MCP SDK TypeScript Bootstrapper

Bootstrap production-ready MCP servers using the official TypeScript SDK with proper transport configuration, tool/resource handlers, and security best practices.

Capabilities

•Generate MCP server projects with TypeScript SDK
•Configure stdio, SSE, or WebSocket transports
•Scaffold tool and resource handlers
•Set up proper error handling and validation
•Configure capability declarations
•Implement security best practices

Usage

Invoke this skill when you need to:

•Create a new MCP server from scratch
•Add MCP capabilities to existing projects
•Scaffold tool and resource implementations
•Configure MCP transport layers

Inputs

Parameter	Type	Required	Description
serverName	string	Yes	Name of the MCP server (kebab-case)
description	string	Yes	Server description for clients
transport	string	No	stdio, sse, or websocket (default: stdio)
tools	array	No	List of tools to scaffold
resources	array	No	List of resources to provide
capabilities	object	No	Server capability declarations

Tool Definition Structure

json

{
  "tools": [
    {
      "name": "read_file",
      "description": "Read contents of a file",
      "inputSchema": {
        "type": "object",
        "properties": {
          "path": { "type": "string", "description": "File path to read" }
        },
        "required": ["path"]
      }
    }
  ]
}

Resource Definition Structure

json

{
  "resources": [
    {
      "uriTemplate": "file:///{path}",
      "name": "File Resource",
      "description": "Access file contents",
      "mimeType": "text/plain"
    }
  ]
}

Output Structure

code

<serverName>/
├── package.json
├── tsconfig.json
├── .gitignore
├── README.md
├── src/
│   ├── index.ts              # Server entry point
│   ├── server.ts             # MCP server setup
│   ├── transport/
│   │   ├── stdio.ts          # Stdio transport
│   │   ├── sse.ts            # SSE transport (if selected)
│   │   └── websocket.ts      # WebSocket transport (if selected)
│   ├── tools/
│   │   ├── index.ts          # Tool registry
│   │   └── <tool>.ts         # Individual tool handlers
│   ├── resources/
│   │   ├── index.ts          # Resource registry
│   │   └── <resource>.ts     # Resource providers
│   ├── prompts/
│   │   └── index.ts          # Prompt templates (optional)
│   └── utils/
│       ├── validation.ts     # Input validation helpers
│       ├── errors.ts         # MCP error handling
│       └── logging.ts        # Structured logging
├── tests/
│   ├── tools/
│   └── resources/
└── mcp.json                  # MCP server manifest

Generated Code Patterns

Server Setup (src/server.ts)

typescript

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { registerTools } from './tools';
import { registerResources } from './resources';

export async function createServer() {
  const server = new McpServer({
    name: '<serverName>',
    version: '1.0.0',
  });

  // Register capabilities
  registerTools(server);
  registerResources(server);

  return server;
}

export async function startServer() {
  const server = await createServer();
  const transport = new StdioServerTransport();

  await server.connect(transport);

  console.error('[MCP] Server started on stdio');
}

Tool Handler (src/tools/<name>.ts)

typescript

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';
import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';

const inputSchema = z.object({
  path: z.string().describe('File path to read'),
});

export function registerReadFileTool(server: McpServer) {
  server.tool(
    'read_file',
    'Read contents of a file',
    inputSchema.shape,
    async (args) => {
      const { path } = inputSchema.parse(args);

      try {
        // Implementation
        const content = await readFile(path, 'utf-8');
        return {
          content: [{ type: 'text', text: content }],
        };
      } catch (error) {
        throw new McpError(
          ErrorCode.InternalError,
          `Failed to read file: ${error.message}`
        );
      }
    }
  );
}

Resource Provider (src/resources/<name>.ts)

typescript

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';

export function registerFileResource(server: McpServer) {
  server.resource(
    'file:///{path}',
    'File Resource',
    'Access file contents by path',
    async (uri) => {
      const path = uri.pathname;

      const content = await readFile(path, 'utf-8');

      return {
        contents: [{
          uri: uri.href,
          mimeType: 'text/plain',
          text: content,
        }],
      };
    }
  );
}

Dependencies

json

{
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0",
    "zod": "^3.22.0"
  },
  "devDependencies": {
    "@types/node": "^20.0.0",
    "typescript": "^5.0.0",
    "vitest": "^1.0.0"
  }
}

Transport Configurations

Stdio (Default)

typescript

import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
const transport = new StdioServerTransport();

SSE (HTTP Server-Sent Events)

typescript

import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
import express from 'express';

const app = express();
app.get('/sse', (req, res) => {
  const transport = new SSEServerTransport('/message', res);
  server.connect(transport);
});

WebSocket

typescript

import { WebSocketServerTransport } from '@modelcontextprotocol/sdk/server/websocket.js';
import { WebSocketServer } from 'ws';

const wss = new WebSocketServer({ port: 3000 });
wss.on('connection', (ws) => {
  const transport = new WebSocketServerTransport(ws);
  server.connect(transport);
});

Workflow

•Validate inputs - Check server name, tool/resource definitions
•Create project structure - Set up folders and base files
•Generate package.json - Configure dependencies
•Generate tsconfig.json - TypeScript configuration
•Create server entry - Main server setup
•Generate transport layer - Selected transport implementation
•Scaffold tools - Tool handlers with schemas
•Scaffold resources - Resource providers
•Create utilities - Validation, errors, logging
•Set up tests - Test structure for tools/resources

Best Practices Applied

•Zod schema validation for all inputs
•Proper MCP error codes and messages
•Structured logging to stderr
•Clean separation of tools/resources
•TypeScript strict mode
•Comprehensive error handling
•Input sanitization

References

•MCP TypeScript SDK: https://github.com/modelcontextprotocol/typescript-sdk
•MCP Specification: https://modelcontextprotocol.io/
•MCP Server Examples: https://github.com/modelcontextprotocol/servers

Target Processes

•mcp-server-bootstrap
•mcp-tool-implementation
•mcp-resource-provider
•mcp-transport-layer