Performance Lab — ASP.NET Core Performance MCP Server

An educational demo project showing how to build an MCP (Model Context Protocol) server that uses AI to diagnose .NET API performance problems in real time.

What it does

You connect GitHub Copilot (or Claude, or any MCP-compatible client) to this project, and then ask it in natural language to:

• Run load tests against any HTTP endpoint
• Compare two endpoints side by side
• Detect ThreadPool starvation, GC pressure, or high error rates
• Suggest concrete .NET fixes based on the data
• Generate markdown performance reports

The project includes a sample API with intentionally broken endpoints so you can see all the problems in action.

Projects

Project	Port	Description
PerformanceLab.Api	5100	Sample ASP.NET Core API with educational (intentionally flawed) endpoints
PerformanceLab.McpServer	5200	MCP server + REST API — the brain
PerformanceLab.Dashboard	5300	Blazor Server dashboard for visualising results
PerformanceLab.Shared	—	Shared models (no external dependencies)
PerformanceLab.Tests	—	xUnit tests for core logic

Quick start

Prerequisites

• .NET 10 SDK
• GitHub Copilot with MCP support, or Claude Desktop

1. Clone and build

git clone <repo-url>
cd PerformanceLab
dotnet build

2. Start all three services

Open three terminals:

# Terminal 1 — Sample API
dotnet run --project src/PerformanceLab.Api

# Terminal 2 — MCP Server
dotnet run --project src/PerformanceLab.McpServer

# Terminal 3 — Dashboard
dotnet run --project src/PerformanceLab.Dashboard

3. Connect your AI client

GitHub Copilot (VS Code)

Add this to your workspace .vscode/mcp.json (or user-level settings):

{
  "servers": {
    "performance-lab": {
      "type": "http",
      "url": "http://localhost:5200/mcp"
    }
  }
}

Reload the window. You should see "performance-lab" in the Copilot MCP server list.

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "performance-lab": {
      "url": "http://localhost:5200/mcp"
    }
  }
}

4. Run your first test

In GitHub Copilot chat (Agent mode):

Run a load test against http://localhost:5100/fast for 10 seconds with 20 users

Then compare the slow endpoint with the fast one:

Compare http://localhost:5100/slow-thread-sleep with http://localhost:5100/slow-task-delay

Get a diagnosis:

Analyze the results for run <ID from the output above>

Sample API Endpoints

Endpoint	What it demonstrates
GET /fast	Baseline — returns immediately
GET /slow-thread-sleep?ms=500	❌ Blocks a ThreadPool thread with Thread.Sleep
GET /slow-task-delay?ms=500	✅ Correct async pattern with await Task.Delay
GET /memory-heavy	Allocates ~1MB per request — GC pressure
GET /cpu-heavy?iterations=50000	CPU-bound work (SHA256 hash loop)
GET /database-simulation	N+1 anti-pattern — 5 sequential awaits (~250ms)
GET /optimized-version	Fixed with Task.WhenAll (~50ms)

MCP Tools Available

Tool	Description
run_load_test	Run a load test, get result ID
compare_endpoints	Test two URLs and compare side by side
analyze_results	Full diagnosis for a result ID
compare_before_after	Compare two stored result IDs
detect_slow_responses	Check for slow latency patterns
detect_threadpool_starvation	p99/p50 ratio analysis
detect_memory_pressure	GC pause spike detection
generate_report	Full markdown report for one or more IDs
suggest_optimizations	Pattern-based .NET fix suggestions
list_results	List all stored test run IDs

Running Tests

dotnet test

Expected: 15 tests, all passing.

Dashboard

Open http://localhost:5300 after starting the dashboard.

The dashboard calls the McpServer REST API (/api/results) to display stored results and allows side-by-side comparison of any two test runs.

Architecture

AI Client (Copilot / Claude)
        │ MCP Protocol (HTTP SSE)
        ▼
PerformanceLab.McpServer (:5200)
  ├─ /mcp          ← MCP tools for AI clients
  ├─ /api/results  ← REST API for dashboard
  │
  ├─ LoadTestRunner    — fires concurrent HTTP requests
  ├─ ResultAnalyzer    — rule-based diagnosis
  └─ InMemoryResultStore — holds results in memory
        │ HTTP
        ▼
PerformanceLab.Api (:5100)
  └─ Sample endpoints (fast, slow, memory-heavy, etc.)

PerformanceLab.Dashboard (:5300)
  └─ Blazor Server — reads /api/results from McpServer

Example AI Prompts

Run a load test against http://localhost:5100/slow-thread-sleep for 15 seconds with 20 users

Compare http://localhost:5100/database-simulation with http://localhost:5100/optimized-version

Detect threadpool starvation for result <ID>

Do you see any GC pressure symptoms in result <ID>?

Generate a full performance report for <ID1>,<ID2>

What .NET optimizations would you suggest for threadpool issues?