The Model Context Protocol (MCP) is an open standard that enables seamless communication between AI assistants and external data sources or tools. Build powerful integrations that extend AI capabilities with your custom servers.
Get up and running in minutes with our TypeScript and Python SDKs
Connect any data source, API, or service to AI assistants
Bidirectional streaming for responsive interactions
Follow this step-by-step workflow to create your first MCP server:
Set up your development environment with the MCP SDK
Initialize your MCP server with proper configuration
Register the capabilities your server provides
Write logic for processing requests and responses
Validate functionality and deploy to production
# Basic MCP Server in Python
from mcp.server import Server, stdio_server
from mcp.server.models import InitializationOptions
from mcp.types import Tool, Resource, TextContent
import asyncio
class MyMCPServer:
def __init__(self):
self.server = Server("my-mcp-server")
self.setup_handlers()
def setup_handlers(self):
"""Register server capabilities"""
@self.server.list_tools()
async def handle_list_tools():
return [
Tool(
name="get_data",
description="Retrieve data from source",
inputSchema={
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Data query"
}
},
"required": ["query"]
}
)
]
@self.server.call_tool()
async def handle_call_tool(name: str, arguments: dict):
if name == "get_data":
query = arguments.get("query")
# Implement your logic here
result = await fetch_data(query)
return [TextContent(text=result)]
raise ValueError(f"Unknown tool: {name}")
async def run(self):
"""Start the MCP server"""
async with stdio_server() as (read_stream, write_stream):
await self.server.run(
read_stream,
write_stream,
InitializationOptions(
server_name="my-mcp-server",
server_version="1.0.0"
)
)
# Start server
if __name__ == "__main__":
server = MyMCPServer()
asyncio.run(server.run())
Enhance your MCP server with advanced capabilities for production use:
Expose structured data and documents to AI assistants
Provide reusable prompt patterns for common tasks
Offer custom completion suggestions to AI models
Implement robust error recovery and logging
// Advanced MCP Server in TypeScript
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ListResourcesRequestSchema,
ListPromptsRequestSchema,
GetPromptRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';
class AdvancedMCPServer {
private server: Server;
private db: DatabaseConnection;
private cache: CacheManager;
constructor() {
this.server = new Server(
{
name: 'advanced-mcp-server',
version: '1.0.0',
},
{
capabilities: {
resources: {},
tools: {},
prompts: {},
},
}
);
this.setupHandlers();
}
private setupHandlers(): void {
// List available resources
this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
resources: [
{
uri: 'db://users',
name: 'User Database',
description: 'Access to user information',
mimeType: 'application/json',
},
{
uri: 'api://analytics',
name: 'Analytics API',
description: 'Performance metrics and analytics',
mimeType: 'application/json',
},
],
}));
// List available prompts
this.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
prompts: [
{
name: 'analyze_data',
description: 'Analyze dataset with specified criteria',
arguments: [
{
name: 'dataset',
description: 'Dataset identifier',
required: true,
},
{
name: 'criteria',
description: 'Analysis criteria',
required: false,
},
],
},
],
}));
// Handle prompt requests
this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
if (request.params.name === 'analyze_data') {
const dataset = request.params.arguments?.dataset || 'default';
const criteria = request.params.arguments?.criteria || 'standard';
return {
prompt: {
name: 'analyze_data',
description: 'Data analysis prompt',
messages: [
{
role: 'user',
content: {
type: 'text',
text: `Analyze the ${dataset} dataset using ${criteria} criteria.
Focus on: trends, anomalies, and actionable insights.`,
},
},
],
},
};
}
throw new Error(`Unknown prompt: ${request.params.name}`);
});
// Handle tool calls
this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
switch (name) {
case 'query_database':
return await this.queryDatabase(args);
case 'cache_operation':
return await this.handleCache(args);
case 'execute_workflow':
return await this.executeWorkflow(args);
default:
throw new Error(`Unknown tool: ${name}`);
}
});
}
private async queryDatabase(args: any): Promise {
// Implement database query logic
const query = args.query;
const params = args.params || [];
try {
const result = await this.db.query(query, params);
return {
content: [
{
type: 'text',
text: JSON.stringify(result, null, 2),
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: `Database error: ${error.message}`,
},
],
isError: true,
};
}
}
async run(): Promise {
const transport = new StdioServerTransport();
await this.server.connect(transport);
console.error('Advanced MCP Server running on stdio');
}
}
// Start server
const server = new AdvancedMCPServer();
server.run().catch(console.error);
Connect your MCP server to various data sources and services:
| Integration Type | Use Case | Complexity | Performance |
|---|---|---|---|
| Database | Structured data queries | Medium | High |
| REST API | External service integration | Low | Medium |
| File System | Local file operations | Low | High |
| Message Queue | Async processing | High | High |
| WebSocket | Real-time updates | Medium | Very High |
Start quickly with our pre-built server templates:
Deploy your MCP server with enterprise-grade reliability:
Set up environment variables and secrets management
Package your server with Docker for consistent deployment
Implement comprehensive observability
Configure auto-scaling and load balancing
Apply security best practices and authentication
# Docker deployment configuration
FROM node:20-alpine
WORKDIR /app
# Install dependencies
COPY package*.json ./
RUN npm ci --only=production
# Copy server code
COPY . .
# Build TypeScript
RUN npm run build
# Security: Run as non-root user
USER node
# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD node healthcheck.js
# Start server
CMD ["node", "dist/index.js"]
---
# docker-compose.yml
version: '3.8'
services:
mcp-server:
build: .
container_name: mcp-server
environment:
- NODE_ENV=production
- DB_HOST=${DB_HOST}
- DB_PASSWORD=${DB_PASSWORD}
- REDIS_URL=${REDIS_URL}
ports:
- "3000:3000"
volumes:
- ./config:/app/config:ro
networks:
- mcp-network
deploy:
replicas: 3
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
redis:
image: redis:alpine
container_name: mcp-redis
volumes:
- redis-data:/data
networks:
- mcp-network
postgres:
image: postgres:15
container_name: mcp-db
environment:
- POSTGRES_DB=mcp
- POSTGRES_PASSWORD=${DB_PASSWORD}
volumes:
- postgres-data:/var/lib/postgresql/data
networks:
- mcp-network
networks:
mcp-network:
driver: bridge
volumes:
redis-data:
postgres-data:
Always validate and sanitize inputs from AI assistants to prevent injection attacks and ensure data integrity.
Implement comprehensive error handling with meaningful error messages for debugging and user feedback.
Use caching, connection pooling, and async operations to handle high request volumes efficiently.
Maintain backward compatibility and use semantic versioning for your MCP server releases.
Implement unit tests, integration tests, and end-to-end tests for reliable server operation.
Provide clear documentation for tools, resources, and prompts to help AI assistants use your server effectively.