Generative AI (GenAI) has emerged as a transformative force across various industries, offering capabilities that revolutionize how data is generated and processed. However, the true potential of GenAI is unleashed when it is seamlessly embedded into user interfaces. This integration magnifies the power of GenAI, ensuring that its capabilities are not confined to isolated tools but are deeply woven into the fabric of everyday user interactions. By embedding GenAI into UIs, businesses can achieve more intuitive, responsive, and intelligent systems that enhance user engagement and streamline operations.

Incorporating GenAI directly into UIs is not merely a technical enhancement—it represents a fundamental shift in how applications are developed and experienced.

Historically, Business Intelligence (BI) and data science solutions have struggled with adoption challenges due to being disconnected from operational UIs. Consequently, for next-generation UI builder libraries and applications, facilitating the embedding of GenAI becomes a critical priority. This involves creating frameworks and platforms that enable effortless integration, allowing developers to leverage GenAI’s capabilities to their fullest extent. By supporting GenAI integration, UI builders can drive more sophisticated and user-centric design patterns, catalyzing a new era of digital interfaces that are both powerful and seamlessly intuitive. The potential benefits for businesses are significant—ranging from improved user satisfaction to enhanced data-driven decision-making, making the case for GenAI integration all the more compelling.

Our Approach to Embedding GenAI

We recently unveiled a variety of RAI’s powerful features, demonstrating how our AI assistant can take productivity to the next level for different roles in the organization. Our approach enables users to activate the RAI assistant through both UI screen menus, such as those on product detail pages, and context menus within individual widgets, like the product description text editor. Additionally, RAI can be interfaced with directly through APIs, allowing seamless embedding into third-party applications and workflows.

We employ various specialized AI assistants, each dedicated to a specific business domain and fine-tuned with tailored prompts to address particular needs and contexts. These assistants are readily created using our RAI APIs, which prepopulate them with defined prompts and functions, thereby automating actions like assistants.create and assistants.update with OpenAI. These setups can be further customized using OpenAI's native assistant interface, including adjustments for fine-tuning to optimize performance.

From our UI builder, developers can select which assistants to associate with specific actions, providing flexibility and precision in how GenAI is deployed throughout the application. Once a user triggers RAI from a menu, the system initiates a new session thread with the chosen assistant, sustaining the interaction with OpenAI for the duration of RAI's active state on the screen. This maintains a continuous and cohesive dialogue between the user and the AI.

Below is a simplified code block illustrating this operational flow:

// Initialize a new thread if no threadId exists

if (!threadId) {
    threadId = await createNewThread();
}

// Initiate a run and await initial response

const run = await createAndPoll(assistantId, threadId, content);

/*
Recursive function to process tool results.

When run.status === "requires_action":
- Executes a local function as per "tool_calls"
- Aggregates their output into toolResults
- Executes submitToolOutputsAndPoll for next steps

When run.status === "completed":
- Returns all aggregated tool results
*/

const toolResults = await handleRunStatus(run);

The standard return values from our local function calls include:

• action: Specifies the type of action for the UI to execute, such as create_record, applicable to tasks that require data modification.

• props: Parameters necessary for executing the defined action, like the specifics of a data record to be created.

• feedback: Additional prompts sent to OpenAI for instances where the function needs to invoke further logic or impose constraints.

This structured approach not only facilitates seamless integration but also ensures that GenAI capabilities are leveraged to enhance user interactions and data management processes.

Use Case: Master Data Management

GenAI significantly enhances the automated creation of business records, such as product catalogs and customer profiles, through structured data generation processes. By utilizing JSON schema to define data attributes and constraints, developers can facilitate seamless integration and maintain high standards of data integrity.

A refined approach involves utilizing dedicated AI models that are fine-tuned for specific business domains. By leveraging existing business records, such as historical product data, these models can be optimized with domain-specific datasets, enhancing the accuracy and relevance of generated outputs. This fine-tuning allows the AI to grasp specialized terminology and context, essential for producing precise records.

The record creation process should be iterative, with GenAI's capabilities enabling continuous interaction to refine and improve the results. Through continuous communication with GenAI APIs, businesses can ensure that the generated data becomes progressively more accurate and contextually relevant, adapting to new inputs and feedback dynamically.

At Rierino, we already employ JSON schemas for our data model definitions, which positions us to seamlessly integrate this into our user interfaces via OpenAI assistant APIs. This integration allows us to automate the generation of precise, contextually relevant records with minimal manual input. A simplified set of function calls we use are as follows:

For retrieving JSON schema for any specific business domain, which is called at the beginning of any new thread to ensure that latest data model is used by the AI assistant:

{
    "type": "function",
    "function": {
        "name": "get_json_schema",
        "description": "Retrieves the json schema for the given name.",
        "parameters": {
            "type": "object",
            "properties": {
                "name": {
                  "type": "string",
                  "description": "Json schema name to pull"
                }
            }
        }
    }
}

For populating data back to our UI:

{
    "type": "function",
    "function": {
        "name": "populate_data",
        "description": "Passes provided content to user interface for display.",
        "parameters": {
            "type": "object",
            "properties": {
              "data": {
                "type": "string",
                "description": "Content to display for provided json schema as a valid json string"
              }
            }
        }
    }
}

Upon activation of our AI assistant, known as RAI, on any interface screen, we initiate a new GenAI thread for the user. This thread facilitates continuous interaction with the assistant, enabling incremental data editing through successive prompts. Users can instruct RAI to enhance or rephrase specific data elements, thereby refining the output iteratively.

Use Case: Smart Text Widgets

Integrating GenAI within individual UI components, such as input widgets, enhances user interaction by automating and enriching data input processes. This allows users access to AI-driven suggestions for fields like product descriptions, translations, and content revisions, effectively streamlining workflows and improving data quality.

Through GenAI integration, widgets can dynamically offer real-time content generation and context-aware suggestions, transforming typical data-entry tasks into intelligent, interactive experiences. By offloading repetitive input tasks onto AI, users can focus on higher-level decision-making and analysis, enhancing overall efficiency.

The next generation of UI widgets should inherently incorporate GenAI features, analogous to how validation libraries are currently a built-in standard. Just as validation libraries automatically handle data integrity and user input accuracy, GenAI integration can bring dynamic intelligence directly to the user interface, enhancing interactivity and personalization.

At Rierino, we've enabled our widgets to integrate seamlessly with GenAI through our RAI assistant. This integration features a special pop-up tool that allows users to edit or receive feedback in any input editor. A simplified set of function calls we use are as follows:

For populating data back to our UI based on the user prompts:

{
    "type": "function",
    "function": {
        "name": "submit_content",
        "description": "Passes produced content to user interface for display.",
        "parameters": {
            "type": "object",
            "properties": {
              "content": {
                "type": "string",
                "description": "Content that is produced based on given directions."
              }
            }
        }
    }
}

For generating translations using our localized editors:

{
    "type": "function",
    "function": {
        "name": "submit_translation",
        "description": "Passes produced translations to user interface for display.",
        "parameters": {
          "type":"object",
          "properties":{
            "translations":{
              "type": "array",
              "description": "List of translations by language",
              "items": {
                "type": "object",
                "properties":{
                  "language": {
                    "type": "string",
                    "description": "Language of translation"
                  },
                  "text": {
                    "type": "string",
                    "description": "Translated content"
                  }
                }
              }
            }
          }
        }
    }
}

Much like the master data management use case, our RAI assistant establishes a feedback loop within the created thread, allowing users to iteratively enhance and refine the generated content through interactive engagement.

Use Case: Rich Content Creation

The integration of GenAI into rich content editors, such as markdown, handlebars, and HTML editors, significantly enhances content creation and management capabilities. GenAI provides users with advanced tools to draft, revise, and format content, ensuring that it meets high standards of quality and consistency.

By embedding GenAI into content editing environments, businesses can streamline the editorial process. Users benefit from AI-driven suggestions for content generation, structural formatting, and language enhancements, which enable the efficient creation of polished, professional-grade content with minimal manual effort. This enables content creators to focus more on strategic messaging and less on the mechanics of document creation.

Beyond simple text generation, GenAI can also suggest multimedia elements, keyword optimizations, and structural improvements, tailoring content to specific audiences and platforms. This functionality is especially beneficial for digital marketing, blogging, and content-heavy platforms needing to produce high volumes of targeted communications.

At Rierino, our markdown, handlebars, and HTML editors are equipped to leverage OpenAI for generating and enhancing rich content. Through seamless integration with OpenAI, these editors can assist in crafting content specifically tailored for both web and mobile applications. These editors use a function set similar to the smart text widgets use case with special prompts guiding RAI assistant to follow specific syntax in produced content.

Use Case: Augmented Search and Query

GenAI's integration into search and query functionalities revolutionizes how users interact with databases by leveraging natural language processing (NLP). This advancement allows users to perform complex queries using everyday language, which the system then converts into precise machine-readable queries.

The power of NLP in GenAI simplifies querying by eliminating the need for users to understand complex query languages like SQL. Instead, users can articulate their data requests in natural language, enabling broader access to powerful data retrieval and analysis tools. This democratization of data access enhances user engagement and supports more informed decision-making, as users can easily extract valuable insights from large datasets.

NLP capabilities in GenAI facilitate smart, intuitive search functionalities that can dynamically filter, sort, and analyze data in real time. This is particularly useful in domains with extensive data records where traditional methods may prove cumbersome or inefficient.

At Rierino, we leverage GenAI to generate queries in our abstract syntax that is compatible with both SQL and non-SQL databases, providing users with flexible and powerful data interaction tools. This capability ensures that users can extract the necessary insights regardless of the underlying database architecture. For those interested in a deeper dive into our approach and the technical nuances of GenAI integration with database systems, we have detailed this process in another article on GenAI. This further elucidates how Rierino utilizes AI to enhance data querying and management.

Advancing UI Integration with GenAI

The embedding of Generative AI into user interfaces represents a critical evolution in application architecture, allowing for a deeper fusion of AI capabilities with user-driven operations. As we've demonstrated across various use cases—ranging from smart data management to rich content creation—the integration of GenAI enhances the functionality of UIs, making them more responsive, context-aware, and capable of handling complex user demands.

From a development perspective, this shift isn’t just about adding another tool to the stack. It’s about building systems that leverage GenAI at their core, enabling seamless interaction between users and large learning models. The practical application of AI within UI components, such as automated data inputs or augmented search functions, creates more dynamic and intelligent environments that adapt to user behavior in real-time.

At Rierino, our approach to integrating GenAI through frameworks like RAI is designed to support extensibility, precision, and flexibility. We’ve focused on building a robust architecture that allows for iterative improvements in how AI interacts with users, ensuring that the system can evolve alongside user requirements. By embedding GenAI deeply into the UI layer, we’re enabling developers to create more sophisticated interfaces that not only enhance user experience but also reduce friction in operational workflows.

As we continue to explore the possibilities of AI-driven UIs, the emphasis will remain on creating frameworks that support the scalability and adaptability required for complex, real-world applications. This approach ensures that the benefits of GenAI can be fully realized within a wide range of business domains, driving more intelligent, efficient, and user-centric designs.

Get in touch with us today if you are interested in a deeper dive into our approach, and learn how we can help elevate your platform's capabilities.