Build Claude Desktop Extensions in Minutes with QuickMCP.NET

Posted on by — No Comments ↓

Hey developers!

Remember the last time you tried to integrate a REST API with Claude Desktop? Yeah, me too. It involved reading through MCP docs, writing YAML configs, figuring out authentication, and probably a few frustrated sighs.

What if I told you there’s a better way? A way that involves one command and lets AI do the heavy lifting?

Let me introduce you to QuickMCP.NET – specifically its brand new Claude Desktop Extension Builder. Trust me, this is going to blow your mind.

The Problem We’ve All Had

You’ve got a REST API. Maybe it’s your company’s internal API, maybe it’s Stripe, GitHub, or that quirky microservice Bob built. You want Claude to interact with it.

So you dive into the Model Context Protocol docs and realize you need to:

  1. Write an MCP server configuration
  2. Configure authentication (API keys, OAuth, whatever)
  3. Create a manifest file with proper metadata
  4. Write user-friendly descriptions for every config field
  5. Package it all into a .mcpb file
  6. Hope it actually works

By the time you’re done, you’ve spent 3 hours on what should’ve been a 5-minute task.

Enter QuickMCP.NET: Your New Best Friend

QuickMCP.NET is a .NET toolkit that generates MCP servers from OpenAPI/Swagger specs. But the real magic is in the new Claude Extension Builder feature.

Here’s what it does:

  • AI-powered metadata generation using Google Gemini
  • Automatic auth detection from your config
  • Smart placeholder parsing for environment variables
  • One-command packaging to .mcpb files
  • Auto-generated README with install instructions

Let me show you how ridiculously easy this is.

The “Holy Crap That’s Easy” Example

Let’s say you want to build a Stripe API extension. First, create your config file with QuickMCP CLI: 

# Build a config file with authentication placeholders
quickmcp build config 
  --spec-url https://api.stripe.com/v1/openapi.yaml 
  --server-name "Stripe API" 
  --auth bearer

QuickMCP will guide you through authentication setup, and you’ll use placeholders for secrets like {{STRIPE_API_KEY}}. You’ll end up with a config file like this: 

{
  "type": "openapi",
  "serverName": "Stripe API",
  "apiSpecUrl": "https://api.stripe.com/v1/openapi.yaml",
  "apiBaseUrl": "https://api.stripe.com",
  "authentication": {
    "type": "bearer",
    "settings": {
      "token": "{{STRIPE_API_KEY}}"
    }
  }
}

Now watch this – turn it into a Claude Desktop extension: 

quickmcp build ce -c stripe_config.json -m -k YOUR_GEMINI_KEY

That’s it. ONE command.

Here’s what just happened:

  1. Parsed your config
  2. Found the {{STRIPE_API_KEY}} placeholder
  3. Asked Gemini 2.5 Flash: “Hey, what should users know about this?”
  4. Gemini responds: “This is a Stripe API key, format is sk_..., it’s sensitive, here’s a helpful description…”
  5. Generated a beautiful manifest with user-friendly forms
  6. Created a README with installation steps
  7. Packaged everything into stripe.mcpb

The result? A production-ready Claude Desktop extension that users can install with a few clicks.

The AI Magic Under The Hood

This is where it gets really cool. When you enable AI metadata (-m flag), QuickMCP sends your config to Gemini and asks it to analyze everything:

For your auth variables, it generates:

  • User-friendly titles (“API Key” instead of “API_KEY”)
  • Helpful descriptions (“Enter your API key from the Stripe dashboard…”)
  • Format hints (“sk_live_…” or “Bearer …”)
  • Sensitivity markers (automatically marks secrets)

For your extension, it creates:

  • Professional display name
  • Clear, concise description
  • Relevant keywords for search
  • Author info (extracted from API metadata)

Here’s a real example. Without AI: 

{
  "title": "CLIENT_SECRET",
  "description": "Enter your CLIENT_SECRET"
}

Meh.

With AI: 

{
  "title": "OAuth Client Secret",
  "description": "Your OAuth 2.0 client secret from the developer console. This is used alongside your client ID to authenticate token requests. Keep this confidential!",
  "format_hint": "Usually a 32-character hex string",
  "sensitive": true
}

Now we’re talking!

Two Ways to Build: Maximum Flexibility

Option 1: Two-Step Process (Recommended)

Step 1: Build your config file first (gives you more control): 

# Create config with authentication
quickmcp build config 
  --spec-url https://api.github.com/openapi.yaml 
  --server-name "GitHub API" 
  --auth bearer

# This creates a config file with {{GITHUB_TOKEN}} placeholder
# Edit it if needed, then build the extension

Step 2: Build the Claude extension: 

quickmcp build ce 
  -c github_config.json 
  -m 
  --author-name "Your Company"

Option 2: All-in-One

Create config and extension in a single command: 

quickmcp build ce 
  --spec-url https://api.github.com/openapi.yaml 
  --server-name "GitHub API" 
  --auth bearer 
  -m 
  --author-name "Your Company"

Both workflows give you the same beautiful result: a ready-to-install .mcpb package.

Pro tip: The two-step process is recommended because it lets you review and customize the config file before building the extension. You can add custom authentication settings, filter API paths, or tweak the configuration.

Real-World Example: GitHub Integration

Let’s build a GitHub API extension together from scratch.

Step 1: Create the config file: 

quickmcp build config 
  --spec-url https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json 
  --server-name "GitHub API" 
  --auth bearer

During setup, you’ll be prompted to configure authentication. Use {{GITHUB_TOKEN}} as the token placeholder. This creates a config file: 

{
  "type": "openapi",
  "serverName": "GitHub API",
  "apiSpecUrl": "https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json",
  "apiBaseUrl": "https://api.github.com",
  "authentication": {
    "type": "bearer",
    "settings": {
      "token": "{{GITHUB_TOKEN}}"
    }
  }
}

Step 2: Build the Claude extension: 

quickmcp build ce 
  -c github_config.json 
  -m 
  --author-name "GitHub" 
  --author-url "https://github.com"

Output: 

✓ Using existing config file: github_config.json
✓ Analyzing configuration and generating metadata...
✓ Using AI-generated display name: GitHub API Integration
✓ Using AI-generated description: Access GitHub's REST API to manage repositories, issues, pull requests, and more
✓ Using AI-generated keywords: github, api, git, repositories, ci-cd
✓ Generated comprehensive metadata successfully!

For environment variable: GITHUB_TOKEN
  • Title: GitHub Personal Access Token
  • Description: A personal access token from your GitHub account settings with appropriate scopes...
  • Format: ghp_...
  • Sensitive: Yes

✓ Generating manifest.json...
✓ Generating README.md...
✓ Creating .mcpb package...
✓ Package created: github.mcpb

Claude Desktop extension successfully built!

You now have a github.mcpb file ready to distribute!

What’s Inside The Package?

When you build an extension, you get: 

output-directory/
├── manifest.json          # Extension metadata
├── github_config.json     # MCP server config
├── openapi.json          # API specification
├── README.md             # Installation guide
└── github.mcpb           # The installable package

The manifest.json is where the magic happens: 

{
  "manifest_version": "0.3",
  "name": "github",
  "display_name": "GitHub API Integration",
  "version": "1.0.0",
  "description": "Access GitHub's REST API...",
  "server": {
    "type": "binary",
    "entry_point": "quickmcp",
    "mcp_config": {
      "command": "quickmcp",
      "args": ["serve", "--config-path", "${__dirname}/github_config.json"],
      "env": {
        "GITHUB_TOKEN": "${user_config.githubtoken}"
      }
    }
  },
  "user_config": {
    "githubtoken": {
      "type": "string",
      "title": "GitHub Personal Access Token",
      "description": "A personal access token from your GitHub account settings...",
      "required": true
    }
  }
}

See that user_config section? That’s what creates the nice UI in Claude Desktop for users to enter their credentials. No more config file editing!

Installing Your Extension

Your users get a super smooth experience:

Step 1: Install QuickMCP CLI (one-time setup) 

dotnet tool install -g quickmcp.cli

Step 2: Install the extension in Claude Desktop

  1. Open Claude Desktop
  2. Settings → Extensions
  3. “Install Extension…”
  4. Select the .mcpb file
  5. Enter their credentials in the nice form
  6. Restart Claude

Step 3: Start using it!

Claude can now interact with your API. No more copy-pasting curl commands!

The Developer Experience is Fire

Here’s what I love most about this workflow:

1. It Just Works™

No YAML indentation hell. No “why isn’t this working?” debugging sessions. The CLI validates everything and gives you clear error messages.

2. AI Does The Boring Stuff

Writing descriptions for 15 different OAuth parameters? Pass. Let Gemini handle it. You focus on the fun stuff.

3. Type Safety Built-In

It’s .NET, so you get all the type safety, intellisense, and tooling you love. The generated MCP servers are robust and production-ready.

4. Instant Feedback

quickmcp serve -c config.json

Test your server instantly. No deploy, no container builds. Just run it.

5. Cross-Platform

Works on Windows, macOS, and Linux. Your extensions work everywhere Claude Desktop works.

Advanced: Batch Build Multiple Extensions

Got 10 APIs to integrate? No problem: 

# Set your Gemini key once
export GOOGLE_API_KEY=your_key

# Build them all
for config in configs/*.json; do
  quickmcp build ce -c "$config" -m
done

Boom. 10 production-ready extensions in seconds.

Authentication: We Support It All

QuickMCP handles pretty much every auth method:

  • API Keys (header, query param)
  • Bearer Tokens
  • Basic Auth
  • OAuth 2.0 (all grant types!)
  • Custom Headers
  • Custom Authenticators (roll your own!)

And with the AI metadata generator, users get clear instructions for every auth type.

Tips & Tricks

Use Environment Variables Everywhere

Always use placeholders for secrets: 

{
  "apiKey": "{{API_KEY}}"        // Good
  "apiKey": "sk_live_real_key"   // Bad
}

Let AI Do The Work

Compare these:

Without AI (--author-name "Required" only):

  • Minimal metadata
  • Generic descriptions
  • More manual work

With AI (-m flag):

  • Rich, helpful metadata
  • Context-aware descriptions
  • Nearly zero manual work

The choice is obvious!

Test Before Distributing

# Build
quickmcp build ce -c config.json -m

# Extract and test
unzip your_api.mcpb -d test/
quickmcp serve -c test/your_api_config.json

# Make requests to test it

Version Your Extensions

quickmcp build ce 
  -c config.json 
  --version "2.0.0" 
  -m

Semantic versioning keeps your users happy!

The Full Command Reference

Here’s the complete syntax: 

quickmcp build ce 
  -c <config-path>              # Or --spec-url for new configs
  -m                            # Enable AI metadata
  -k <gemini-api-key>           # Or use GOOGLE_API_KEY env var
  --author-name "Your Name"     # Required unless using -m
  --display-name "My Extension" # Optional, AI can generate
  --description "What it does"  # Optional, AI can generate
  --version "1.0.0"             # Optional, defaults to 1.0.0
  --keywords "api,integration"  # Optional, AI can generate
  --author-url "https://..."    # Optional
  --homepage "https://..."      # Optional
  --documentation "https://..." # Optional
  --license "MIT"               # Optional, defaults to MIT
  -o ./output                   # Optional output directory
  --skip-readme                 # Skip README generation

Aliases: These all work the same:

  • quickmcp build ce
  • quickmcp build claude-extension
  • quickmcp build claude

What Else Can QuickMCP Do?

The extension builder is the newest feature, but QuickMCP has been around for a bit with some other cool features:

Build Config Files First

Before building extensions, you can create and test your MCP server configuration: 

# Build a config with interactive prompts
quickmcp build config 
  --spec-url https://petstore.swagger.io/v2/swagger.json 
  --server-name "Petstore" 
  --auth apiKey

# Test it immediately
quickmcp serve --config-path petstore_config.json

Boom. MCP server running from your config. Test it, tweak it, then build the extension.

.NET Library Integration

var serverInfo = await McpServerInfoBuilder.ForOpenApi()
    .FromUrl("https://api.example.com/openapi.json")
    .WithBaseUrl("https://api.example.com")
    .AddAuthentication(new ApiKeyAuthenticator("key", "X-API-Key"))
    .BuildAsync();

// Integrate with official MCP C# SDK
services
    .AddMcpServer()
    .WithQuickMCP(serverInfo)
    .WithStdioServerTransport();

Type-safe, async, and production-ready.

Server Registry

# Save a server config
quickmcp add server config.json -n MyAPI

# List your servers
quickmcp list server

# Serve by name
quickmcp serve -i MyAPI

No more hunting for config files!

Common Questions

Q: Do I need to know .NET to use this?
A: Nope! The CLI is standalone. Just install and run.

Q: Does it cost money?
A: QuickMCP is free and MIT licensed. You only pay for Gemini API calls (fractions of a penny per build).

Q: Can I use it without AI?
A: Yep! Just skip the -m flag and provide metadata manually.

Q: What if my API doesn’t have an OpenAPI spec?
A: You can write a config manually, or use the build spec command to generate one from documentation URLs!

Q: Does it work with private APIs?
A: Absolutely! Point it at your internal OpenAPI spec or discovery doc.

Q: Can I customize the generated files?
A: Sure! They’re all JSON/Markdown. Edit after generation if needed.

Get Started Now!

Install QuickMCP CLI

dotnet tool install -g quickmcp.cli

Get a Gemini API Key

  1. Visit https://aistudio.google.com/app/apikey
  2. Create a new API key (free tier available!)
  3. Set it: export GOOGLE_API_KEY=your_key

Build Your First Extension

Option A: Two-step (recommended for learning) 

# Step 1: Create config
quickmcp build config 
  --spec-url https://petstore.swagger.io/v2/swagger.json 
  --server-name "Petstore API" 
  --auth apiKey

# Review the generated config file, then...

# Step 2: Build extension
quickmcp build ce 
  -c petstore_config.json 
  -m 
  --author-name "Swagger"

Option B: All-in-one (faster) 

quickmcp build ce 
  --spec-url https://petstore.swagger.io/v2/swagger.json 
  --server-name "Petstore API" 
  --auth apiKey 
  -m 
  --author-name "Swagger"

# Install petstore.mcpb in Claude Desktop
# Profit!

Join The Community

This is still pretty new, and we’d love your feedback!

  • Star the repo: github.com/gunpal5/QuickMCP
  • Report issues: Use GitHub Issues
  • Feature ideas: Open a discussion
  • Read the docs: Check out the wiki
  • Try it out: Build something cool and share!

Wrapping Up

Look, I get it. You’ve got APIs to integrate, features to ship, and limited time. QuickMCP’s Claude Extension Builder gives you back that time.

One command. AI-powered metadata. Production-ready extensions. What are you waiting for?

Go build something awesome!

Try it now: 

dotnet tool install -g quickmcp.cli
quickmcp build ce --help

Links:

Have you built a Claude Desktop extension? What APIs are you integrating? Drop a comment below!

Leave a Reply