Building AI Agents With .NET: A Practical Guide

dotnet new console -n AIAgentConsole
cd AIAgentConsole
dotnet add package OpenAI

{
  "OpenAI": {
    "ApiKey": "your-openai-api-key",
    "Model": "gpt-3.5-turbo"
  }
}

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;
using AIAgentConsole.Interfaces;
using AIAgentConsole.Services;
using AIAgentConsole.Dispatcher;

var config = new ConfigurationBuilder()
    .AddJsonFile("appsettings.json")
    .Build();

var services = new ServiceCollection();
services.AddSingleton<IConfiguration>(config);
services.AddSingleton<IAgentService, CustomerAgentService>();
services.AddSingleton<IOrderService, OrderService>();
services.AddSingleton<ICustomerService, CustomerService>();
services.AddSingleton<ISupportService, SupportService>();
services.AddSingleton<IntentRouter>();

var serviceProvider = services.BuildServiceProvider();
var agent = serviceProvider.GetRequiredService<IAgentService>();

Console.WriteLine("AI Customer Service Agent (type 'exit' to quit)\n");

while (true)
{
    Console.Write("You: ");
    var input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input) || input.ToLower() == "exit") break;

    var reply = await agent.HandleRequestAsync(input);
    Console.WriteLine($"Agent: {reply}\n");
}

namespace AIAgentConsole.Interfaces
{
    public interface IAgentService
    {
        Task<string> HandleRequestAsync(string userInput);
    }
}

using OpenAI;
using OpenAI.Chat;
using OpenAI.Models;
using AIAgentConsole.Interfaces;
using AIAgentConsole.Dispatcher;

namespace AIAgentConsole.Services
{
    public class CustomerAgentService : IAgentService
    {
        private readonly OpenAIClient _client;
        private readonly string _model;
        private readonly IntentRouter _router;
        private readonly LearningLogger _logger;

        public CustomerAgentService(IConfiguration config, IntentRouter router, LearningLogger logger)
        {
            _model = config["OpenAI:Model"];
            _client = new OpenAIClient(new OpenAIAuthentication(config["OpenAI:ApiKey"]));
            _router = router;
            _logger = logger;
        }

        public async Task<string> HandleRequestAsync(string userInput)
        {
            var prompt = $"""
You are a smart customer support agent. Identify if the user wants to:
1. Get order status
2. Update address
3. Create a support ticket
4. General question
Return only: order_status, update_address, create_ticket, general_question
User: {userInput}
""";

            var request = new ChatRequest(new[] { new Message(Role.User, prompt) }, model: _model);
            var response = await _client.ChatEndpoint.GetCompletionAsync(request);
            var intent = response.FirstChoice.Message.Content.Trim().ToLower();

            var result = await _router.RouteAsync(intent, userInput);

            _logger.Log(userInput, intent, result);

            return result;
        }
    }
}

namespace AIAgentConsole.Interfaces
{
    public interface IAgentService
    {
        Task<string> HandleRequestAsync(string userInput);
    }

    public interface IOrderService
    {
        string GetOrderStatus(string input);
    }

    public interface ICustomerService
    {
        string UpdateAddress(string input);
    }

    public interface ISupportService
    {
        string CreateTicket(string input);
    }
}

using AIAgentConsole.Interfaces;

namespace AIAgentConsole.Services
{
    public class OrderService : IOrderService
    {
        public string GetOrderStatus(string input)
        {
            return "Your order #123456 is in transit and will arrive tomorrow.";
        }
    }

    public class CustomerService : ICustomerService
    {
        public string UpdateAddress(string input)
        {
            return "Your address has been successfully updated.";
        }
    }

    public class SupportService : ISupportService
    {
        public string CreateTicket(string input)
        {
            return "A support ticket has been created. Your ticket number is TCK-98765.";
        }
    }
}

using AIAgentConsole.Interfaces;

namespace AIAgentConsole.Dispatcher
{
    public class IntentRouter
    {
        private readonly IOrderService _orderService;
        private readonly ICustomerService _customerService;
        private readonly ISupportService _supportService;

        public IntentRouter(IOrderService orderService, ICustomerService customerService, ISupportService supportService)
        {
            _orderService = orderService;
            _customerService = customerService;
            _supportService = supportService;
        }

        public async Task<string> RouteAsync(string intent, string input)
        {
            return intent switch
            {
                "order_status" => _orderService.GetOrderStatus(input),
                "update_address" => _customerService.UpdateAddress(input),
                "create_ticket" => _supportService.CreateTicket(input),
                _ => "I'm not sure how to help with that. Let me search online."
            };
        }
    }
}

namespace AIAgentConsole.Services
{
    public class LearningLogger
    {
        private const string LogFile = "learning_log.txt";

        public void Log(string userInput, string intent, string agentResponse)
        {
            var logEntry = $"[{DateTime.Now}] INPUT: {userInput} | INTENT: {intent} | RESPONSE: {agentResponse}";
            File.AppendAllText(LogFile, logEntry + Environment.NewLine);
        }
    }
}