CR

create-mcp-server

Generates local MCP server scaffolding and synthetic test data for building and debugging agentic systems.

Install

mkdir -p .claude/skills/create-mcp-server-appliedcognetics && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/15949" && unzip -o skill.zip -d .claude/skills/create-mcp-server-appliedcognetics && rm skill.zip

Installs to .claude/skills/create-mcp-server-appliedcognetics

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Scaffold a local MCP server with synthetic data for agentic system development. Use when creating a new data source, building tool endpoints, or generating test data for agents to consume.
188 chars✓ has a “when” trigger
Intermediate

Key capabilities

  • Scaffold a local MCP server directory structure
  • Create MCP server entry points
  • Generate tool handler files for each exposed tool
  • Produce synthetic JSON data files for testing
  • Wire the server into VS Code configuration
  • Update the tool registry with new server tools

How it works

This skill creates an MCP server project by generating directory structures, entry points, tool handlers, and synthetic data files based on user-defined server details.

Inputs & outputs

You give it
server name, purpose, and list of tools with descriptions
You get back
a scaffolded MCP server project with synthetic data and updated configuration files

When to use create-mcp-server

  • Building new MCP tools
  • Scaffolding data sources for agents
  • Generating test data

About this skill

Create MCP Server

When to Use

  • Creating a new data source that agents consume via MCP tools
  • Building tool endpoints that serve synthetic data for testing
  • Adding a new MCP server to an existing agentic system
  • Regenerating synthetic data for an existing MCP server

Procedure

  1. Ask the user for the server's name (kebab-case), purpose (one sentence), and list of tools it should expose (name + one-line description each)
  2. Determine the data domain — what kind of data will each tool return. Reference synthetic data patterns for generation strategies per data type.
  3. Create the server project directory:
    mcp-servers/{server-name}/
    ├── src/
    │   ├── index.ts           # MCP server entry point
    │   ├── tools/             # One file per tool handler
    │   └── data/              # Synthetic data JSON files
    ├── package.json
    └── tsconfig.json
    
  4. Scaffold the MCP server entry point using the MCP server template. Register each tool with name, description, and input schema (JSON Schema format).
  5. For each tool, create a handler in src/tools/{tool-name}.ts:
    • Parse input parameters from the MCP CallToolRequest
    • Load synthetic data from src/data/{dataset}.json
    • Filter/transform data based on input parameters
    • Return structured JSON response
  6. Generate synthetic data files in src/data/ following the synthetic data patterns:
    • Match the schema each tool expects to return
    • Include 10-50 records per dataset — enough for realistic testing
    • Use realistic but fictional values (no real PII, real tickers are OK)
  7. Wire the server into VS Code by updating .vscode/mcp.json following the MCP config reference:
    {
      "servers": {
        "{server-name}": {
          "type": "stdio",
          "command": "npx",
          "args": ["tsx", "mcp-servers/{server-name}/src/index.ts"]
        }
      }
    }
    
  8. Update the tool registry with the new server's tools, input shapes, and agent assignments
  9. Verify: server starts without errors, each tool returns valid JSON, .vscode/mcp.json entry exists

Validation Checklist

  • Server directory follows mcp-servers/{name}/ structure
  • src/index.ts imports and registers all tool handlers
  • Each tool has a handler file in src/tools/
  • Each handler has typed input schema matching the tool registry
  • Synthetic data files exist in src/data/ with 10-50 records each
  • Data values are realistic but fictional — no real PII
  • .vscode/mcp.json has a valid entry for this server
  • Tool registry artifact is updated with new tools
  • npx tsx mcp-servers/{name}/src/index.ts starts without errors

When not to use it

  • When the user wants to use real PII data
  • When the user wants to use real tickers for synthetic data

Limitations

  • Synthetic data should not contain real PII
  • Synthetic data should include 10-50 records per dataset
  • Tool registry artifact must be updated

How it compares

This skill automates the scaffolding of a local MCP server with synthetic data for agentic system development, unlike manual setup that requires creating each file and configuration entry individually.

Compared to similar skills

create-mcp-server side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
create-mcp-server (this skill)05moNo flagsIntermediate
mcp-builder1363moReviewAdvanced
copilot-sdk74moReviewIntermediate
chatgpt-app-builder52moReviewAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

mcp-builder

anthropics

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

136215

copilot-sdk

github

Build agentic applications with GitHub Copilot SDK. Use when embedding AI agents in apps, creating custom tools, implementing streaming responses, managing sessions, connecting to MCP servers, or creating custom agents. Triggers on Copilot SDK, GitHub SDK, agentic app, embed Copilot, programmable agent, MCP server, custom agent.

763

chatgpt-app-builder

mcp-use

Build ChatGPT apps with interactive widgets using mcp-use and OpenAI Apps SDK. Use when creating ChatGPT apps, building MCP servers with widgets, defining React widgets, working with Apps SDK, or when user mentions ChatGPT widgets, mcp-use widgets, or Apps SDK development.

535

create-mcp-app

modelcontextprotocol

This skill should be used when the user asks to "create an MCP App", "add a UI to an MCP tool", "build an interactive MCP View", "scaffold an MCP App", or needs guidance on MCP Apps SDK patterns, UI-resource registration, MCP App lifecycle, or host integration. Provides comprehensive guidance for building MCP Apps with interactive UIs.

331

mcporter

openclaw

Use the mcporter CLI to list, configure, auth, and call MCP servers/tools directly (HTTP or stdio), including ad-hoc servers, config edits, and CLI/type generation.

726

calcom-api

calcom

Interact with the Cal.com API v2 to manage scheduling, bookings, event types, availability, and calendars. Use this skill when building integrations that need to create or manage bookings, check availability, configure event types, or sync calendars with Cal.com's scheduling infrastructure.

216

Search skills

Search the agent skills registry