GenAI Integration: API


  • A GenAI task leverages an AI model to enable intelligent processing of documents in runtime.

    • The task is associated with a document collection and with an AI model.
    • It is an ongoing task that:
      1. Continuously monitors the collection;
      2. Whenever needed, like when a document is added to the collection, generates user-defined context objects based on the source document data;
      3. Passes each context object to the AI model for further processing;
      4. Receives the AI model's JSON-based results;
      5. And finally, runs a user-defined script that potentially acts upon the results.
  • The main steps in defining a GenAI task are:

  • In this article:


Defining a Connection string

  • Choose the model to connect with, by what you need from your GenAI task.
    E.g., If you require security and speed above all for the duration of a rapid development phase, you may prefer a local AI service like Ollama.
  • Make sure you define the correct service: both Ollama and OpenAI are supported but you need to pick an Ollama/OpenAI service that supports generative AI, like Ollama llama3.2 or OpenAI gpt-4o-mini.
  • Learn more about connection strings here.

Example:

using (var store = new DocumentStore())
{
    // Define the connection string to Ollama
    var connectionString = new AiConnectionString
    {
        // Connection string name & identifier
        Name = "ollama-cs", 
        
        // Ollama connection settings
        OllamaSettings = new OllamaSettings(
            // LLM Ollama model for text generation
            model: "llama3.2",
            // local Ollama mode URL
            uri: "http://localhost:11434/")
    };
    
    // Deploy the connection string to the server
    var operation = new PutConnectionStringOperation<AiConnectionString>(connectionString);
    var putConnectionStringResult = store.Maintenance.Send(operation);
}
using (var store = new DocumentStore())
{
    // Define the connection string to Ollama
    var connectionString = new AiConnectionString
    {
        // Connection string name & identifier
        Name = "open-ai-cs",

        // Ollama connection settings
        OpenAiSettings = new OpenAiSettings(
            apiKey: "your-api-key",
            endpoint: "https://api.openai.com/v1",
            // LLM Ollama model for text generation
            model: "gpt-4o-mini")
    };

    // Deploy the connection string to the server
    var operation = new PutConnectionStringOperation<AiConnectionString>(connectionString);
    var putConnectionStringResult = store.Maintenance.Send(operation);
}

Syntax:

public class AiConnectionString
{
    public string Name { get; set; }
    public string Identifier { get; set; }
    public OllamaSettings OllamaSettings { get; set; }
}

public class OllamaSettings : AbstractAiSettings
{
    public string Model { get; set; }
    public string Uri { get; set; }
}
public class AiConnectionString
{
    public string Name { get; set; }
    public string Identifier { get; set; }
    public OpenAiSettings OpenAiSettings { get; set; }
}

public class OpenAiSettings : AbstractAiSettings
{
    public string ApiKey { get; set; }
    public string Endpoint { get; set; }
    public string Model { get; set; }
    public int? Dimensions { get; set; }
    public string OrganizationId { get; set; }
    public string ProjectId { get; set; }
}

public class AbstractAiSettings
{
    public int? EmbeddingsMaxConcurrentBatches { get; set; }
}

Defining the GenAI task

  • Define a GenAI task using a GenAiConfiguration object.
  • Run the task using AddGenAiOperation.

GenAiConfiguration config = new GenAiConfiguration
{
    // Task name
    Name = "FilterSpam",

    // Unique task identifier
    Identifier = "FilterSpam",

    // Connection string to AI model
    ConnectionStringName = "ollama-cs",

    // Task is enabled
    Disabled = false,

    // Collection associated with the task
    Collection = "Posts",

    // Context generation script - format for objects to be sentto the AI model
    GenAiTransformation = new GenAiTransformation {
        Script = @"
            for(const comment of this.Comments)
            {
                ai.genContext({Text: comment.Text, Author: comment.Author, Id: comment.Id});}"
    },

    // AI model Prompt - the instructions sent to the AI model
    Prompt = "Check if the following blog post comment is spam or not",

    // JSON schema - a sample response object to format AI model replies by
    SampleObject = JsonConvert.SerializeObject(
        new
        {
            Blocked = true,
            Reason = "Concise reason for why this comment was marked as spam or ham"
        }),

    // Update script - specifies what to do with AI model replies
    UpdateScript = @"    
            // Find the comment
            const idx = this.Comments.findIndex(c => c.Id == $input.Id);  
            // Was detected as spam
            if($output.Blocked)
            {
                // Remove this comment
                this.Comments.splice(idx, 1);
            }",

    // Max concurrent connections to AI model
    MaxConcurrency = 4
};

// Run the task
var GenAiOperation = new AddGenAiOperation(config);
var addAiIntegrationTaskResult = store.Maintenance.Send(GenAiOperation);

GenAiConfiguration

Parameters Type Description
Name string Task name
Identifier string Unique task identifier, embedded in documents metadata to indicate they were processed along with hash codes for their processed parts
ConnectionStringName string Connection string name
Disabled bool Determines whether the task is enabled or disabled
Collection string Name of the document collection associated with the task
GenAiTransformation GenAiTransformation Context generation script - format for objects to be sent to the AI model
Prompt string AI model Prompt - the instructions sent to the AI model
SampleObject string JSON schema - a sample response object to format AI model replies by
UpdateScript string Update script - specifies what to do with AI model replies
MaxConcurrency int Max concurrent connections to the AI model (each connection serving a single context object