Getting Started with MCP

TypeScript/JavaScript Example

import { MCPClient } from '@modelcontextprotocol/client';

async function main() {
  // Create an MCP client
  const client = new MCPClient();
  
  // Connect to an MCP server (e.g., filesystem server)
  await client.connect({
    transport: 'stdio',
    command: 'npx',
    args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/directory']
  });
  
  // List available tools
  const tools = await client.listTools();
  console.log('Available tools:', tools);
  
  // Call a tool
  const result = await client.callTool({
    name: 'readFile',
    parameters: { path: 'example.txt' }
  });
  console.log('File contents:', result);
  
  // Disconnect when done
  await client.disconnect();
}

main().catch(console.error);

Python Example

from mcp_client import MCPClient
import asyncio

async def main():
    # Create an MCP client
    client = MCPClient()
    
    # Connect to an MCP server (e.g., filesystem server)
    await client.connect(
        transport='stdio',
        command='npx',
        args=['-y', '@modelcontextprotocol/server-filesystem', '/path/to/directory']
    )
    
    # List available tools
    tools = await client.list_tools()
    print('Available tools:', tools)
    
    # Call a tool
    result = await client.call_tool(
        name='readFile',
        parameters={'path': 'example.txt'}
    )
    print('File contents:', result)
    
    # Disconnect when done
    await client.disconnect()

asyncio.run(main())

TypeScript/JavaScript Example

import { createServer, MCPTool } from '@modelcontextprotocol/server';

// Define a tool
const greetingTool: MCPTool = {
  name: 'greeting',
  description: 'Returns a greeting message',
  parameters: {
    type: 'object',
    properties: {
      name: {
        type: 'string',
        description: 'Name to greet'
      }
    },
    required: ['name']
  },
  handler: async (params) => {
    return `Hello, ${params.name}!`;
  }
};

// Create an MCP server
const server = createServer({
  name: 'greeting-server',
  description: 'A server that provides greeting functionality',
  version: '1.0.0',
  tools: [greetingTool]
});

// Start the server
server.start();

Python Example

from mcp_server import create_server, MCPTool

# Define a tool
greeting_tool = MCPTool(
    name='greeting',
    description='Returns a greeting message',
    parameters={
        'type': 'object',
        'properties': {
            'name': {
                'type': 'string',
                'description': 'Name to greet'
            }
        },
        'required': ['name']
    }
)

# Define the handler function
async def greeting_handler(params):
    return f"Hello, {params['name']}!"

# Attach the handler
greeting_tool.handler = greeting_handler

# Create an MCP server
server = create_server(
    name='greeting-server',
    description='A server that provides greeting functionality',
    version='1.0.0',
    tools=[greeting_tool]
)

# Start the server
server.start()

Claude Desktop

Claude Desktop provides a user-friendly interface for connecting Claude to MCP servers:

1. Install Claude Desktop from Anthropic's website.
2. Open Claude Desktop and start a conversation.
3. Click on the "Connect" button in the interface.
4. Select the MCP server you want to connect to (e.g., filesystem, Git).
5. Follow the prompts to configure the server connection.
6. Once connected, Claude can access the data and tools provided by the MCP server.

Claude API with MCP

For programmatic access, you can use the Claude API with MCP:

import { MCPClient } from '@modelcontextprotocol/client';
import { Claude } from '@anthropic-ai/sdk';

async function main() {
  // Create an MCP client
  const mcpClient = new MCPClient();
  
  // Connect to an MCP server
  await mcpClient.connect({
    transport: 'stdio',
    command: 'npx',
    args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/directory']
  });
  
  // List available tools
  const tools = await mcpClient.listTools();
  
  // Create a Claude client
  const claude = new Claude({
    apiKey: process.env.ANTHROPIC_API_KEY
  });
  
  // Send a message to Claude with MCP tools
  const response = await claude.messages.create({
    model: 'claude-3-opus-20240229',
    max_tokens: 1024,
    messages: [
      {
        role: 'user',
        content: 'Please read the file example.txt and summarize its contents.'
      }
    ],
    tools: tools
  });
  
  console.log(response.content);
}

main().catch(console.error);

Security Considerations

• Limit Access: Configure MCP servers to access only the resources that are necessary for the application.
• Validate Inputs: Implement proper input validation for tool parameters to prevent security vulnerabilities.
• Use Local Transport: For sensitive operations, use stdio transport to ensure data doesn't leave the local machine.
• Secure API Keys: Protect API keys and credentials used by MCP servers.

Performance Optimization

• Cache Tool Lists: Cache the results of listTools calls to reduce latency.
• Optimize Data Transfer: Transfer only the necessary data between clients and servers to minimize overhead.
• Implement Pagination: For tools that return large amounts of data, implement pagination to avoid performance issues.
• Use Efficient Serialization: Choose efficient serialization formats for data exchange between clients and servers.

Tool Design

• Clear Descriptions: Provide clear and detailed descriptions for tools and parameters to help AI models understand how to use them.
• Consistent Naming: Use consistent naming conventions for tools and parameters across your MCP servers.
• Atomic Operations: Design tools to perform atomic operations that can be composed to achieve complex tasks.
• Error Handling: Implement robust error handling to provide informative error messages when tools fail.

Testing and Debugging

• Unit Testing: Write comprehensive unit tests for your MCP servers and tools.
• Integration Testing: Test the interaction between your MCP clients and servers to ensure compatibility.
• Logging: Implement detailed logging in your MCP servers to help debug issues.
• Mocking: Use mock MCP servers for testing to isolate client code from external dependencies.