Generate TypeScript MCP Server

Create a complete Model Context Protocol (MCP) server in TypeScript using the MCP TypeScript SDK v2 with the following specifications:

Requirements

1. Project Structure: Create a new TypeScript/Node.js project with proper directory structure
2. NPM Packages: The v1 monolithic @modelcontextprotocol/sdk package is retired. Use the focused v2 packages:
   • @modelcontextprotocol/server — server implementation (stdio transport via the @modelcontextprotocol/server/stdio subpath)
   • @modelcontextprotocol/node — Node HTTP transport (NodeStreamableHTTPServerTransport), or a framework adapter: @modelcontextprotocol/express, @modelcontextprotocol/hono, @modelcontextprotocol/fastify — each adapter requires its peer framework to be installed alongside it (e.g. @modelcontextprotocol/express + express)
   • @modelcontextprotocol/core — shared protocol schemas (import *Schema constants from here, not from sdk/types.js)
   • zod@^4.2 — v2 requires Zod 4.2+; do not use zod@3
3. Runtime: Node.js 20+ (v2 minimum); ESM-first with "type": "module" (a CommonJS build is also shipped, so require() works if needed)
4. Server Type: Choose between HTTP (Streamable HTTP transport) or stdio-based server. SSE and WebSocket transports were removed in v2 — do not generate them.
5. Tools: Create at least one useful tool with proper schema validation
6. Error Handling: Include comprehensive error handling and validation

Implementation Details

Project Setup

• Initialize with npm init and create package.json
• Install dependencies: @modelcontextprotocol/server, zod@^4.2, and the transport package — @modelcontextprotocol/node for plain Node HTTP, or a framework adapter together with its peer framework (e.g. npm install @modelcontextprotocol/express express)
• Configure TypeScript with ES modules: "type": "module" in package.json
• Add dev dependencies: tsx or ts-node for development
• Create proper .gitignore file

Server Configuration

• Use McpServer class from @modelcontextprotocol/server for high-level implementation
• Set server name and version
• Choose the appropriate transport:
  • HTTP (Node): NodeStreamableHTTPServerTransport from @modelcontextprotocol/node
  • HTTP (Web Standard runtimes): WebStandardStreamableHTTPServerTransport from @modelcontextprotocol/server
  • stdio: StdioServerTransport from @modelcontextprotocol/server/stdio
• For HTTP: prefer a framework adapter (@modelcontextprotocol/express, etc.) with proper middleware and error handling
• Note that v2 uses Web Standard Headers/Request types; read headers with ctx.http?.req?.headers.get('x-custom')

Tool Implementation

• Use registerTool() with a config object — v1 variadic .tool() signatures are gone:

  server.registerTool('greet', {
    description: 'Greet user',
    inputSchema: z.object({ name: z.string() })
  }, async ({ name }, ctx) => {
    return { content: [{ type: 'text', text: `Hello, ${name}!` }] };
  });
  

• Schemas must be full Zod objects (z.object({...})) — raw shape objects ({ name: z.string() }) are deprecated
• Provide clear title and description fields
• Return both content and structuredContent in results
• The handler's second parameter is a structured ctx object (replaces v1 extra): ctx.mcpReq.signal, ctx.mcpReq.id, ctx.mcpReq.send(...), ctx.mcpReq.notify(...)
• Implement proper error handling with try-catch blocks; use the v2 error hierarchy (ProtocolError, SdkError, SdkHttpError with .status) instead of v1 McpError/StreamableHTTPError
• Support async operations where appropriate

Resource/Prompt Setup (Optional)

• Add resources using registerResource() with ResourceTemplate for dynamic URIs
• Add prompts using registerPrompt() with argument schemas (same config-object style as registerTool())
• Consider adding completion support for better UX; note the v2 completable() wrapper order: completable(z.string(), callback).optional() (optional applied outside)

Code Quality

• Use TypeScript for type safety
• Follow async/await patterns consistently
• Implement proper cleanup on transport close events
• Use environment variables for configuration
• Add inline comments for complex logic
• Structure code with clear separation of concerns

Example Tool Types to Consider

• Data processing and transformation

…