This tutorial explores integration of the RAG pattern using Open AI models and vector search capabilities in a .NET app. The sample application performs vector searches on custom data stored in Azure Cosmos DB for MongoDB and further refines the responses using generative AI models, such as GPT-35 and GPT-4. In the sections that follow, you'll set up a sample application and explore key code examples that demonstrate these concepts.

Prerequisites

• .NET 8.0 installed
• AnAzure Account
• AnAzure Cosmos DB for MongoDB vCore service
• AnAzure Open AI service
  • Deploytext-embedding-ada-002 model for embeddings
  • Deploygpt-35-turbo model for chat completions

App overview

The Cosmos Recipe Guide app allows you to perform vector and AI driven searches against a set of recipe data. You can search directly for available recipes or prompt the app with ingredient names to find related recipes. The app and the sections ahead guide you through the following workflow to demonstrate this type of functionality:

1. Upload sample data to an Azure Cosmos DB for MongoDB database.

2. Create embeddings and a vector index for the uploaded sample data using the Azure OpenAItext-embedding-ada-002 model.

3. Perform vector similarity search based on the user prompts.

4. Use the Azure OpenAIgpt-35-turbo completions model to compose more meaningful answers based on the search results data.

   

Get started

1. Clone the following GitHub repository:

   git clone https://github.com/microsoft/AzureDataRetrievalAugmentedGenerationSamples.git

2. In theC#/CosmosDB-MongoDBvCore folder, open theCosmosRecipeGuide.sln file.

3. In theappsettings.json file, replace the following config values with your Azure OpenAI and Azure CosmosDB for MongoDb values:

   "OpenAIEndpoint": "https://<your-service-name>.openai.azure.com/","OpenAIKey": "<your-API-key>","OpenAIEmbeddingDeployment": "<your-ADA-deployment-name>","OpenAIcompletionsDeployment": "<your-GPT-deployment-name>","MongoVcoreConnection": "<your-Mongo-connection-string>"

4. Launch the app by pressing theStart button at the top of Visual Studio.

Explore the app

When you run the app for the first time, it connects to Azure Cosmos DB and reports that there are no recipes available yet. Follow the steps displayed by the app to begin the core workflow.

1. SelectUpload recipe(s) to Cosmos DB and pressEnter. This command reads sample JSON files from the local project and uploads them to the Cosmos DB account.

   The code from theUtility.cs class parses the local JSON files.

   public static List<Recipe> ParseDocuments(string Folderpath){    List<Recipe> recipes = new List<Recipe>();    Directory.GetFiles(Folderpath)        .ToList()        .ForEach(f =>        {            var jsonString= System.IO.File.ReadAllText(f);            Recipe recipe = JsonConvert.DeserializeObject<Recipe>(jsonString);            recipe.id = recipe.name.ToLower().Replace(" ", "");            recipes.Add(recipe);        }    );    return recipes;}

   TheUpsertVectorAsync method in theVCoreMongoService.cs file uploads the documents to Azure Cosmos DB for MongoDB.

   public async Task UpsertVectorAsync(Recipe recipe)    {        BsonDocument document = recipe.ToBsonDocument();        if (!document.Contains("_id"))        {            Console.WriteLine("UpsertVectorAsync: Document does not contain _id.");            throw new ArgumentException("UpsertVectorAsync: Document does not contain _id.");        }        string? _idValue = document["_id"].ToString();        try        {            var filter = Builders<BsonDocument>.Filter.Eq("_id", _idValue);            var options = new ReplaceOptions { IsUpsert = true };            await _recipeCollection.ReplaceOneAsync(filter, document, options);        }        catch (Exception ex)        {            Console.WriteLine($"Exception: UpsertVectorAsync(): {ex.Message}");            throw;        }    }

2. SelectVectorize the recipe(s) and store them in Cosmos DB.

   The JSON items uploaded to Cosmos DB do not contain embeddings and therefore are not optimized for RAG via vector search. An embedding is an information-dense, numerical representation of the semantic meaning of a piece of text. Vector searches are able to find items with contextually similar embeddings.

   TheGetEmbeddingsAsync method in theOpenAIService.cs file creates an embedding for each item in the database.

   public async Task<float[]?> GetEmbeddingsAsync(dynamic data){    try    {        EmbeddingsOptions options = new EmbeddingsOptions(data)        {            Input = data        };        var response = await _openAIClient.GetEmbeddingsAsync(openAIEmbeddingDeployment, options);        Embeddings embeddings = response.Value;        float[] embedding = embeddings.Data[0].Embedding.ToArray();        return embedding;    }    catch (Exception ex)    {        Console.WriteLine($"GetEmbeddingsAsync Exception: {ex.Message}");        return null;    }}

   TheCreateVectorIndexIfNotExists in theVCoreMongoService.cs file creates a vector index, which enables you to perform vector similarity searches.

   public void CreateVectorIndexIfNotExists(string vectorIndexName){    try    {        //Find if vector index exists in vectors collection        using (IAsyncCursor<BsonDocument> indexCursor = _recipeCollection.Indexes.List())        {            bool vectorIndexExists = indexCursor.ToList().Any(x => x["name"] == vectorIndexName);            if (!vectorIndexExists)            {                BsonDocumentCommand<BsonDocument> command = new BsonDocumentCommand<BsonDocument>(                    BsonDocument.Parse(@"                        { createIndexes: 'Recipe',                            indexes: [{                            name: 'vectorSearchIndex',                            key: { embedding: 'cosmosSearch' },                            cosmosSearchOptions: {                                kind: 'vector-ivf',                                numLists: 5,                                similarity: 'COS',                                dimensions: 1536 }                            }]                        }"));                BsonDocument result = _database.RunCommand(command);                if (result["ok"] != 1)                {                    Console.WriteLine("CreateIndex failed with response: " + result.ToJson());                }            }        }    }    catch (MongoException ex)    {        Console.WriteLine("MongoDbService InitializeVectorIndex: " + ex.Message);        throw;    }}

3. Select theAsk AI Assistant (search for a recipe by name or description, or ask a question) option in the application to run a user query.

   The user query is converted to an embedding using the Open AI service and the embedding model. The embedding is then sent to Azure Cosmos DB for MongoDB and is used to perform a vector search. TheVectorSearchAsync method in theVCoreMongoService.cs file performs a vector search to find vectors that are close to the supplied vector and returns a list of documents from Azure Cosmos DB for MongoDB vCore.

   public async Task<List<Recipe>> VectorSearchAsync(float[] queryVector)    {        List<string> retDocs = new List<string>();        string resultDocuments = string.Empty;        try        {            //Search Azure Cosmos DB for MongoDB vCore collection for similar embeddings            //Project the fields that are needed            BsonDocument[] pipeline = new BsonDocument[]            {                BsonDocument.Parse(                    @$"{{$search: {{                            cosmosSearch:                                {{ vector: [{string.Join(',', queryVector)}],                                   path: 'embedding',                                   k: {_maxVectorSearchResults}}},                                   returnStoredSource:true                                }}                            }}"),                BsonDocument.Parse($"{{$project: {{embedding: 0}}}}"),            };            var bsonDocuments = await _recipeCollection                .Aggregate<BsonDocument>(pipeline).ToListAsync();            var recipes = bsonDocuments                .ToList()                .ConvertAll(bsonDocument =>                    BsonSerializer.Deserialize<Recipe>(bsonDocument));            return recipes;        }        catch (MongoException ex)        {            Console.WriteLine($"Exception: VectorSearchAsync(): {ex.Message}");            throw;        }    }

   TheGetChatCompletionAsync method generates an improved chat completion response based on the user prompt and the related vector search results.

   public async Task<(string response, int promptTokens, int responseTokens)> GetChatCompletionAsync(string userPrompt, string documents){    try    {        ChatMessage systemMessage = new ChatMessage(            ChatRole.System, _systemPromptRecipeAssistant + documents);        ChatMessage userMessage = new ChatMessage(            ChatRole.User, userPrompt);        ChatCompletionsOptions options = new()        {            Messages =            {                systemMessage,                userMessage            },            MaxTokens = openAIMaxTokens,            Temperature = 0.5f, //0.3f,            NucleusSamplingFactor = 0.95f,            FrequencyPenalty = 0,            PresencePenalty = 0        };        Azure.Response<ChatCompletions> completionsResponse =            await openAIClient.GetChatCompletionsAsync(openAICompletionDeployment, options);        ChatCompletions completions = completionsResponse.Value;        return (            response: completions.Choices[0].Message.Content,            promptTokens: completions.Usage.PromptTokens,            responseTokens: completions.Usage.CompletionTokens        );    }    catch (Exception ex)    {        string message = $"OpenAIService.GetChatCompletionAsync(): {ex.Message}";        Console.WriteLine(message);        throw;    }}

   The app also uses prompt engineering to ensure Open AI service limits and formats the response for supplied recipes.

   //System prompts to send with user prompts to instruct the model for chat sessionprivate readonly string _systemPromptRecipeAssistant = @"    You are an intelligent assistant for Contoso Recipes.    You are designed to provide helpful answers to user questions about    recipes, cooking instructions provided in JSON format below.    Instructions:    - Only answer questions related to the recipe provided below.    - Don't reference any recipe not provided below.    - If you're unsure of an answer, say ""I don't know"" and recommend users search themselves.    - Your response  should be complete.    - List the Name of the Recipe at the start of your response followed by step by step cooking instructions.    - Assume the user is not an expert in cooking.    - Format the content so that it can be printed to the Command Line console.    - In case there is more than one recipe you find, let the user pick the most appropriate recipe.";