Integrates with Biome for code linting and formatting, ensuring code quality standards in the MCP server

Enables repository management and version control for MCP server development

Provides CI/CD pipelines for testing, building, and releasing MCP servers, with automated template synchronization to derived repositories

Runs on Node.js runtime environment with testing across multiple Node.js versions (18, 20, and 22)

Enables automated package publishing and version management for MCP servers

Automates version bumping and release creation based on commit messages

Built with TypeScript for type safety and modern JavaScript features in MCP server development

Provides comprehensive testing framework with coverage reporting for MCP tools

Used for dependency management and script execution in development workflow

Enables schema validation for MCP tool inputs with automatic JSON Schema generation

1. Click on "Install Server".

2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.

3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Template show me how to create a new tool"

That's it! The server will respond to your query, and you can continue using it as needed.

Here is a step-by-step guide with screenshots.

# Start development server with hot reload
yarn dev

# Run tests
yarn test

# Run tests in watch mode
yarn test:watch

# Build the project
yarn build

# Run linting
yarn lint

# Auto-fix linting issues
yarn lint:fix

mcp-template/
├── src/
│ ├── index.ts # MCP server entry point
│ ├── cli.ts # CLI entry point (optional)
│ ├── tools/
│ │ ├── example.ts # Example tool implementation
│ │ ├── example.test.ts # Example tool tests
│ │ └── fetch-example.ts # HTTP fetch example tool
│ └── utils/
│ ├── validation.ts # Common validation schemas
│ └── fetch.ts # HTTP utilities with caching
├── .github/
│ └── workflows/
│ ├── ci.yml # Continuous Integration
│ ├── semantic-release.yml # Automated versioning
│ └── template-sync-*.yml # Template synchronization
├── .template-marker # Template tracking file
├── .template-version # Template version tracking
└── shared/ # Shared utilities for template sync

import { z } from 'zod';
import { zodToJsonSchema } from 'zod-to-json-schema';

// Define input schema
export const MyToolSchema = z.object({
 input: z.string().describe('Input parameter'),
 count: z.number().optional().default(1).describe('Number of iterations'),
});

export type MyToolInput = z.infer<typeof MyToolSchema>;

// Export tool schema for MCP registration
export const myToolSchema = {
 name: 'my_tool',
 description: 'Description of what this tool does',
 inputSchema: zodToJsonSchema(MyToolSchema),
};

// Tool implementation
export async function myTool(input: unknown) {
 const validated = MyToolSchema.parse(input);
 
 // Your tool logic here
 const result = `Processed: ${validated.input}`;
 
 return {
 content: [
 {
 type: 'text',
 text: result,
 },
 ],
 };
}

// In src/index.ts
import { myToolSchema, myTool } from './tools/my-tool.js';

// Register in ListToolsRequestSchema handler
server.setRequestHandler(ListToolsRequestSchema, async () => ({
 tools: [
 myToolSchema,
 // ... other tools
 ],
}));

// Register in CallToolRequestSchema handler
server.setRequestHandler(CallToolRequestSchema, async (request) => {
 const { name, arguments: args } = request.params;
 
 switch (name) {
 case 'my_tool':
 return await myTool(args);
 // ... other tools
 default:
 throw new Error(`Unknown tool: ${name}`);
 }
});

template_repository: mcp-template
template_version: 1.0.0
created_from_template: true
sync_enabled: true

sync_patterns:
 - "tsconfig.json"
 - "biome.json" 
 - "vitest.config.ts"
 - ".github/workflows/**"
 - "src/utils/validation*"
 # Add patterns for files to sync

ignore_patterns:
 - "src/tools/**" # Don't sync tool implementations
 - "README.md" # Keep custom README
 # Add patterns for files to ignore

feat: add new tool for data processing
fix: resolve validation error in example tool
docs: update README with usage examples
chore: update dependencies