Building My First AI Coding Agent with the MCP C# SDK: A Lesson in Modern .NET Development

public class CodeAnalyzer
{
    private readonly HttpClient _httpClient;
    private readonly string _apiKey;
    private readonly ILogger<CodeAnalyzer> _logger;
    
    public CodeAnalyzer(IHttpClientFactory httpClientFactory, 
                       IConfiguration configuration,
                       ILogger<CodeAnalyzer> logger)
    {
        _httpClient = httpClientFactory.CreateClient();
        _apiKey = configuration["OpenAI:ApiKey"] 
            ?? throw new InvalidOperationException("OpenAI API key not configured");
        _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
        _logger = logger;
    }
    
    public async Task<CodeAnalysisResult> AnalyzeCodeAsync(string code, string language)
    {
        var requestBody = new
        {
            model = "gpt-4",
            messages = new[]
            {
                new { role = "system", content = "You are a code review expert." },
                new { role = "user", content = $"Analyze this {language} code:\n\n{code}" }
            },
            temperature = 0.3
        };
        
        try
        {
            var response = await _httpClient.PostAsJsonAsync(
                "https://api.openai.com/v1/chat/completions", 
                requestBody);
            
            if (!response.IsSuccessStatusCode)
            {
                var errorContent = await response.Content.ReadAsStringAsync();
                _logger.LogError("OpenAI API error: {StatusCode} - {Error}", 
                    response.StatusCode, errorContent);
                
                // Manual retry logic for rate limits
                if (response.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
                {
                    var retryAfter = response.Headers.RetryAfter?.Delta ?? TimeSpan.FromSeconds(60);
                    await Task.Delay(retryAfter);
                    return await AnalyzeCodeAsync(code, language); // Recursive retry
                }
                
                throw new HttpRequestException($"API call failed: {response.StatusCode}");
            }
            
            var result = await response.Content.ReadFromJsonAsync<OpenAIResponse>();
            
            return new CodeAnalysisResult
            {
                Analysis = result?.Choices?.FirstOrDefault()?.Message?.Content 
                    ?? "No analysis available",
                Timestamp = DateTime.UtcNow
            };
        }
        catch (HttpRequestException ex)
        {
            _logger.LogError(ex, "Network error calling OpenAI API");
            throw;
        }
        catch (JsonException ex)
        {
            _logger.LogError(ex, "Failed to parse OpenAI response");
            throw;
        }
    }
}

// Supporting types
public record OpenAIResponse(Choice[] Choices);
public record Choice(Message Message);
public record Message(string Content);
public record CodeAnalysisResult
{
    public required string Analysis { get; init; }
    public DateTime Timestamp { get; init; }
}

using System.ComponentModel;
using ModelContextProtocol.Server;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

// Step 1: Define the MCP server with dependency injection
var builder = Host.CreateApplicationBuilder(args);

// Configure logging to stderr to keep it separate from MCP protocol messages
builder.Logging.AddConsole(options =>
{
    options.LogToStandardErrorThreshold = LogLevel.Trace;
});

// Register the AI chat client using Microsoft.Extensions.AI
builder.Services.AddChatClient(chatClientBuilder =>
{
    chatClientBuilder.UseOpenAI(
        apiKey: builder.Configuration["OpenAI:ApiKey"]!,
        modelId: "gpt-4");
});

// Register our MCP server with automatic tool discovery
builder.Services
    .AddMcpServer()
    .WithStdioServerTransport() // Use stdio for local communication
    .WithToolsFromAssembly();   // Automatically discover tools in this assembly

await builder.Build().RunAsync();

// Step 2: Define the code analysis tool
[McpServerToolType]
public class CodeAnalysisTools
{
    private readonly IChatClient _chatClient;
    private readonly ILogger<CodeAnalysisTools> _logger;
    
    // Constructor injection works seamlessly with MCP SDK
    public CodeAnalysisTools(IChatClient chatClient, ILogger<CodeAnalysisTools> logger)
    {
        _chatClient = chatClient;
        _logger = logger;
    }
    
    [McpServerTool(Name = "analyze_code", UseStructuredContent = true)]
    [Description("Analyzes code for potential issues, best practices, and improvements. " +
                 "Supports C#, JavaScript, Python, and other common languages.")]
    public async Task<CodeAnalysisResult> AnalyzeCodeAsync(
        [Description("The source code to analyze")] string code,
        [Description("Programming language (e.g., 'csharp', 'javascript', 'python')")] string language,
        [Description("Analysis focus: 'security', 'performance', 'maintainability', or 'all'")] 
        string focus = "all")
    {
        _logger.LogInformation("Analyzing {Language} code with focus on {Focus}", language, focus);
        
        var systemPrompt = focus switch
        {
            "security" => "You are a security expert. Focus on identifying security vulnerabilities.",
            "performance" => "You are a performance expert. Focus on optimization opportunities.",
            "maintainability" => "You are a code quality expert. Focus on maintainability and best practices.",
            _ => "You are a comprehensive code review expert. Analyze for security, performance, and maintainability."
        };
        
        var messages = new[]
        {
            new ChatMessage(ChatRole.System, systemPrompt),
            new ChatMessage(ChatRole.User, $"Analyze this {language} code:\n\n```{language}\n{code}\n```")
        };
        
        try
        {
            // The SDK handles retries, rate limiting, and error handling automatically
            var response = await _chatClient.CompleteAsync(messages);
            
            return new CodeAnalysisResult
            {
                Analysis = response.Message.Text ?? "No analysis available",
                Language = language,
                Focus = focus,
                Timestamp = DateTime.UtcNow,
                Confidence = 0.95 // Could be derived from response metadata
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to analyze code");
            throw new McpException($"Code analysis failed: {ex.Message}");
        }
    }
    
    [McpServerTool(Name = "suggest_refactoring")]
    [Description("Suggests refactoring opportunities to improve code quality and maintainability.")]
    public async Task<RefactoringResult> SuggestRefactoringAsync(
        [Description("The source code to refactor")] string code,
        [Description("Programming language")] string language,
        [Description("Target C# version (e.g., '12', '13') for language-specific features")] 
        string? targetVersion = null)
    {
        var versionContext = !string.IsNullOrEmpty(targetVersion) && language.ToLower() == "csharp"
            ? $" Use modern C# {targetVersion} features like collection expressions, primary constructors, and required properties where appropriate."
            : "";
        
        var messages = new[]
        {
            new ChatMessage(ChatRole.System, 
                $"You are a refactoring expert.{versionContext} Suggest specific, actionable improvements."),
            new ChatMessage(ChatRole.User, 
                $"Suggest refactorings for this {language} code:\n\n```{language}\n{code}\n```")
        };
        
        var response = await _chatClient.CompleteAsync(messages);
        
        return new RefactoringResult
        {
            Suggestions = response.Message.Text ?? "No suggestions available",
            Language = language,
            TargetVersion = targetVersion,
            Timestamp = DateTime.UtcNow
        };
    }
}

// Output types with modern C# 12/13 features
public record CodeAnalysisResult
{
    public required string Analysis { get; init; }
    public required string Language { get; init; }
    public required string Focus { get; init; }
    public DateTime Timestamp { get; init; }
    public double Confidence { get; init; }
}

public record RefactoringResult
{
    public required string Suggestions { get; init; }
    public required string Language { get; init; }
    public string? TargetVersion { get; init; }
    public DateTime Timestamp { get; init; }
}

[McpServerTool(
    Name = "analyze_code",
    IconSource = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCI+PHBhdGggZD0iTTggMTZsNC00LTQtNE02IDE2bDQtNC00LTQiLz48L3N2Zz4=")]
[Description("Analyzes code for potential issues and improvements")]
public async Task<CodeAnalysisResult> AnalyzeCodeAsync(string code, string language)
{
    // Implementation
}

# Add the dotnet/skills marketplace
/plugin marketplace add dotnet/skills

# Browse available plugins
/plugin marketplace browse dotnet-agent-skills

# Install a specific plugin
/plugin install dotnet-data@dotnet-agent-skills

builder.Services
    .AddMcpServer()
    .WithHttpTransport()  // Instead of WithStdioServerTransport()
    .WithToolsFromAssembly();

var app = builder.Build();
app.MapMcp();  // Registers HTTP endpoints
await app.RunAsync();

[McpServerTool(Name = "analyze_code", UseStructuredContent = true)]
public async Task<CodeAnalysisResult> AnalyzeCodeAsync(string code, string language)
{
    // The SDK will automatically generate a JSON schema for CodeAnalysisResult
}

[McpServerToolType]
public class MyTools
{
    private readonly IMyService _myService;
    private readonly ILogger<MyTools> _logger;
    
    public MyTools(IMyService myService, ILogger<MyTools> logger)
    {
        _myService = myService;
        _logger = logger;
    }
}

[Description("Analyzes code for security vulnerabilities, performance issues, and maintainability concerns. " +
             "Example: analyze_code(code='public void Process() { ... }', language='csharp', focus='security')")]

catch (Exception ex)
{
    _logger.LogError(ex, "Tool execution failed");
    throw new McpException($"Failed to process request: {ex.Message}");
}

{
  "mcpServers": {
    "code-analyzer": {
      "command": "dotnet",
      "args": ["run", "--project", "./CodeAnalyzer.McpServer/CodeAnalyzer.McpServer.csproj"]
    }
  }
}