feat: Article 2/3 - Select Algorithm samples (5 languages)

ai/select-algorithm-dotnet/.devcontainer/devcontainer.json

@@ -0,0 +1,48 @@
+{
+  "name": "Azure DocumentDB Select Algorithm - .NET 8",
+  "image": "mcr.microsoft.com/devcontainers/dotnet:1-8.0-bookworm",
+
+  "features": {
+    "ghcr.io/devcontainers/features/azure-cli:1": {},
+    "ghcr.io/devcontainers/features/github-cli:1": {},
+    "ghcr.io/devcontainers/features/common-utils:2": {
+      "installZsh": true,
+      "configureZshAsDefaultShell": true,
+      "installOhMyZsh": true
+    }
+  },
+
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "ms-dotnettools.csdevkit",
+        "ms-dotnettools.vscodeintellicode-csharp",
+        "ms-azuretools.vscode-azureresourcegroups",
+        "ms-azuretools.vscode-cosmosdb",
+        "mongodb.mongodb-vscode"
+      ],
+      "settings": {
+        "dotnet.completion.showCompletionItemsFromUnimportedNamespaces": true,
+        "files.exclude": {
+          "**/bin": true,
+          "**/obj": true
+        }
+      }
+    }
+  },
+
+  "postCreateCommand": "dotnet restore && dotnet build",
+  "remoteUser": "vscode",
+
+  "containerEnv": {
+    "DOTNET_CLI_TELEMETRY_OPTOUT": "1",
+    "DOTNET_NOLOGO": "1"
+  },
+
+  "mounts": [
+    "source=${localEnv:HOME}${localEnv:USERPROFILE}/.azure,target=/home/vscode/.azure,type=bind,consistency=cached"
+  ],
+
+  "capAdd": ["SYS_PTRACE"],
+  "securityOpt": ["seccomp:unconfined"]
+}

ai/select-algorithm-dotnet/.gitignore

@@ -0,0 +1,7 @@
+bin/
+obj/
+.env
+
+# Local data copy (user copies from ai/data/)
+data/*.json
+!data/README.md

ai/select-algorithm-dotnet/AlgorithmRunner.cs

@@ -0,0 +1,197 @@
+using System.Diagnostics;
+using MongoDB.Driver;
+using MongoDB.Bson;
+using OpenAI.Embeddings;
+using SelectAlgorithm.Models;
+
+namespace SelectAlgorithm;
+
+public static class AlgorithmRunner
+{
+    private record IndexConfig(string Name, string Kind, string Similarity, BsonDocument ExtraParams);
+
+    public static void RunSingleAlgorithm(AppConfiguration config, string algorithm)
+    {
+        Console.WriteLine(new string('=', 60));
+        Console.WriteLine($"  {algorithm.ToUpper()} Vector Search");
+        Console.WriteLine(new string('=', 60));
+
+        var mongoClient = Utils.GetMongoClientPasswordless(config);
+        var embeddingClient = Utils.GetEmbeddingClient(config);
+
+        try
+        {
+            var database = mongoClient.GetDatabase(config.DocumentDB.DatabaseName);
+
+            var collectionName = $"hotels_{algorithm}";
+            var collectionNames = database.ListCollectionNames().ToList();
+            if (collectionNames.Contains(collectionName))
+            {
+                database.DropCollection(collectionName);
+                Console.WriteLine($"Dropped existing '{collectionName}' collection.");
+            }
+
+            var collection = database.GetCollection<BsonDocument>(collectionName);
+
+            var data = Utils.ReadJsonFile(config.DataFiles.WithVectors);
+            var documents = data.Where(d => d.Contains(config.Embedding.EmbeddedField)).ToList();
+            Console.WriteLine($"\nLoaded {documents.Count} documents with embeddings");
+            Utils.InsertData(collection, documents, config.DocumentDB.LoadBatchSize);
+
+            Console.WriteLine($"\nQuery: \"{config.VectorSearch.Query}\"");
+            var embeddingResult = embeddingClient.GenerateEmbedding(config.VectorSearch.Query);
+            var queryVector = embeddingResult.Value.ToFloats().ToArray();
+            Console.WriteLine("Embedding generated\n");
+
+            var indexConfig = BuildIndexConfig(algorithm, config.Embedding.Dimensions);
+            Console.WriteLine($"Creating {algorithm} index...");
+            CreateIndex(collection, config.Embedding.EmbeddedField, indexConfig);
+
+            Console.WriteLine("Waiting for index to build...");
+            Thread.Sleep(5000);
+
+            Console.WriteLine("Running search...\n");
+            var sw = Stopwatch.StartNew();
+            var results = RunVectorSearch(collection, queryVector, config.Embedding.EmbeddedField, indexConfig.Name, config.VectorSearch.TopK, algorithm);
+            sw.Stop();
+
+            PrintResults(results, algorithm, sw.ElapsedMilliseconds);
+        }
+        finally
+        {
+            mongoClient.Cluster.Dispose();
+        }
+    }
+
+    private static IndexConfig BuildIndexConfig(string algorithm, int dimensions)
+    {
+        var algo = algorithm.ToLower();
+        return algo switch
+        {
+            "ivf" => new IndexConfig(
+                $"vector_ivf",
+                "vector-ivf",
+                "COS",
+                new BsonDocument { { "numLists", 1 } }
+            ),
+            "hnsw" => new IndexConfig(
+                $"vector_hnsw",
+                "vector-hnsw",
+                "COS",
+                new BsonDocument { { "m", 16 }, { "efConstruction", 64 } }
+            ),
+            "diskann" => new IndexConfig(
+                $"vector_diskann",
+                "vector-diskann",
+                "COS",
+                new BsonDocument { { "maxDegree", 32 }, { "lBuild", 50 } }
+            ),
+            _ => throw new ArgumentException($"Unknown algorithm: {algorithm}")
+        };
+    }
+
+    private static void CreateIndex(IMongoCollection<BsonDocument> collection, string vectorField, IndexConfig config)
+    {
+        try
+        {
+            collection.Indexes.DropOne(config.Name);
+        }
+        catch (MongoCommandException)
+        {
+        }
+
+        var cosmosSearchOptions = new BsonDocument
+        {
+            { "kind", config.Kind },
+            { "dimensions", int.Parse(Environment.GetEnvironmentVariable("EMBEDDING_DIMENSIONS") ?? "1536") },
+            { "similarity", config.Similarity }
+        };
+
+        foreach (var param in config.ExtraParams)
+        {
+            cosmosSearchOptions.Add(param);
+        }
+
+        var command = new BsonDocument
+        {
+            { "createIndexes", collection.CollectionNamespace.CollectionName },
+            { "indexes", new BsonArray
+                {
+                    new BsonDocument
+                    {
+                        { "name", config.Name },
+                        { "key", new BsonDocument(vectorField, "cosmosSearch") },
+                        { "cosmosSearchOptions", cosmosSearchOptions }
+                    }
+                }
+            }
+        };
+
+        try
+        {
+            collection.Database.RunCommand<BsonDocument>(command);
+        }
+        catch (MongoCommandException ex) when (ex.Message.Contains("already exists"))
+        {
+        }
+    }
+
+    private static List<BsonDocument> RunVectorSearch(
+        IMongoCollection<BsonDocument> collection,
+        float[] queryVector,
+        string vectorField,
+        string indexName,
+        int topK,
+        string algorithm)
+    {
+        var cosmosSearch = new BsonDocument
+        {
+            { "vector", new BsonArray(queryVector.Select(f => (double)f)) },
+            { "path", vectorField },
+            { "k", topK }
+        };
+
+        switch (algorithm.ToLower())
+        {
+            case "diskann":
+                cosmosSearch.Add("lSearch", 100);
+                break;
+            case "hnsw":
+                cosmosSearch.Add("efSearch", 80);
+                break;
+            case "ivf":
+                cosmosSearch.Add("nProbes", 1);
+                break;
+        }
+
+        var pipeline = new[]
+        {
+            new BsonDocument("$search", new BsonDocument("cosmosSearch", cosmosSearch)),
+            new BsonDocument("$project", new BsonDocument
+            {
+                { "HotelName", 1 },
+                { "score", new BsonDocument("$meta", "searchScore") }
+            })
+        };
+
+        return collection.Aggregate<BsonDocument>(pipeline).ToList();
+    }
+
+    private static void PrintResults(List<BsonDocument> results, string algorithm, long latencyMs)
+    {
+        Console.WriteLine(new string('=', 60));
+        Console.WriteLine($"  {algorithm.ToUpper()} Results ({results.Count} found, {latencyMs}ms)");
+        Console.WriteLine(new string('=', 60));
+        Console.WriteLine();
+
+        for (var i = 0; i < results.Count; i++)
+        {
+            var doc = results[i];
+            var name = doc.Contains("HotelName") ? doc["HotelName"].AsString : "Unknown";
+            var score = doc.Contains("score") ? doc["score"].ToDouble() : 0.0;
+            Console.WriteLine($"  {i + 1}. {name} (score: {score:F4})");
+        }
+
+        Console.WriteLine();
+    }
+}