Building an AI Agent with Semantic Kernel, C#, OpenAI and MongoDB Atlas

1
export OPENAI_API_KEY=”<REPLACE WITH YOUR OPEN AI API KEY>” # MacOS/Linux
2
set OPENAI_API_KEY=”<REPLACE WITH YOUR OPEN AI API KEY>” # Windows”
3
4
export OPENAI_MODEL_NAME=”<REPLACE WITH YOUR MODEL OF CHOICE>” 
5
set OPENAI_MODEL_NAME_”<REPLACE WITH YOUR MODEL OF CHOICE>”
6
7
export MONGODB_ATLAS_CONNECTION_STRING=”<YOUR MONGODB ATLAS CONNECTION STRING>”
8
set MONGODB_ATLAS_CONNECTION_STRING=”<YOUR MONGODB ATLAS CONNECTION STRING>” 

1
string apiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY") ?? throw new ArgumentNullException("Environment.GetEnvironmentVariable(\"OPENAI_API_KEY\")");
2
string modelName = Environment.GetEnvironmentVariable("OPENAI_MODEL_NAME") ?? "gpt-4o-mini";

1
await GenerateEmbeddingsForCuisine();

1
dotnet run

1
var builder = Kernel.CreateBuilder();
2
3
builder.Services.AddOpenAIChatCompletion(
4
    modelName,
5
    apiKey);
6
7
var kernel = builder.Build();

1
[KernelFunction, Description("Get a list of available ingredients")]
2
        public static string GetIngredientsFromCupboard()
3
        {
4
            // Ensures that the file path functions across all operating systems.
5
            string baseDir = AppContext.BaseDirectory;
6
            string projectRoot = Path.Combine(baseDir, "..", "..", "..");
7
            string filePath = Path.Combine(projectRoot, "Data", "cupboardinventory.txt");
8
            return File.ReadAllText(filePath).ToLower();
9
        }

1
using System.ComponentModel;
2
using Microsoft.SemanticKernel;

1
kernel.ImportPluginFromType<IngredientsPlugin>();

1
{
2
  "schema": 1,
3
  "type": "completion",
4
  "description": "Identify the cuisine of the user's requested meal",
5
  "execution_settings": {
6
    "default": {
7
      "max_tokens": 800,
8
      "temperature": 0
9
    }
10
  },
11
  "input_variables": [
12
    {
13
      "name": "cuisine",
14
      "description": "Text from the user that contains their requested meal",
15
      "required": true
16
    }
17
  ]
18
}

1
Return a single word that represents the cuisine of the requested meal that is sent: {{$cuisine}}.
2
3
For example, if the meal is mac and cheese, return American. Or for pizza it would be Italian.
4
Do not return any extra words, just return the single name of the cuisine.

1
string baseDir = AppContext.BaseDirectory;
2
string projectRoot = Path.Combine(baseDir, "..", "..", "..");
3
var plugins = kernel.CreatePluginFromPromptDirectory(projectRoot + "/Prompts");

1
using FoodAgentDotNet.Models;
2
using Microsoft.SemanticKernel;
3
using Microsoft.SemanticKernel.Connectors.MongoDB;
4
using Microsoft.SemanticKernel.Connectors.OpenAI;
5
using Microsoft.SemanticKernel.Memory;
6
using MongoDB.Driver;
7
using System;
8
using System.Collections.Generic;
9
using System.ComponentModel;
10
using System.Linq;
11
using System.Text;
12
using System.Threading.Tasks;
13
14
namespace FoodAgentDotNet.Plugins;

1
#pragma warning disable
2
public class RestaurantsPlugin
3
{
4
    static readonly string mongoDBConnectionString = Environment.GetEnvironmentVariable("MONGODB_ATLAS_CONNECTION_STRING");
5
    static readonly string openAIApiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
6
7
    [KernelFunction, Description("Find a restaurant to eat at")]
8
    public static async Task<List<Restaurant>> GetRecommendedRestaurant(
9
           [Description("The cuisine to find a restaurant for")] string cuisine)
10
    {
11
        var mongoDBMemoryStore = new MongoDBMemoryStore(mongoDBConnectionString, "sample_restaurants", "restaurants_index");
12
        var memoryBuilder = new MemoryBuilder();
13
        memoryBuilder.WithOpenAITextEmbeddingGeneration(
14
            "text-embedding-3-small",
15
            openAIApiKey    );
16
        memoryBuilder.WithMemoryStore(mongoDBMemoryStore);
17
        var memory = memoryBuilder.Build();
18
19
        var restaurants = memory.SearchAsync(
20
            "embedded_cuisines",
21
            cuisine,
22
            limit: 5,
23
            minRelevanceScore: 0.5
24
            );
25
26
        List<Restaurant> recommendedRestaurants = new();
27
28
        await foreach(var restaurant in restaurants)
29
        {
30
            recommendedRestaurants.Add(new Restaurant
31
            {
32
                Name = restaurant.Metadata.Description,
33
                // We include the cuisine so that the AI has this information available to it
34
                Cuisine = restaurant.Metadata.AdditionalMetadata,
35
            });
36
        }
37
        return recommendedRestaurants;
38
    }
39
}

1
kernel.ImportPluginFromType<RestaurantsPlugin>();

1
{
2
  "fields": [
3
    {
4
      "type": "vector",
5
      "path": "embedding",
6
      "numDimensions": 1536,
7
      "similarity": "cosine"
8
    }
9
  ]
10
}

1
OpenAIPromptExecutionSettings settings = new()
2
{
3
    ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions
4
};

1
Console.WriteLine("What would you like to make for dinner?");
2
var input = Console.ReadLine();

1
string ingredientsPrompt = @"This is a list of ingredients available to the user:
2
{{IngredientsPlugin.GetIngredientsFromCupboard}}
3
4
Based on their requested dish " + input + ", list what ingredients they are missing from their cupboard to make that meal and return just the list of missing ingredients. If they have similar items such as pasta instead of a specific type of pasta, don't consider it missing";

1
var ingredientsResult = await kernel.InvokePromptAsync(ingredientsPrompt, new(settings));
2
3
var missing = ingredientsResult.ToString().ToLower()
4
    .Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
5
    .Where(line => line.StartsWith("- "))
6
    .ToList();

1
var cuisineResult = await kernel.InvokeAsync(
2
    plugins["GetCuisine"],
3
    new() { { "cuisine", input } }
4
);
5
6
if (missing.Count >= 5)
7
{
8
    string restaurantPrompt = @"This is the cuisine that the user requested: " + cuisineResult + @". Based on this cuisine, recommend a restaurant for the user to eat at. Include the name and address
9
    {{RestaurantsPlugin.GetRecommendedRestaurant}}";
10
11
    var kernelArguments = new KernelArguments(settings)
12
    {
13
        { "cuisine", cuisineResult }
14
    };
15
16
    var restaurantResult = await kernel.InvokePromptAsync(restaurantPrompt, kernelArguments);
17
18
    Console.WriteLine($"You have so many missing ingredients ({missing.Count}!), why bother? {restaurantResult}");
19
}
20
else if(missing.Count < 5 && missing.Count > 0)
21
{
22
    Console.WriteLine($"You have most of the ingredients to make {input}. You are missing: ");
23
    foreach (var ingredient in missing)
24
    {
25
        Console.WriteLine(ingredient);
26
    }
27
    string similarPrompt = @"The user requested to make " + input + @" but is missing some ingredients. Based on what they want to eat, suggest another meal that is similar from the " + cuisineResult + " cuisine they can make and tell them the name of it but do not return a full recipe";
28
    var similarResult = await kernel.InvokePromptAsync(similarPrompt, new(settings));
29
30
    Console.WriteLine(similarResult);
31
}
32
else {
33
    Console.WriteLine("You have all the ingredients to make " + input + "!");
34
    string recipePrompt = @"Find a recipe for making " + input;
35
    var recipeResult = await kernel.InvokePromptAsync(recipePrompt, new(settings));
36
    Console.WriteLine(recipeResult);
37
}