Test Cloud admin guide

Working with Context Grounding

Getting started​

Managing the ingestion pipeline​

• Orchestrator or Agents, from the Indexes page. See Managing indexes.
• The Update Context Grounding Index activity, part of the UiPath GenAI activities package.

Querying data with Context Grounding​

• In Autopilot for Everyone, Context Grounding enhances user interactions by enabling searches across existing indexes to provide accurate answers to queries. For details, refer to Context Grounding in Autopilot for Everyone.
• GenAI Activities benefit from Context Grounding by allowing content generation based on information stored in permissioned knowledge bases. For details, refer to GenAI Activities.
• For agents, indexes play a crucial role in providing context during runs. For details, refer to Contexts.

1. Place a Log Message activity immediately after the Content Generation activity in your workflow sequence.
2. Use the following output variables to capture specific information:
   • Top Generated Text: View the LLM generation response after workflow execution.
   • Citations: Examine the semantic search results that influenced the generation output. This works only for PDF and JSON data types.

Context Grounding in GenAI Activities​

1. Establish your data source for Context Grounding.
   • Context Grounding follows shared folder permissions. Use a folder with appropriate access to manage and query from data.
   • Create a connection to the supported Integration Service data sources or add data to a shared Orchestrator bucket location.
2. Ingest data from your data source into Context Grounding.
   • Create and sync indexes in Orchestrator.
   • Use the Update Context Grounding Index activity to sync an index you have created.
3. Query and ground prompts with your data.
   • Use the Content Generation activity, agents, or Autopilot for Everyone to query over documents and use information to augment or ground prompts.

Common Context Grounding patterns​

• Data extraction and comparison: Context Grounding can automatically identify and extract specific types of information from documents, then compare them in meaningful ways. Imagine you have a stack of résumés and want to compare candidates' work experiences. The service could extract job titles, durations, and responsibilities, then present them in a way that makes comparison easy, even if the information is formatted differently in each résumé.
• Summarization: Context Grounding can create summaries of long documents or multiple related documents. It doesn't pick out random sentences, but understands the key points and overall message. For example, if you have a long report on market trends, the service can provide a summary highlighting the main findings, key statistics, and overall conclusions.

Notifications​

• Ingestion Job Completed
• Ingestion Job Failed
• Ingestion Job Started

Bringing your own vector database​

• Query an external vector database from a UiPath agent.
• Return the most relevant content as structured context.
• Ground agent responses in your organization’s data securely and in real time.

• Your data is already indexed in an external vector store.
• You want agents to access up-to-date enterprise knowledge.
• You need to avoid copying or re-indexing data into UiPath.
• You require full control over data storage, security, and embeddings.

How it works​

1. User query: The user submits a prompt to the agent.
2. Tool selection: The agent’s LLM determines that additional context is required and selects the custom vector search tool.
3. API Workflow execution: The agent invokes the published API Workflow, passing the user’s query as input.
4. Vector search: The workflow queries the vector database to retrieve the most semantically relevant content.
5. Context return: The workflow returns the retrieved content as structured JSON.
6. Response formulation: The agent uses this context to generate a grounded, accurate response.

Architecture overview​

• Vector database: Your existing system (for example, Databricks Vector Search or Azure AI Search).
• API workflow: A UiPath Integration Service workflow that:
  • Accepts a query.
  • Calls the vector database API.
  • Returns relevant results.
• Agent tool: The published API Workflow, added as a tool that the agent can invoke.

Security and credential management​

• Store credentials in Orchestrator: Add your API keys and other secrets as credential assets in your Orchestrator tenant. This provides centralized, secure management of sensitive information.
• Retrieve credentials at runtime: In your API Workflow, use the Get Credential activity to access stored credentials when the workflow runs. The activity returns the username as a string and the password (for example, an API key) as a SecureString, preventing secrets from being exposed in logs or workflow definitions.

Prerequisites​

• An active vector database (such as Databricks Vector Search or Azure AI Search) with indexed data.
• A valid API endpoint and authentication credentials stored as credential assets in Orchestrator.
• An embedding model endpoint and key, also stored securely (for Azure client-side vectorization only).

Setup​

Databricks vector search (model-native endpoint)​

• A simple configuration
• Only one API call per query
• No separate embedding model required

1. Get the Databricks details:
   1. Retrieve the Endpoint URL.
   2. Store your Databricks Personal Access Token as a credential asset in Orchestrator.
2. In Studio, create a new API workflow project and define the following arguments:
   • in_QueryText (String)
   • in_TopK (Int32, with a default value of 5)
   • out_Results (String)
3. Use the Get Credential activity to retrieve the Databricks Personal Access Token from Orchestrator at runtime.
4. Add an HTTP Request activity to call the Databricks endpoint:
   • Endpoint: the Databricks Vector Search endpoint
   • Method: POST
   • Headers: Authorization: Bearer <Personal Access Token>
   • Body: Construct the JSON body required by the Databricks API, mapping your input variables.
5. Publish the workflow to your Orchestrator tenant.
6. Add the workflow as a tool to your agent, providing a clear name and description for the LLM to use.

Azure AI Search (client-side vectorization)​

• Full control over embedding models
• Compatibility with existing vector indexes

1. Get the API details:
   • For Azure AI Search: Retrieve the Endpoint URL, Index name, and store your API Key as a credential asset in Orchestrator.
   • For the embedding model: Retrieve the Endpoint URL and store the API Key for your embedding service as a credential asset in Orchestrator.
2. In Studio, create a new API workflow project and define the following arguments:
   • in_QueryText (String)
   • in_TopK (Int32, with a default value of 5)
   • out_Results (String)
3. First, vectorize the query:
   1. Add a Get Credential activity to retrieve your embedding model's API key.
   2. Add an HTTP Request activity to call your embedding model with the in_QueryText.
   3. Deserialize the JSON response and store the resulting embedding vector in a variable (e.g., queryVector).
4. Query Azure AI Search:
   1. Add a Get Credential activity to retrieve your Azure AI Search API key.
   2. Add a HTTP Request activity and configure it as follows:
      • Endpoint: Your Azure AI Search endpoint.
      • Method: POST.
      • Headers: Add an api-key header with your Azure AI Search API key variable, as follows: api-key: <API key>.
      • Body: Construct the JSON body for the Azure AI Search vector search query, embedding your queryVector variable.
5. Publish the workflow to your Orchestrator tenant.
6. Add the published workflow as a tool to your agent, providing a clear description for the LLM to use.

Azure AI Search (integrated vectorization)​

• Simplest Azure setup
• No embedding calls in the workflow
• Single API request per query

1. Get the API details:
   • Retrieve your Azure AI Search Endpoint URL, Index name, and store your API Key as a credential asset in Orchestrator.
2. In Studio, create a new API workflow project and define the following arguments:
   • in_QueryText (String)
   • in_TopK (Int32, with a default value of 5)
   • out_Results (String)
3. Add a Get Credential activity to retrieve your Azure AI Search API key from Orchestrator.
4. Add an HTTP Request activity and configure it as follows:
   • Endpoint:
     assignment

     https://<service>.search.windows.net/indexes/<index-name>/docs/search?api-version=2023-11-01
     https://<service>.search.windows.net/indexes/<index-name>/docs/search?api-version=2023-11-01
     

   • Method: POST
   • Headers: Add an api-key header with your Azure AI Search API key variable, as follows: api-key: <API key>
   • Body: Construct the JSON body to perform a vector search using the query text. Azure AI Search handles vectorization automatically.
     assignment

     {
       "vectorQueries": [
         {
           "kind": "text",
           "text": "<%= in_QueryText %>",
           "fields": "contentVector",
           "k": "<%= in_TopK %>"
         }
       ],
       "select": "chunk, source_document"
     }
     {
       "vectorQueries": [
         {
           "kind": "text",
           "text": "<%= in_QueryText %>",
           "fields": "contentVector",
           "k": "<%= in_TopK %>"
         }
       ],
       "select": "chunk, source_document"
     }
     

5. Publish the workflow to your Orchestrator tenant.
6. Add the published workflow as a tool to your agent, providing a clear description for the LLM.

Frequently asked questions​

• Managed Vector DB as a Service: We make it easy for you to convert your data into embedding representations.
• Retrieval Augmented Generation (RAG) as a Service: Context Grounding queries data from various automation products, retrieves the most relevant results, and augments prompts with those results to ensure generations are more specific.

• Index limit: There is a limit of ten indices per tenant. We recommend you maintain a 1-1 relationship between Orchestrator buckets from which you are ingesting data to prevent data leak across folders and ensure logical separation of data that may need to be queried by different users for different purposes. Context Grounding takes advantage of folder authorization permissions to help enforce this recommendation.
• Storage: There is no limit on storage across or within these indices. However, we impose some limits on customers who have exceedingly high amount of data ingested.