MCP TypeScript Template 🚀

Jumpstart your Model Context Protocol (MCP) Client & Server development with this TypeScript Repo Template!

This template provides a solid, beginner-friendly foundation for building robust MCP servers and clients, adhering to the MCP 2025-03-26 specification. It includes production-ready utilities, a well-structured codebase, working examples, and clear documentation to get you up and running quickly.

Whether you're creating a new MCP server to extend an AI's capabilities or integrating MCP client features into your application, this template is your starting point.

📋 Table of Contents

• ✨ Key Features
• 🌟 Projects Using This Template
• 🏁 Quick Start
• ⚙️ Configuration
• 🔩 Server Configuration (Environment Variables)
• 🔌 Client Configuration (src/mcp-client/client-config/mcp-config.json)
• 🏗️ Project Structure
• 🧩 Adding Tools/Resources
• 🌍 More MCP Resources
• 📜 License
• 📊 Detailed Features Table

✨ Key Features

For a more granular breakdown, see the Detailed Features Table below.

🌟 Projects Using This Template

This template is already powering several MCP servers, demonstrating its flexibility and robustness:

Note: toolkit-mcp-server was initially built using an older version of this template and is pending updates to the latest structure.

You can also see my GitHub profile for additional MCP servers I've created, many of which are planned to be migrated to or built upon this template in the future.

🏁 Quick Start

Get the example server running in minutes:

1. Clone the repository:

   git clone https://github.com/cyanheads/mcp-ts-template.git
   cd mcp-ts-template

2. Install dependencies:

   npm install

3. Build the project:

   npm run build
   # Or use 'npm run rebuild' for a clean install (deletes node_modules, logs, dist)

4. Format the code (Optional but Recommended):

   npm run format

5. Run the Example Server:

   • Via Stdio (Default): Many MCP host applications will run this automatically using stdio. To run manually for testing:

     npm start
     # or 'npm run start:stdio'

   • Via Streamable HTTP:

     npm run start:http

     This starts a Streamable HTTP server (default: http://127.0.0.1:3010) which uses Server-Sent Events for the server-to-client streaming component. The port, host, and allowed origins are configurable via environment variables (see Configuration).

⚙️ Configuration

🔩 Server Configuration (Environment Variables)

Configure the MCP server's behavior using these environment variables:

Note on HTTP Port Retries: If the MCP_HTTP_PORT is busy, the server automatically tries the next port (up to 15 times).

Security Note for HTTP Transport: When using MCP_TRANSPORT_TYPE=http, authentication is mandatory as per the MCP specification. This template includes JWT-based authentication middleware (src/mcp-server/transports/authentication/authMiddleware.ts). You MUST set a strong, unique MCP_AUTH_SECRET_KEY in your production environment for this security mechanism to function correctly. Failure to do so will result in bypassed authentication checks in development and fatal errors in production.

🔌 Client Configuration (src/mcp-client/client-config/mcp-config.json)

Configure the connections for the built-in MCP client using src/mcp-client/client-config/mcp-config.json. If this file is missing, it falls back to src/mcp-client/client-config/mcp-config.json.example.

This file defines external MCP servers the client can connect to. The client implementation adheres to the MCP 2025-03-26 specification.

Example mcp-config.json (see src/mcp-client/client-config/mcp-config.json.example for the full version):

{
  "mcpServers": {
    "my-stdio-server": {
      "command": "node", // Command or executable
      "args": ["/path/to/my-server/index.js"], // Arguments for stdio
      "env": { "LOG_LEVEL": "debug" }, // Optional environment variables
      "transportType": "stdio" // Explicitly stdio (or omit for default)
    },
    "my-http-server": {
      "command": "http://localhost:8080", // Base URL for HTTP
      "args": [], // Not used for HTTP
      "env": {}, // Not used for HTTP
      "transportType": "http" // Explicitly http
    }
  }
}

• command: Executable path (stdio) or Base URL (http).
• args: Array of arguments (required for stdio).
• env: Optional environment variables to set for the server process (stdio).
• transportType: stdio (default) or http.

See src/mcp-client/client-config/configLoader.ts for the Zod validation schema and src/mcp-client/client-config/mcp-config.json.example for a complete example.

🏗️ Project Structure

This project follows a standard TypeScript project layout. Here's an overview of the key directories and files:

• .clinerules: Developer cheatsheet and guidelines for LLM coding agents working with this repository.
• docs/: Contains project documentation, including API references and the auto-generated tree.md file.
• scripts/: Utility scripts for development tasks like cleaning builds, generating directory trees, and fetching OpenAPI specs.
• src/: The heart of the application, containing all TypeScript source code.
  • src/config/: Handles loading and validation of environment variables and application configuration.
  • src/mcp-client/: Implements the MCP client logic for connecting to and interacting with external MCP servers. This includes client configuration, core connection management, and transport handlers.
  • src/mcp-server/: Contains the MCP server implementation provided by this template, including example tools, resources, and transport handlers (Stdio, HTTP).
  • src/services/: Provides reusable modules for integrating with external services, such as DuckDB for local data storage and OpenRouter for LLM access.
  • src/types-global/: Defines shared TypeScript interfaces and type definitions used across the project, particularly for error handling and MCP-specific types.
  • src/utils/: A collection of core utilities.
    • src/utils/internal/: Core internal utilities like the logger, error handler, and request context management.
    • src/utils/metrics/: Utilities related to metrics, such as token counting.
    • src/utils/network/: Network-related utilities, like fetch with timeout.
    • src/utils/parsing/: Utilities for parsing data, such as dates and JSON.
    • src/utils/security/: Security-focused utilities including ID generation, rate limiting, and input sanitization.
  • src/index.ts: The main entry point for the application, responsible for initializing and starting the MCP server. The MCP client is meant to be built upon, so it does not have a dedicated entry point in this template.
• package.json: Defines project metadata, dependencies, and npm scripts.
• README.md: This file, providing an overview of the project.
• tsconfig.json: TypeScript compiler options for the project.
• LICENSE: Apache 2.0 License file.

Explore the full structure yourself:

See the current file tree in docs/tree.md or generate it dynamically:

npm run tree

(This uses scripts/tree.ts to generate a current file tree, respecting .gitignore.)

🧩 Adding Your Own Tools & Resources

This template is designed for extension! Follow the high-level SDK patterns:

1. Create Directories: Add new directories under src/mcp-server/tools/yourToolName/ or src/mcp-server/resources/yourResourceName/.
2. Implement Logic (logic.ts): Define Zod schemas for inputs/outputs and write your core processing function.
3. Register (registration.ts):
   • Tools: Use server.tool(name, description, zodSchemaShape, handler) (SDK v1.10.2+). This handles schema generation, validation, and routing. Remember to add relevant annotations (readOnlyHint, destructiveHint, etc.) as untrusted hints.
   • Resources: Use server.resource(regName, template, metadata, handler).
   • Wrap logic in ErrorHandler.tryCatch for robust error handling.
4. Export & Import: Export the registration function from your new directory's index.ts and call it within createMcpServerInstance in src/mcp-server/server.ts.

Refer to the included EchoTool and EchoResource examples and the .clinerules cheatsheet for detailed patterns.

For an example of a tool that performs asynchronous operations, such as making an external API call, see the get_random_cat_fact tool located in src/mcp-server/tools/catFactFetcher/. This tool demonstrates how to use async/await within your tool's logic and handler, manage Promises, and integrate external data sources.

🌍 Explore More MCP Resources

Looking for more examples, guides, and pre-built MCP servers? Check out the companion repository:

➡️ cyanheads/model-context-protocol-resources

This collection includes servers for Filesystem, Obsidian, Git, GitHub, Perplexity, Atlas, Ntfy, and more, along with in-depth guides based on my real-world MCP development.

📜 License

This project is licensed under the Apache License 2.0. See the LICENSE file for details.

📊 Detailed Features Table