cpateldev/TodoMCPServer

flowchart TD
    A[Client Applications] --> B{Interaction Layer}
    B --> C[REST API<br/>11 Endpoints]
    B --> D[MCP Server<br/>11 Tools]
    C --> E[Business Logic Layer]
    D --> E
    E --> F[Data Access Layer]
    F --> G[In-Memory EF Context]

    H[Swagger UI] --> C
    I[Claude Desktop] --> D
    J[VSCode Gemini Code Assist] --> D
    K[VSCode GitHub Copilot] --> D
    L[Visual Studio GitHub Copilot] --> D

dotnet new webapi -n TodoMCPServer
cd TodoMCPServer

dotnet add package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore --version 10.0.0
dotnet add package Microsoft.AspNetCore.OpenApi --version 10.0.0
dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 10.0.0
dotnet add package ModelContextProtocol --version 0.4.1-preview.1
dotnet add package ModelContextProtocol.AspNetCore --version 0.4.1-preview.1
dotnet add package Swashbuckle.AspNetCore.SwaggerUI --version 10.0.1

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()   // Use stdio transport for local AI clients
    .WithHttpTransport()          // Use HTTP transport for web-based clients
    .WithToolsFromAssembly();     // Automatically register all MCP tools in the assembly

using ModelContextProtocol.AspNetCore.Tools;
using TodoMCPServer.Models;

public static class TodoService
{
    public static void MapEndPoints(this IEndpointRouteBuilder app)
    {
        app.MapGroup("/todoitems");

        app.MapGet("/", TodoTools.GetAllTodos)
            .WithSummary("Get All Todo Items")
            .WithDescription("Retrieve all todo items, optionally filtered by status query parameter (e.g., ?status=completed).");

        app.MapPost("/complete", TodoTools.CompleteTodoItem)
            .WithSummary("Complete Todo Item")
            .WithDescription("Mark a todo item as complete by its ID.");
            
        // Rest of the code
    }
}

[McpServerToolType]
public static class TodoTools
{
    // Get all todo items
    [McpServerTool(Name = "get_all_todos"), Description("Retrieve all todo items optionally filtered by status.")]
    public static async Task<List<Todo>> GetAllTodos(string? status, TodoDb db)
    {
        if (string.Equals(status, "completed", StringComparison.OrdinalIgnoreCase))
        {
            return await db.Todos.Where(t => t.IsComplete).ToListAsync();
        }
        else
        {
            return await db.Todos.ToListAsync();
        }
    }
    // Other MCP tool implementations go here...
}

git clone https://github.com/cpateldev/TodoMCPServer.git
cd TodoMCPServer

dotnet restore

dotnet run
# or for development with hot reload
dotnet watch run

sequenceDiagram
    participant Client as MCP Client Prompt (Github Copilot / Claude / Gemini)
    participant MCPServer as Todo MCP Server
    participant API as REST API Layer
    participant DB as (EF Core) In-Memory DB

    Client->>MCPServer: Prompt to Tool Request (e.g., get_all_todo)
    MCPServer->>API: Process MCP Request
    API->>DB: Execute Database Operation
    DB-->>API: Return Data
    API-->>MCPServer: Format Response
    MCPServer-->>Client: Return Tool Result

{
  "servers": {
    "TodoMcpServer": {
      "type": "http",
      "url": "http://localhost:5000/api/mcp"
    }
  }
}

{
  "servers": {
    "TodoMcpServer": {
      "type": "http",
      "url": "http://localhost:5000/api/mcp"
    }
  }
}

{
  "servers": {
    "TodoMcpHttpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": ["run", "--project", "ToDoMCPServer.csproj"]
    }
  }
}

{
  "mcpServers": {
    "TodoMcpHttpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": [
        "run",
        "--project",
        "<path to project directory>\\TodoMCPServer.csproj"
      ]
    }
  }
}

{
  "mcpServers": {
    "TodoMcpHttpServer": {
      "type": "stdio",
      "command": "dotnet",
      "args": ["run", "--project", "ToDoMCPServer.csproj"]
    }
  }
}

npx -y @modelcontextprotocol/inspector http http://localhost:5000/api/mcp

npx -y @modelcontextprotocol/inspector stdio "dotnet run --project ToDoMCPServer.csproj"

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.Authority = "https://login.microsoftonline.com/<tenant-id>/v2.0";
        options.Audience = "<app-client-id>";
    });

builder.Services.AddAuthorization();

app.MapMcp("api/mcp").RequireAuthorization();

flowchart TD
    subgraph "MCP Clients Ecosystem"
        A[Claude Desktop]
        B[VS Code with MCP]
        C[Cursor IDE]
        D[Gemini Code Assist]
        E[Custom MCP Client]
    end

    subgraph "Azure App Service Deployment"
        F[Azure App Service<br/>TodoMCPServer]
        G[Web API Layer<br/>ASP.NET Core 10]
        H[MCP Server Layer<br/>Stdio Protocol]
        I[Business Logic<br/>TodoTools.cs]
        J[Data Access<br/>Entity Framework]
        
        subgraph "Database Options"
            K1[Azure SQL Database]
            K2[Cosmos DB]
            K3[In-Memory<br/>Dev/Test]
        end
        
        L[Azure Key Vault<br/>Secrets Management]
        M[Application Insights<br/>Monitoring]
        N[Azure Monitor<br/>Logging & Alerts]
    end

    subgraph "Development & CI/CD"
        O[GitHub Repository]
        P[GitHub Actions<br/>CI/CD Pipeline]
        Q[Azure Container Registry]
        R[Docker Container]
    end

    %% Client Connections
    A -->|STDIO Protocol<br/>over SSH/WebSocket| F
    B -->|STDIO Protocol<br/>VS Code Extension| F
    C -->|STDIO Protocol<br/>Integrated Client| F
    D -->|STDIO Protocol<br/>Google Extension| F
    E -->|Custom MCP Protocol| F

    %% Internal Azure Flow
    F --> G
    F --> H
    G --> I
    H --> I
    I --> J
    J --> K1
    J --> K2
    J --> K3
    
    %% Security & Monitoring
    F --> L
    F --> M
    M --> N
    
    %% Deployment Flow
    O --> P
    P --> Q
    Q --> R
    R --> F

    %% External Services
    S[Azure Active Directory<br/>Authentication]
    T[Azure API Management<br/>Optional Gateway]
    U[Azure Front Door<br/>CDN & WAF]
    
    S --> F
    T --> F
    U --> F

sequenceDiagram
    participant C as MCP Client (Claude/VS Code)
    participant APIM as Azure API Management (Optional)
    participant AS as App Service
    participant MCP as MCP Server
    participant API as Web API
    participant DB as Azure SQL

    Note over C,DB: Initial Connection
    C->>APIM: MCP Handshake Request
    APIM->>AS: Forward Request
    AS->>MCP: Initialize MCP Server
    MCP-->>AS: Server Ready
    AS-->>APIM: Handshake Response
    APIM-->>C: Connection Established
    
    Note over C,DB: Tool Execution Flow
    C->>APIM: Tool Request (e.g., get_all_todos)
    APIM->>AS: Forward with Auth
    AS->>MCP: Parse & Validate Request
    MCP->>API: Call Internal API
    API->>DB: Database Query
    DB-->>API: Results
    API-->>MCP: Formatted Data
    MCP-->>AS: MCP-formatted Response
    AS-->>APIM: Response
    APIM-->>C: Final Result

TodoMCPServer/
├── .gemini/                        # gemini Code Assist configuration folder
│   └── settings.json               # config for Gemini Code Assist (MCP)
├── .vscode/                        # VS Code configuration (MCP + editor settings)
│   └── mcp.json                    # MCP configuration for Visual Studio GitHub Copilot
├── ClaudeDesktopConfig/            # Cache folder of Claude Desktop config (MCP)
│   └── claude_desktop_config.json  # MCP configuration for Claude Desktop
├── Properties/                     # project properties (auto-generated by .NET)
│   └── …                           # (typically AssemblyInfo, launchSettings, etc.)
├── images/                         # static image assets (if any)
│   └── …                           # (files here)
├── Program.cs                      # main entry point (ASP.NET minimal API + MCP setup)
├── Readme.md                       # project README / documentation
├── ToDo.cs                         # model/entity class (Todo item)
├── ToDoDb.cs                       # EF Core in-memory DB context
├── TodoItemDTO.cs                  # Data Transfer Object for Todo (for API / MCP)
├── TodoMCPServer.csproj            # .NET project file
├── TodoMCPServer.sln               # Solution file
├── TodoMCPServer.http              # HTTP request collection (e.g. for testing via REST)
├── TodoService.cs                  # REST minimal api endpoints + MCP Tools for Todo operations logic
├── appsettings.json                # general configuration file
├── appsettings.Development.json    # development-specific configuration
└── .mcp.json                       # MCP configuration for Visual Studio 2026 GitHub Copilot (placed at solution root or user profile root)