Merge pull request #2 from BLaZeKiLL/feat/cypher-plugin

Neo4j Cypher Code Gen Plugin

Author: BLaZeKiLL

Codeblaze.SemanticKernel.Connectors.Ollama/README.md

@@ -7,15 +7,15 @@ Supports
 > :warning: **Embedding generation**: Is experimental in the semantic kernel.
 
 ### Quick Start
-- Install from [nuget](https://www.nuget.org/packages/Codeblaze.SemanticKernel.Connectors.AI.Ollama)
+- Install from [nuget](https://www.nuget.org/packages/Codeblaze.SemanticKernel.Connectors.Ollama)
     ```
-    dotnet add package Codeblaze.SemanticKernel.Connectors.AI.Ollama
+    dotnet add package Codeblaze.SemanticKernel.Connectors.Ollama
     ```
 - Text Generation
 
     Configure the kernel
-    ```cs
-    var builder = new KernelBuilder();
+    ```csharp
+    var builder = Kernel.CreateBuilder();
 
     // provide the HTTP client used to interact with Ollama API
     builder.Services.AddTransient<HttpClient>();
@@ -29,7 +29,7 @@ Supports
     ```
 
     Usage
-    ```cs
+    ```csharp
     const string prompt = """
     Bot: How can I help you?
     User: {{$input}}
@@ -50,7 +50,7 @@ Supports
 - Chat Completion
 
     Configure the kernel
-    ```cs
+    ```csharp
     var builder = new KernelBuilder();
 
     // provide the HTTP client used to interact with Ollama API
@@ -65,7 +65,7 @@ Supports
     ```
 
     Usage
-    ```cs
+    ```csharp
     var chat = _Kernel.GetRequiredService<IChatCompletionService>();
 
     var history = new ChatHistory();
@@ -86,7 +86,7 @@ Supports
 - Embedding Generation (Experimental)
 
     Configure the kernel
-    ```cs
+    ```csharp
     var builder = new KernelBuilder();
 
     // provide the HTTP client used to interact with Ollama API
@@ -103,7 +103,7 @@ Supports
     ```
 
     Usage
-    ```cs
+    ```csharp
     var memory = _Kernel.GetRequiredService<ISemanticTextMemory>();
 
     // This will internally call Ollama embedding service to generate embeddings

Codeblaze.SemanticKernel.Console/Program.cs

@@ -58,7 +58,7 @@ async Task Prompt()
 {
     var prompt = AnsiConsole.Prompt(new TextPrompt<string>("What are you looking to do today ?").PromptStyle("teal"));
 
-    NeoResult result = null;
+    Neo4jResult result = null;
 
     await AnsiConsole.Status().StartAsync("Processing...", async ctx =>
     {

Codeblaze.SemanticKernel.Console/Services/NeoKernelService.cs

@@ -1,37 +1,37 @@
+using Codeblaze.SemanticKernel.Connectors.Ollama;
 using Codeblaze.SemanticKernel.Plugins.Neo4j;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.SemanticKernel;
 
 namespace Codeblaze.SemanticKernel.Console.Services;
 
 public class NeoKernelService
 {
     private readonly Kernel _Kernel;
-    private readonly Neo4jPlugin _plugin;
 
     public NeoKernelService(IConfiguration config)
     {
         var builder = Kernel.CreateBuilder();
 
+        // builder.Services.AddTransient<HttpClient>();
+        
         builder.AddOpenAIChatCompletion(config["OpenAI:Model"], config["OpenAI:Key"]);
-
+        // builder.AddOllamaChatCompletion(config["Ollama:Model"], config["Ollama:BaseUrlGeneration"]);
+        
         _Kernel = builder.Build();
-
-        _plugin = new Neo4jPlugin(_Kernel, config["Neo4j:Url"], config["Neo4j:Username"], config["Neo4j:Password"]);
-    }
-
-    public string GetSchema()
-    {
-        return _plugin.Schema;
-    }
-
-    public Task<string> GenerateCypher(string prompt)
-    {
-        return _plugin.GenerateCypher(prompt);
+        
+        _Kernel.AddNeo4jCypherGenPlugin(config["Neo4j:Url"], config["Neo4j:Username"], config["Neo4j:Password"]);
     }
 
-    public Task<NeoResult> Run(string prompt)
+    public Task<Neo4jResult?> Run(string prompt)
     {
-        return _plugin.Run(prompt);
+        return _Kernel.InvokeAsync<Neo4jResult>(
+            nameof(Neo4jCypherGenPlugin), "Query", 
+            new KernelArguments
+            {
+                { "prompt", prompt }
+            }
+        );
     }
 }

Codeblaze.SemanticKernel.Plugins.Neo4j/Neo4jPlugin.cs renamed to Codeblaze.SemanticKernel.Plugins.Neo4j/Neo4jCypherGenPlugin.cs

@@ -1,23 +1,32 @@
+using System.ComponentModel;
 using System.Text.Json;
 using Microsoft.SemanticKernel;
 using Microsoft.SemanticKernel.ChatCompletion;
 using Neo4j.Driver;
 
 namespace Codeblaze.SemanticKernel.Plugins.Neo4j;
 
-public class NeoResult
+/// <summary>
+/// Cypher gen query execution result
+/// </summary>
+public class Neo4jResult
 {
     public bool Success { get; set; }
     public string? Cypher { get; set; }
     public List<IRecord>? Result { get; set; }
 }
 
-// Extend from IKernelPlugin
-public class Neo4jPlugin
+/// <summary>
+/// Cypher code gen plugin
+/// </summary>
+public class Neo4jCypherGenPlugin
 {
     private readonly IDriver _driver;
     private readonly IChatCompletionService _chat;
 
+    /// <summary>
+    /// Text bases representation of schema for the current database
+    /// </summary>
     public string Schema { get; }
 
     private const string NODE_PROPS_QUERY = """
@@ -43,67 +52,49 @@ CALL apoc.meta.data()
                                      RETURN {source: label, relationship: property, target: other} AS output
                                      """;
 
-    public Neo4jPlugin(Kernel kernel, string url, string username, string password)
+    /// <summary>
+    /// Creates a neo4j cypher gen plugin instance
+    /// </summary>
+    /// <param name="chat">Chat service from semantic kernel to be used as generation backend</param>
+    /// <param name="url">Neo4j url, used by the neo4j driver</param>
+    /// <param name="username">Neo4j database username, used by the neo4j driver</param>
+    /// <param name="password">Neo4j database password, used by the neo4j driver</param>
+    public Neo4jCypherGenPlugin(IChatCompletionService chat, string url, string username, string password)
     {
         _driver = GraphDatabase.Driver(url, AuthTokens.Basic(username, password));
-        _chat = kernel.GetRequiredService<IChatCompletionService>();
+        _chat = chat;
 
         Schema = GetSchema().GetAwaiter().GetResult();
     }
-    
-    private async Task<string> GetSchema()
-    {
-        
-        var node_props = JsonSerializer.Serialize((await Query(NODE_PROPS_QUERY)).Select(x => x.Values["output"]).ToList());
-        var rel_props = JsonSerializer.Serialize((await Query(REL_PROPS_QUERY)).Select(x => x.Values["output"]).ToList());
-        var rels = JsonSerializer.Serialize((await Query(REL_QUERY)).Select(x => x.Values["output"]).ToList());
-        
-        return $"""
-                 This is the schema representation of the Neo4j database.
-                 Node properties are the following:
-                 {node_props}
-                 Relationship properties are the following:
-                 {rel_props}
-                 Relationship point from source to target nodes
-                 {rels}
-                 Make sure to respect relationship types and directions
-                 """;
-    }
 
-    public async Task<string> GenerateCypher(string prompt)
+    /// <summary>
+    /// Creates a neo4j cypher gen plugin instance
+    /// </summary>
+    /// <param name="chat">Chat service from semantic kernel to be used as generation backend</param>
+    /// <param name="driver">Neo4j driver to be used for executing cypher</param>
+    public Neo4jCypherGenPlugin(IChatCompletionService chat, IDriver driver)
     {
-        var system = $"""
-                       Task: Generate Cypher queries to query a Neo4j graph database based on the provided schema definition.
-                       Instructions:
-                       Use only the provided relationship types and properties.
-                       Do not use any other relationship types or properties that are not provided.
-                       If you cannot generate a Cypher statement based on the provided schema, explain the reason to the user.
-                       Schema:
-                       {Schema}
-                       
-                       Note: Do not include any explanations or apologies in your responses.
-                       """;
-
-        var history = new ChatHistory
-        {
-            new(AuthorRole.System, system),
-            new(AuthorRole.User, prompt)
-        };
-
-        var result = await _chat.GetChatMessageContentsAsync(history);
+        _driver = driver;
+        _chat = chat;
 
-        return result[0].Content;
+        Schema = GetSchema().GetAwaiter().GetResult();
     }
-
-    public async Task<NeoResult> Run(string prompt)
+    
+    /// <summary>
+    /// SK Function to generate cypher, execute it and return the result
+    /// </summary>
+    /// <param name="prompt">prompt against which cypher is to be generated</param>
+    /// <returns>Result containing, cypher and cypher execution result</returns>
+    [KernelFunction, Description("Generates cypher code based on prompt and queries the database")]
+    public async Task<Neo4jResult> Query(string prompt)
     {
         var cypher = await GenerateCypher(prompt);
 
         try
         {
-            var result = await Query(cypher);
+            var result = await NeoQuery(cypher);
 
-            return new NeoResult
+            return new Neo4jResult
             {
                 Success = true,
                 Cypher = cypher,
@@ -112,11 +103,60 @@ public async Task<NeoResult> Run(string prompt)
         }
         catch
         {
-            return new NeoResult { Success = false, Cypher = cypher };
+            return new Neo4jResult { Success = false, Cypher = cypher };
         }
     }
 
-    private async Task<List<IRecord>> Query(string query)
+    /// <summary>
+    /// SK Function to generate cypher based on the prompt
+    /// </summary>
+    /// <param name="prompt">prompt against which cypher is to be generated</param>
+    /// <returns>Generated cypher</returns>
+    [KernelFunction, Description("Generates cypher code based on prompt")]
+    public async Task<string> GenerateCypher(string prompt)
+    {
+        var system = $"""
+                      Task: Generate Cypher queries to query a Neo4j graph database based on the provided schema definition.
+                      Instructions:
+                      Use only the provided relationship types and properties.
+                      Do not use any other relationship types or properties that are not provided.
+                      If you cannot generate a Cypher statement based on the provided schema, explain the reason to the user.
+                      Schema:
+                      {Schema}
+
+                      Note: Do not include any explanations or apologies in your responses.
+                      """;
+
+        var history = new ChatHistory
+        {
+            new(AuthorRole.System, system),
+            new(AuthorRole.User, prompt)
+        };
+
+        var result = await _chat.GetChatMessageContentsAsync(history);
+        
+        return result[0].Content;
+    }
+    
+    private async Task<string> GetSchema()
+    {
+        var nodeProps = JsonSerializer.Serialize((await NeoQuery(NODE_PROPS_QUERY)).Select(x => x.Values["output"]).ToList());
+        var relationProps = JsonSerializer.Serialize((await NeoQuery(REL_PROPS_QUERY)).Select(x => x.Values["output"]).ToList());
+        var relations = JsonSerializer.Serialize((await NeoQuery(REL_QUERY)).Select(x => x.Values["output"]).ToList());
+        
+        return $"""
+                 This is the schema representation of the Neo4j database.
+                 Node properties are the following:
+                 {nodeProps}
+                 Relationship properties are the following:
+                 {relationProps}
+                 Relationship point from source to target nodes
+                 {relations}
+                 Make sure to respect relationship types and directions
+                 """;
+    }
+    
+    private async Task<List<IRecord>> NeoQuery(string query)
     {
         await using var session = _driver.AsyncSession(o => o.WithDatabase("neo4j"));
 
@@ -127,6 +167,4 @@ private async Task<List<IRecord>> Query(string query)
             return await cursor.ToListAsync();
         });
     }
-    
-    
 }

Codeblaze.SemanticKernel.Plugins.Neo4j/Neo4jPluginBuilderExtension.cs

@@ -1,12 +1,26 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.ChatCompletion;
+using Neo4j.Driver;
 
 namespace Codeblaze.SemanticKernel.Plugins.Neo4j;
 
-// Extend from IKernelBuilderPlugins
 public static class Neo4jPluginBuilderExtension
 {
-    public static void AddNeo4jPlugin(this IServiceCollection services, string url, string username, string password)
+    public static void AddNeo4jCypherGenPlugin(this Kernel kernel, string url, string username, string password)
     {
+        var chat = kernel.GetRequiredService<IChatCompletionService>();
 
+        var plugin = new Neo4jCypherGenPlugin(chat, url, username, password);
+
+        kernel.ImportPluginFromObject(plugin, nameof(Neo4jCypherGenPlugin));
+    }
+    
+    public static void AddNeo4jCypherGenPlugin(this Kernel kernel, IDriver driver)
+    {
+        var chat = kernel.GetRequiredService<IChatCompletionService>();
+        
+        var plugin = new Neo4jCypherGenPlugin(chat, driver);
+
+        kernel.ImportPluginFromObject(plugin, nameof(Neo4jCypherGenPlugin));
     }
 }