Add project files.

Author: AbP-DAI

README.md

@@ -0,0 +1,28 @@
+# InvoiceBot – Query Structured Data with Microsoft.Extensions.AI
+
+This is a simple .NET-based AI app that uses **Microsoft.Extensions.AI** to a structured invoice dataset using **tool/function calls**.
+
+
+##  Getting Started
+
+### Requirements
+
+- .NET 8
+- Azure OpenAI or OpenAI API Key
+- Visual Studio or VS Code
+
+### Setup
+
+1. Clone this repo  
+2. Replace `appsettings.json` or builder code with your API keys:
+   ```json
+   "OpenAi": {
+     "Key": "your-openai-key"
+   }3. Run the app:
+   '''bash
+   dotnet run
+
+## Example Queries
+- Compare Q1 and Q2 sales
+- Where is most of my money coming from?
+- Who are my highest paying customers?

src/InvoicesBot.Console/Agent/Invoices.Agent.cs

@@ -0,0 +1,90 @@
+using Microsoft.Extensions.AI;
+
+using System.Text.Json;
+
+namespace InvoicesBot.Console.Agent;
+
+/*
+ * Notes: 
+ * For educational/learning purposes only. Not production grade.
+ * This agent uses ToolCalls to interact with the InvoiceService.
+ * InvoiceService is a simple in-memory service that simulates invoice data. Realworld applications would use a database or external service.
+ * Prefer strongly typed models over objects for tool outputs.
+ * Prefer serialized JSON over objects for tool outputs to save some tokens.
+ * Always provide counts and sums in responses, AI is bad at counting/math.
+ * Never return long lists of objects, always paginate or summarize to save tokens and avoid hallucinations.
+ * This uses LINQ.Dynamic for dynamic filtering and grouping. Can also be done manually using expressions or reflection.
+ * Do not add too many tools. Tools schema counts towards the token limit.
+ * Use dynamic or RAG based tooling, Multi agents orchestration concepts if there are many tools or complex logic.
+ * Chat history must be summarized beyond certain count.
+ * Read more about prompt engineering and AI safety.
+*/
+public interface IInvoicesAgent
+{
+    IAsyncEnumerable<string> GetResponseAsync(List<ChatMessage> messages, Guid threadId);
+}
+public class InvoicesAgent : IInvoicesAgent
+{
+    private readonly IChatClient chatClient;
+    private readonly ToolBuilder toolBuilder;
+
+    public InvoicesAgent([FromKeyedServices("OpenAI")] IChatClient chatClient, ToolBuilder toolBuilder)
+    {
+        this.chatClient=chatClient;
+        this.toolBuilder=toolBuilder;
+    }
+
+    private ChatOptions GetChatOptions(string threadId)
+    {
+        return new ChatOptions
+        {
+            Temperature = 0.3f,
+            Tools = [.. toolBuilder.Build()],
+            MaxOutputTokens = 1024,
+            ConversationId = threadId,
+            AllowMultipleToolCalls = true,
+        };
+    }
+
+
+    public IAsyncEnumerable<string> GetResponseAsync(List<ChatMessage> messages, Guid threadId)
+    {
+        var systemMessage = new ChatMessage(ChatRole.System, InvoicesPromptBuilder.BuildSystemPrompt());
+        messages.Insert(0, systemMessage);
+        //Console.WriteLine(systemMessage);
+        var stream = chatClient.GetStreamingResponseAsync(messages, GetChatOptions(threadId.ToString()));
+        return AIContentToStringAsync(stream);
+    }
+    //real world get messages history from db
+    //private List<ChatMessage> GetMessages(string currentMessage)
+    //{
+    //    var chatHistory = new List<ChatMessage>();
+    //    chatHistory.Add(new ChatMessage(ChatRole.System, SystemPromptBuilder.BuildSystemPrompt()));
+
+    //    //chatHistory.AddRange(previous.ToList().ConvertAll(pm => (ChatMessage)pm));
+
+    //    chatHistory.Add(new ChatMessage(ChatRole.User, currentMessage));
+    //    return chatHistory;
+    //}
+    private async IAsyncEnumerable<string> AIContentToStringAsync(IAsyncEnumerable<ChatResponseUpdate> stream)
+    {
+        await foreach(var update in stream)
+        {
+            foreach(var content in update.Contents)
+            {
+                switch(content)
+                {
+                    case TextContent text:
+                        yield return text.Text;
+                        break;
+                    case FunctionCallContent toolCall:
+                        //yield return $"Tool call: {toolCall.Name} with arguments {JsonSerializer.Serialize(toolCall.Arguments)}";
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+}
+

src/InvoicesBot.Console/Agent/Invoices.PromptBuilder.cs

@@ -0,0 +1,50 @@
+using InvoicesBot.Console.Services.Models;
+
+using Microsoft.Extensions.AI;
+
+namespace InvoicesBot.Console.Agent;
+
+public static class InvoicesPromptBuilder
+{
+    public static string GenerateCompactSchema<T>()
+    {
+        var schema = AIJsonUtilities.CreateJsonSchema(typeof(T));
+        return schema.ToString();
+    }
+    /*
+    not all schemas are needed for this use case
+        Location: {GenerateCompactSchema<Location>()}
+        LineItem: {GenerateCompactSchema<LineItem>()}
+        LineItemType: {GenerateCompactSchema<LineItemType>()}
+     */
+
+    public static string BuildSystemPrompt()
+    {
+        return $"""
+        You are a Corporate AI assistant that helps users with invoice data.
+        Todays date is {DateTime.UtcNow:yyyy-MM-dd}. Assume realtime access to data.
+        You can retrieve invoices based on various criteria such as date, amount, and status.
+        Always use tools to provide answers, never generate data or make assumptions.
+        For comparisions, use markdown tables and provide key insights
+        
+        Schemas of the invoices are as follows:
+        Invoice: {GenerateCompactSchema<Invoice>()}
+       
+        Customer: {GenerateCompactSchema<Customer>()}
+     
+        Always reason step by step before calling tools.
+        Never hallucinate facts. Use only what the tools return.
+   
+        Max tool usage is 5 per request.
+
+        At the end of your response, include a short, casual summary:
+        - Mention which tool you used
+        - Briefly say what data or filters you gave it
+        Example: “Used the ‘get_invoices’ tool to pull unpaid invoices from last month.”
+        
+        """;
+    }
+};
+
+
+

src/InvoicesBot.Console/Agent/Invoices.ToolBuilder.cs

@@ -0,0 +1,56 @@
+using InvoicesBot.Console.Attributes;
+
+using Microsoft.Extensions.AI;
+
+using System.Linq.Dynamic.Core;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace InvoicesBot.Console.Agent;
+
+public class ToolBuilder
+{
+    private readonly IInvoiceTools invoiceTools;
+
+    public ToolBuilder(IInvoiceTools invoiceTools)
+    {
+        this.invoiceTools=invoiceTools;
+    }
+    public List<AIFunction> Build()
+    {
+
+        var tools = new List<AIFunction>();
+
+        var methods = typeof(InvoiceTools)
+            .GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+
+        foreach(var method in methods)
+        {
+            var nameAttr = method.GetCustomAttribute<NameAttribute>();
+            var toolName = nameAttr?.Value ?? method.Name;
+
+            var del = Delegate.CreateDelegate(
+                Expression.GetDelegateType(
+                    method.GetParameters()
+                          .Select(p => p.ParameterType)
+                          .Concat(new[] { method.ReturnType })
+                          .ToArray()),
+                invoiceTools,
+                method
+            );
+
+            var tool = AIFunctionFactory.Create(del, new AIFunctionFactoryOptions { Name = toolName });
+            tools.Add(tool);
+        }
+
+        return tools;
+
+        // Alternatively, you can manually create tools for specific methods if needed
+        //var tool1 = AIFunctionFactory.Create(invoiceTools.GetInvoices, new AIFunctionFactoryOptions() { Name = "get_invoices" });
+        //var tool2 = AIFunctionFactory.Create(invoiceTools.GetInvoiceById);
+
+        //return new List<AIFunction> { tool1, tool2 };
+    }
+
+}
+