QuickMCP

Why I Built QuickMCP: Making MCP Server Development Actually Enjoyable

Learn how QuickMCP automatically generates MCP servers from API specifications in minutes. Covers authentication, CLI commands, and real examples from the creator.

I spent three weekends last year building MCP servers for various APIs. By the third weekend, I was copying and pasting so much boilerplate code that I started questioning my life choices. That's when I decided to build QuickMCP – a .NET toolkit that generates MCP servers automatically from API specifications.

The Problem I Was Trying to Solve

Every MCP server I built required the same tedious work:

  • Implementing the MCP protocol from scratch
  • Manually writing tool definitions for each endpoint
  • Handling authentication (OAuth flows are fun, said no one ever)
  • Managing error responses and type conversions
  • Testing everything with actual MCP clients

For a simple REST API with 20 endpoints, this took 6-8 hours. For complex APIs? Multiple days. And the worst part? Most APIs already have OpenAPI specs that describe everything perfectly.

I realized I was just translating machine-readable documentation into MCP format manually. That's literally what computers are for.

What QuickMCP Does

QuickMCP reads your OpenAPI or Google Discovery specification and generates a production-ready MCP server. Here's the simplest example:

dotnet tool install -g QuickMCP.CLI
quickmcp serve --spec-url https://petstore.swagger.io/v2/swagger.json

That's it. You now have an MCP server that Claude Desktop (or any MCP client) can use. No code, no configuration, just works.

Five Authentication Methods That Actually Work

Authentication was the hardest part of building MCP servers. Every API uses different methods, and getting them right takes time. QuickMCP supports five authentication types:

1. API Key

quickmcp build config --spec-url https://api.example.com/spec.json --auth apikey

Edit the config to add your key:

{
  "authentication": {
    "type": "ApiKey",
    "apiKey": "${API_KEY}",
    "paramName": "X-API-Key",
    "location": "header"
  }
}

2. Bearer Token

Perfect for GitHub, modern REST APIs:

{
  "authentication": {
    "type": "Bearer",
    "token": "${BEARER_TOKEN}"
  }
}

3. Basic Authentication

For legacy systems:

{
  "authentication": {
    "type": "Basic",
    "username": "${USERNAME}",
    "password": "${PASSWORD}"
  }
}

4. OAuth 2.0 Client Credentials

The complex one, made simple:

{
  "authentication": {
    "type": "OAuth2",
    "tokenUrl": "https://auth.example.com/token",
    "clientId": "${CLIENT_ID}",
    "clientSecret": "${CLIENT_SECRET}",
    "scopes": ["read", "write"]
  }
}

QuickMCP handles token refresh automatically. I tested this with Azure AD, Auth0, and Okta – it works.

5. Custom Headers

For proprietary auth schemes:

{
  "authentication": {
    "type": "CustomHeader",
    "headerName": "X-Custom-Auth",
    "headerValue": "${AUTH_VALUE}"
  }
}

The CLI Commands You'll Actually Use

serve - Start an MCP Server

# From URL
quickmcp serve --spec-url https://api.example.com/openapi.json

# From local file
quickmcp serve --spec-path ./api-spec.json

# From saved config
quickmcp serve --config-path ./my-config.json

# With logging for debugging
quickmcp serve --config-path ./config.json --logging

build - Generate Configuration

quickmcp build config \
  --spec-url https://api.example.com/openapi.json \
  --auth bearer \
  --exclude-paths "/admin/*,/internal/*" \
  --ai-metadata \
  --output-path ./config.json

Important flags:

  • --auth: Set authentication type (apikey, bearer, basic, oauth2, customheader)
  • --exclude-paths: Filter out endpoints you don't want exposed
  • --ai-metadata: Add AI-optimized descriptions for better tool discovery
  • --output-path: Save configuration for reuse

list - See Available Options

# List authentication types
quickmcp list auth

# List configured servers
quickmcp list server

add and delete - Manage Servers

# Save a server configuration
quickmcp add server ./github-config.json --name github

# Remove it
quickmcp delete server --name github

Real Example: GitHub API in 2 Minutes

Let me show you exactly how I set up the GitHub API:

# Step 1: Generate config
quickmcp build config \
  --spec-url https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json \
  --auth bearer \
  --output-path ./github-mcp.json

# Step 2: Add token (or use environment variable)
export GITHUB_TOKEN="ghp_your_token_here"

# Step 3: Start server
quickmcp serve --config-path ./github-mcp.json

For Claude Desktop, add this to claude_desktop_config.json:

{
  "mcpServers": {
    "github": {
      "command": "quickmcp",
      "args": ["serve", "--config-path", "/full/path/to/github-mcp.json"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Restart Claude Desktop. Done.

Path Filtering: Security by Default

Don't expose your entire API. Use path filtering:

quickmcp build config \
  --spec-url https://api.example.com/spec.json \
  --exclude-paths "/admin/*,/internal/*,/debug/*"

You can use wildcards:

--exclude-paths "*/delete,*/remove,/v1/internal/*"

This excludes all delete operations, all remove operations, and anything under /v1/internal/.

Using QuickMCP as a .NET Library

For programmatic control:

dotnet add package QuickMCP

using QuickMCP;

var config = new McpServerConfiguration
{
    ServerId = "my-api",
    SpecificationUrl = "https://api.example.com/openapi.json",
    Authentication = new BearerTokenAuthenticator("your-token"),
    PathFilters = new PathFilterConfiguration
    {
        ExcludePatterns = new[] { "/admin/*", "/internal/*" }
    }
};

var server = await McpServerBuilder
    .FromConfiguration(config)
    .BuildAsync();

await server.StartAsync();

Common Mistakes I Made (So You Don't Have To)

1. Hardcoding Credentials

Don't do this:

{
  "authentication": {
    "token": "sk-proj-actual-secret-token"
  }
}

Do this:

{
  "authentication": {
    "token": "${API_TOKEN}"
  }
}

Then: export API_TOKEN="your-token"

2. Exposing Dangerous Endpoints

Always use --exclude-paths for admin, internal, or destructive endpoints:

--exclude-paths "/admin/*,/internal/*,/debug/*"

3. Ignoring Rate Limits

QuickMCP proxies requests to your API. If your API has rate limits, they still apply. Use bulk endpoints when available, or implement rate limiting at the MCP layer.

When to Use QuickMCP

Use QuickMCP when:

  • You have an OpenAPI/Swagger or Google Discovery spec
  • You want AI assistants to access your API
  • You need multiple authentication methods
  • You're prototyping and need speed
  • You're tired of writing boilerplate

Don't use QuickMCP when:

  • You need extreme MCP protocol customization
  • Your API has no spec (write one first)

FAQ

Q: Do I need to know .NET?
No. The CLI works standalone. Just install the .NET SDK and use the quickmcp command.

Q: Does it work without an OpenAPI spec?
You need a spec. Many tools (Swagger UI, Postman, NSwag) can generate OpenAPI specs from existing APIs.

Q: Is it free?
Yes. MIT licensed. Use it anywhere.

Q: What MCP clients does it support?
Any MCP-compatible client. Tested with Claude Desktop and custom implementations.

Q: How does it handle errors?
QuickMCP wraps API errors in proper MCP error responses. 404 becomes "resource not found," 401 becomes "authentication failed," etc.

Q: Can I customize tool descriptions?
Yes. Use --ai-metadata for AI-optimized descriptions, or edit the generated config manually.

Q: What if my API changes?
Regenerate your config with the updated spec. QuickMCP picks up changes automatically.

Why MCP Matters

We're entering an era where AI assistants can use tools – not just answer questions, but actually call APIs, query databases, and perform actions. The Model Context Protocol standardizes this.

QuickMCP makes it easy to expose your existing APIs to AI assistants. I've used it to:

  • Let Claude manage GitHub issues
  • Connect Stripe for revenue queries
  • Build weather tools for contextual advice
  • Integrate internal company APIs

Each took under an hour. Without QuickMCP, each would've been days of work.

Get Started

# Install
dotnet tool install -g QuickMCP.CLI

# Try it (30 seconds)
quickmcp serve --spec-url https://petstore.swagger.io/v2/swagger.json

Resources:

QuickMCP is open source (MIT license) and built on .NET 8+. It runs on Windows, macOS, and Linux.

If you're building with MCP, give QuickMCP a try. It'll save you hours of tedious work so you can focus on what actually matters – building great AI integrations.

About the Author: I'm the developer of QuickMCP. I built it because I was tired of writing the same MCP server code over and over. Now I'm sharing it with the community. Find me on GitHub.

Read next