4.2 The Model Context Protocol (MCP)

{ "name": "filesystem-mcp-server", "version": "1.0.0", "description": "MCP server providing filesystem access", "main": "dist/index.js", "type": "module", "scripts": { "build": "tsc", "start": "node dist/index.js" }, "dependencies": { "@modelcontextprotocol/sdk": "^0.1.0", "fs-extra": "^11.1.1", "path": "^0.12.7" }, "devDependencies": { "typescript": "^5.0.0", "@types/node": "^20.0.0" } }

import { Server } from '@modelcontextprotocol/sdk/server/index.js'; import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'; import fs from 'fs-extra'; import path from 'path'; class FileSystemMCPServer { private server: Server; private allowedPaths: string[]; constructor(allowedPaths: string[] = []) { this.allowedPaths = allowedPaths; this.server = new Server( { name: "filesystem-server", version: "1.0.0" }, { capabilities: { resources: {}, tools: {} } } ); this.setupResourceHandlers(); this.setupToolHandlers(); } private isPathAllowed(filePath: string): boolean { const resolvedPath = path.resolve(filePath); return this.allowedPaths.some(allowedPath => resolvedPath.startsWith(path.resolve(allowedPath)) ); } private setupResourceHandlers() { // List available file resources this.server.setRequestHandler('resources/list', async () => { const resources = []; for (const allowedPath of this.allowedPaths) { try { const files = await fs.readdir(allowedPath); for (const file of files) { const filePath = path.join(allowedPath, file); const stat = await fs.stat(filePath); if (stat.isFile()) { resources.push({ uri: `file://${filePath}`, name: file, description: `File: ${file}`, mimeType: this.getMimeType(file) }); } } } catch (error) { // Skip inaccessible directories } } return { resources }; }); // Read file content this.server.setRequestHandler('resources/read', async (request) => { const { uri } = request.params; if (!uri.startsWith('file://')) { throw new Error('Only file:// URIs are supported'); } const filePath = uri.slice(7); // Remove 'file://' prefix if (!this.isPathAllowed(filePath)) { throw new Error('Access denied to this path'); } try { const content = await fs.readFile(filePath, 'utf8'); return { contents: [{ uri, mimeType: this.getMimeType(filePath), text: content }] }; } catch (error) { throw new Error(`Failed to read file: ${error.message}`); } }); } private setupToolHandlers() { // List available tools this.server.setRequestHandler('tools/list', async () => { return { tools: [ { name: "write_file", description: "Write content to a file", inputSchema: { type: "object", properties: { path: { type: "string", description: "File path" }, content: { type: "string", description: "File content" } }, required: ["path", "content"] } }, { name: "create_directory", description: "Create a new directory", inputSchema: { type: "object", properties: { path: { type: "string", description: "Directory path" } }, required: ["path"] } }, { name: "list_directory", description: "List directory contents", inputSchema: { type: "object", properties: { path: { type: "string", description: "Directory path" } }, required: ["path"] } } ] }; }); // Execute tools this.server.setRequestHandler('tools/call', async (request) => { const { name, arguments: args } = request.params; switch (name) { case 'write_file': return await this.writeFile(args.path, args.content); case 'create_directory': return await this.createDirectory(args.path); case 'list_directory': return await this.listDirectory(args.path); default: throw new Error(`Unknown tool: ${name}`); } }); } private async writeFile(filePath: string, content: string) { if (!this.isPathAllowed(filePath)) { throw new Error('Access denied to this path'); } await fs.writeFile(filePath, content, 'utf8'); return { content: [{ type: "text", text: `Successfully wrote ${content.length} characters to ${filePath}` }] }; } private async createDirectory(dirPath: string) { if (!this.isPathAllowed(dirPath)) { throw new Error('Access denied to this path'); } await fs.ensureDir(dirPath); return { content: [{ type: "text", text: `Successfully created directory: ${dirPath}` }] }; } private async listDirectory(dirPath: string) { if (!this.isPathAllowed(dirPath)) { throw new Error('Access denied to this path'); } const files = await fs.readdir(dirPath, { withFileTypes: true }); const fileList = files.map(file => `${file.isDirectory() ? '📁' : '📄'} ${file.name}` ).join('\n'); return { content: [{ type: "text", text: `Directory contents of ${dirPath}:\n${fileList}` }] }; } private getMimeType(filename: string): string { const ext = path.extname(filename).toLowerCase(); const mimeTypes = { '.txt': 'text/plain', '.md': 'text/markdown', '.json': 'application/json', '.js': 'text/javascript', '.ts': 'text/typescript', '.py': 'text/x-python' }; return mimeTypes[ext] || 'text/plain'; } public async start() { const transport = new StdioServerTransport(); await this.server.connect(transport); console.error('Filesystem MCP Server started'); } } // Start the server with environment configuration const allowedPaths = process.env.ALLOWED_PATHS?.split(':') || [process.cwd()]; const server = new FileSystemMCPServer(allowedPaths); server.start();

// MCP Client Configuration (claude_desktop_config.json) { "mcpServers": { "filesystem": { "command": "node", "args": [ "path/to/filesystem-server/dist/index.js" ], "env": { "ALLOWED_PATHS": "/home/user/documents:/home/user/projects" } }, "database": { "command": "python", "args": [ "database-server.py" ], "env": { "DB_CONNECTION_STRING": "postgresql://user:pass@localhost/db" } }, "web-search": { "command": "npx", "args": [ "@modelcontextprotocol/server-web-search" ], "env": { "SEARCH_API_KEY": "your-api-key" } } } }

import { Client } from '@modelcontextprotocol/sdk/client/index.js'; import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'; import { spawn } from 'child_process'; class MCPClientManager { private clients: Map<string, Client> = new Map(); async connectToServer(serverName: string, config: any) { // Spawn the MCP server process const serverProcess = spawn( config.command, config.args || [], { env: { ...process.env, ...config.env }, stdio: ['pipe', 'pipe', 'inherit'] } ); // Create client and transport const transport = new StdioClientTransport({ readable: serverProcess.stdout!, writable: serverProcess.stdin! }); const client = new Client( { name: `${serverName}-client`, version: "1.0.0" }, { capabilities: {} } ); await client.connect(transport); this.clients.set(serverName, client); return client; } async listResources(serverName: string) { const client = this.clients.get(serverName); if (!client) { throw new Error(`Client ${serverName} not connected`); } return await client.request('resources/list', {}); } async readResource(serverName: string, uri: string) { const client = this.clients.get(serverName); if (!client) { throw new Error(`Client ${serverName} not connected`); } return await client.request('resources/read', { uri }); } async listTools(serverName: string) { const client = this.clients.get(serverName); if (!client) { throw new Error(`Client ${serverName} not connected`); } return await client.request('tools/list', {}); } async callTool(serverName: string, toolName: string, args: any) { const client = this.clients.get(serverName); if (!client) { throw new Error(`Client ${serverName} not connected`); } return await client.request('tools/call', { name: toolName, arguments: args }); } } // Example usage async demonstrateMCPUsage() { const manager = new MCPClientManager(); // Connect to filesystem server await manager.connectToServer('filesystem', { command: 'node', args: ['filesystem-server.js'], env: { ALLOWED_PATHS: '/tmp:/home/user/documents' } }); // List available resources const resources = await manager.listResources('filesystem'); console.log('Available resources:', resources); // Read a file const fileContent = await manager.readResource( 'filesystem', 'file:///tmp/example.txt' ); console.log('File content:', fileContent); // Use a tool const result = await manager.callTool( 'filesystem', 'write_file', { path: '/tmp/output.txt', content: 'Hello from MCP!' } ); console.log('Tool result:', result); }