C8 — Build a C# MCP Server for BookTracker

git switch -c my-c8 checkpoint/c7-rag
cd src/BookTracker

dotnet new web -n BookTracker.Mcp
dotnet sln BookTracker.sln add BookTracker.Mcp/BookTracker.Mcp.csproj

dotnet add BookTracker.Mcp reference BookTracker.Core/BookTracker.Core.csproj
dotnet add BookTracker.Mcp reference BookTracker.Data/BookTracker.Data.csproj

dotnet add BookTracker.Mcp package ModelContextProtocol --version 1.4.0
dotnet add BookTracker.Mcp package ModelContextProtocol.AspNetCore --version 1.4.0

using BookTracker.Core.Services;
using BookTracker.Data;
using Microsoft.EntityFrameworkCore;

var builder = WebApplication.CreateBuilder(args);

// MCP server over Streamable HTTP; tools are discovered from [McpServerTool] methods in this assembly.
builder.Services.AddMcpServer()
    .WithHttpTransport()
    .WithToolsFromAssembly();

// Reuse the BookTracker stack against the same DB. AddBookTrackerData registers the DbContext +
// repositories; the Core services are registered here just as the API host does.
var connectionString = builder.Configuration.GetConnectionString("BookTracker")
    ?? "Data Source=booktracker.db";
builder.Services.AddBookTrackerData(connectionString);
builder.Services.AddScoped<IBookService, BookService>();
builder.Services.AddScoped<IAuthorService, AuthorService>();
builder.Services.AddScoped<IReadingProgressService, ReadingProgressService>();

var app = builder.Build();

// Migrate at startup so the server runs straight from a clone.
using (var scope = app.Services.CreateScope())
    scope.ServiceProvider.GetRequiredService<BookTrackerDbContext>().Database.Migrate();

app.MapMcp();
app.Run();

{
  "profiles": {
    "http": {
      "commandName": "Project",
      "applicationUrl": "http://localhost:5100",
      "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" }
    }
  }
}

using System.ComponentModel;
using System.Text.Json;
using BookTracker.Core.Dtos;
using BookTracker.Core.Services;
using ModelContextProtocol.Server;

namespace BookTracker.Mcp.Tools;

[McpServerToolType]
public class BookMcpTools
{
    [McpServerTool]
    [Description("Search BookTracker for books whose title matches a query. Returns matching books as JSON.")]
    public async Task<string> SearchBooks(
        IBookService books,
        [Description("Text to match against book titles")] string query,
        CancellationToken ct)
    {
        if (string.IsNullOrWhiteSpace(query))
            return "Error: query is required.";
        return Serialize(await books.SearchAsync(query, ct));
    }

    [McpServerTool]
    [Description("Get a book's reading progress (page, status, percent complete) by book id.")]
    public async Task<string> GetReadingProgress(
        IReadingProgressService progress,
        [Description("The book id")] int bookId,
        CancellationToken ct)
        // Reuses the C4 service — its business rules hold over MCP just as over HTTP.
        => Serialize(await progress.GetForBookAsync(bookId, ct));

    [McpServerTool]
    [Description("Add a new book to BookTracker. The author must already exist. Returns the created book as JSON.")]
    public async Task<string> AddBook(
        IBookService books,
        [Description("Book title")] string title,
        [Description("Id of an existing author")] int authorId,
        [Description("Total page count")] int totalPages,
        [Description("ISBN (optional)")] string? isbn,
        [Description("Genre (optional)")] string? genre,
        CancellationToken ct)
    {
        if (string.IsNullOrWhiteSpace(title))
            return "Error: title is required.";

        // CreateAsync returns a BookMutationResult; check its status before returning the book.
        var result = await books.CreateAsync(new CreateBookRequest(title, authorId, isbn, totalPages, genre), ct);
        return result.Status == BookMutationStatus.Success
            ? Serialize(result.Book)
            : $"Error: author {authorId} does not exist.";
    }

    private static string Serialize(object? value) => JsonSerializer.Serialize(value);
}

namespace BookTracker.Mcp.Security;

public class McpAuth
{
    private readonly RequestDelegate _next;
    private readonly string? _apiKey;

    public McpAuth(RequestDelegate next, IConfiguration configuration)
    {
        _next = next;
        _apiKey = configuration["Mcp:ApiKey"];
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if (!string.IsNullOrEmpty(_apiKey)
            && context.Request.Headers.Authorization.ToString() != $"Bearer {_apiKey}")
        {
            context.Response.StatusCode = StatusCodes.Status401Unauthorized;
            await context.Response.WriteAsync("Unauthorized: missing or invalid bearer token.");
            return;
        }
        await _next(context);
    }
}

namespace BookTracker.Mcp.Security;

public class AuditLogger
{
    private readonly ILogger<AuditLogger> _logger;
    public AuditLogger(ILogger<AuditLogger> logger) => _logger = logger;

    public void ToolInvoked(string toolName, string argumentsSummary)
        => _logger.LogInformation("MCP tool invoked: {Tool} args=({Args})", toolName, argumentsSummary);
}

dotnet build BookTracker.sln

dotnet run --project BookTracker.Mcp --urls http://localhost:5100   # leave this running

# in another terminal, from src/BookTracker:
claude mcp add --transport http booktracker http://localhost:5100
claude mcp list                                                     # booktracker - connected

Search BookTracker for books about space

What is the reading progress for book 1?