跳到主要内容

MCP开发与应用

Model Context Protocol (MCP) 是一个开放标准，用于在AI应用和外部数据源及工具之间建立安全、可控的连接。本文将深入介绍MCP的核心概念、开发实践、实际应用以及相关Node.js库的使用。

📦 MCP相关Node.js库​

目前，MCP生态系统中有几个可直接调用的Node.js库，可以帮助开发者快速实现MCP协议：

官方核心库​

  1. @mcp/core

    • 提供MCP协议的核心实现
    • 包含基础服务器和客户端类
    • 支持多种传输协议(WebSocket, HTTP, stdio)

  2. @mcp/resources

    • 提供标准资源提供者实现
    • 包含文件、数据库、API等资源类型的处理

  3. @mcp/tools

    • 提供工具集成框架
    • 包含常用工具的封装和调用机制

社区贡献库​

  1. mcp-express

    • 基于Express的MCP服务器中间件
    • 简化Web应用中的MCP集成

  2. mcp-react

    • 为React应用提供MCP客户端集成
    • 包含React Hooks和组件

  3. mcp-cli

    • 命令行工具，用于测试和管理MCP服务
    • 支持资源浏览、工具调用等功能

  4. @modelcontextprotocol/sdk

    • 提供完整的MCP服务器和客户端实现
    • 支持多种传输协议(stdio, WebSocket等)
    • 包含工具注册和调用机制

🚀 快速开始​

以下是使用MCP相关库的快速示例：

使用@modelcontextprotocol/sdk的示例​

const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const { z } = require('zod'); // 用于参数校验

// 创建MCP服务器
const server = new McpServer({
  name: "weather-server",
  version: "1.0.0"
});

// 注册一个"查询天气"的工具
server.registerTool("get_weather", {
  title: "天气查询工具",
  description: "获取指定城市的实时天气",
  inputSchema: {
    city: z.string().describe("城市名称，如北京、上海")
  }
}, async ({ city }) => {
  // 这里可以替换为真实的天气API调用
  const mockWeather = `【${city}】当前天气：晴朗，25℃`;
  return { content: { type: "text", text: mockWeather } };
});

// 启动服务（通过标准输入输出通信）
const transport = new StdioServerTransport();
server.connect(transport).then(() => {
  console.log("天气MCP服务已启动");
});

使用官方@mcp/core库的示例​

// 安装依赖
// npm install @mcp/core @mcp/resources

// 服务器端示例
const { MCPServer } = require('@mcp/core');
const { FileResourceProvider } = require('@mcp/resources');

// 创建服务器
const server = new MCPServer({
  port: 3000,
  transport: 'websocket'
});

// 注册资源提供者
server.registerResourceProvider('file', new FileResourceProvider({
  basePath: './resources'
}));

// 启动服务器
server.start()
  .then(() => console.log('MCP服务器已启动'))
  .catch(err => console.error('服务器启动失败:', err));

// 客户端示例
const { MCPClient } = require('@mcp/core');

// 创建客户端
const client = new MCPClient({
  url: 'ws://localhost:3000'
});

// 连接服务器
client.connect()
  .then(() => {
    console.log('已连接到服务器');
    // 列出资源
    return client.request('resources/list', { type: 'file' });
  })
  .then(result => {
    console.log('资源列表:', result.resources);
  })
  .catch(err => console.error('错误:', err));

详细的库使用文档请参考官方文档：MCP官方文档

🎯 学习目标​

通过本文学习，你将掌握：

  • MCP协议的核心概念和架构设计
  • MCP服务器和客户端的开发方法
  • 资源、工具和提示的实现技巧
  • MCP在实际项目中的应用场景
  • 安全性和性能优化策略

🔍 MCP核心概念​

MCP协议简介​

Model Context Protocol (MCP) 是一个标准化协议，旨在解决AI应用与外部系统集成的复杂性问题。

核心特性​

  1. 标准化接口

    • 统一的协议规范
    • 降低集成复杂度
    • 提高互操作性
    • 简化开发流程

  2. 安全连接

    • 安全的数据传输
    • 身份验证
    • 权限控制
    • 数据加密

  3. 资源管理

    • 统一的资源访问
    • 支持文件系统、数据库、API服务、云存储等

  4. 工具集成

    • 外部工具调用
    • 函数调用
    • 命令执行
    • 服务调用

  5. 提示管理

    • 提示模板系统
    • 模板复用
    • 参数化
    • 版本控制

MCP vs 传统集成方式​

特性传统方式MCP方式
标准化各自实现统一协议
安全性自定义内置安全
复杂度高低
维护性困难简单
扩展性有限良好

🏗️ MCP架构设计​

整体架构​

MCP采用客户端-服务器架构，主要包含以下组件：

  1. 客户端 (AI应用)

    • 发起连接请求
    • 调用MCP服务
    • 处理响应数据

  2. 服务器 (资源提供者)

    • 暴露资源接口
    • 提供工具功能
    • 管理权限控制

  3. 传输层

    • 基于JSON-RPC 2.0协议
    • 支持多种传输方式(WebSocket, HTTP/HTTPS, stdio)

数据流程​

  1. Client 发起连接请求
  2. Server 验证身份和权限
  3. 建立安全连接
  4. Client 请求资源/工具
  5. Server 处理请求
  6. 返回结果给 Client
  7. Client 处理响应数据

协议规范​

MCP基于JSON-RPC 2.0协议，支持三种消息类型：

  1. 请求消息
{
  "jsonrpc": "2.0",
  "id": "unique-id",
  "method": "method-name",
  "params": {}
}
  1. 响应消息
{
  "jsonrpc": "2.0",
  "id": "unique-id",
  "result": {}
  // 或 error: {}
}
  1. 通知消息
{
  "jsonrpc": "2.0",
  "method": "notification-method",
  "params": {}
}

🖥️ MCP服务器开发​

基础服务器实现​

使用官方库@mcp/core实现MCP服务器（推荐）：

const { MCPServer } = require('@mcp/core');

// 创建服务器实例
const server = new MCPServer({
  name: 'My MCP Server',
  version: '1.0.0',
  port: 3000,
  transport: 'websocket'
});

// 启动服务器
server.start()
  .then(() => {
    console.log(`🚀 MCP服务器已启动在端口 ${server.options.port}`);
  })
  .catch(error => {
    console.error('❌ 服务器启动失败:', error);
  });

// 监听服务器事件
server.on('started', () => {
  console.log('✅ 服务器已成功启动');
});

server.on('error', (error) => {
  console.error('❌ 服务器错误:', error);
});

server.on('client_connected', (client) => {
  console.log(`🔗 新客户端连接: ${client.id}`);
});

📁 资源管理实现​

使用官方库@mcp/resources实现资源管理（推荐）：

const { MCPServer } = require('@mcp/core');
const {
  FileResourceProvider,
  DatabaseResourceProvider,
  APIResourceProvider
} = require('@mcp/resources');

// 创建服务器
const server = new MCPServer({
  port: 3000,
  transport: 'websocket'
});

// 注册文件资源提供者
server.registerResourceProvider('file', new FileResourceProvider({
  basePath: './documents',
  allowedExtensions: ['.txt', '.md', '.json'],
  maxFileSize: 5 * 1024 * 1024 // 5MB
}));

// 注册数据库资源提供者
server.registerResourceProvider('database', new DatabaseResourceProvider({
  connectionString: 'postgresql://user:password@localhost:5432/mydb',
  allowedTables: ['products', 'customers'],
  rowLimit: 1000
}));

// 注册API资源提供者
server.registerResourceProvider('api', new APIResourceProvider({
  baseUrl: 'https://api.example.com',
  headers: {
    'Authorization': 'Bearer {API_TOKEN}',
    'Content-Type': 'application/json'
  },
  allowedEndpoints: ['users', 'posts']
}));

// 自定义资源提供者示例
const { BaseResourceProvider } = require('@mcp/resources');

class CustomResourceProvider extends BaseResourceProvider {
  constructor(options = {}) {
    super(options);
  }

  async listResources(params = {}) {
    return [
      { uri: 'custom://resource1', name: 'Custom Resource 1' },
      { uri: 'custom://resource2', name: 'Custom Resource 2' }
    ];
  }

  async readResource(uri, params = {}) {
    return {
      text: JSON.stringify({ data: 'Custom resource content' }),
      mimeType: 'application/json'
    };
  }
}

// 注册自定义资源提供者
server.registerResourceProvider('custom', new CustomResourceProvider());

// 启动服务器
server.start()
  .then(() => console.log('MCP服务器已启动，支持多种资源类型'))
  .catch(err => console.error('服务器启动失败:', err));

💻 MCP客户端开发​

基础客户端实现​

使用官方库@mcp/core实现MCP客户端（推荐）：

const { AdvancedMCPClient } = require('@mcp/core');

// 创建客户端实例
const client = new AdvancedMCPClient({
  url: 'ws://localhost:3000',
  reconnect: true,
  reconnectInterval: 3000
});

// 连接服务器
client.connect()
  .then(() => {
    console.log('✅ 已连接到MCP服务器');
    return client.initialize({
      protocolVersion: '2024-11-05',
      capabilities: {
        resources: { subscribe: true },
        tools: {},
        prompts: {}
      },
      clientInfo: {
        name: 'My MCP Client',
        version: '1.0.0'
      }
    });
  })
  .then(initializationResult => {
    console.log('🔍 服务器能力:', initializationResult.capabilities);
    // 列出所有资源
    return client.listResources();
  })
  .then(resourcesResult => {
    console.log('📋 可用资源数量:', resourcesResult.resources.length);
    // 读取特定资源
    const fileResource = resourcesResult.resources.find(r => r.type === 'file');
    if (fileResource) {
      return client.readResource(fileResource.uri);
    }
  })
  .then(resourceContent => {
    if (resourceContent) {
      console.log('📄 资源内容:', resourceContent.contents[0].text.substring(0, 100) + '...');
    }
  })
  .catch(error => {
    console.error('❌ 客户端错误:', error);
  });

// 监听客户端事件
client.on('authenticated', () => {
  console.log('🔑 客户端已认证');
});

client.on('disconnected', () => {
  console.log('🔌 与服务器断开连接');
});

client.on('notification:notifications/resources/updated', (params) => {
  console.log('🔔 资源更新通知:', params.uri);
});

🔧 工具集成开发​

MCP支持工具的注册和调用，以下是使用@mcp/tools库的示例：

const { MCPServer } = require('@mcp/core');
const { ToolManager } = require('@mcp/tools');

// 创建服务器
const server = new MCPServer({
  port: 3000,
  transport: 'websocket'
});

// 创建工具管理器
const toolManager = new ToolManager();

// 注册工具
toolManager.registerTool('calculate', {
  name: '计算器',
  description: '进行数学计算',
  parameters: {
    type: 'object',
    properties: {
      expression: {
        type: 'string',
        description: '数学表达式，如 "2+2*3"' 
      }
    },
    required: ['expression']
  },
  handler: async (params) => {
    try {
      // 注意：这里使用eval有安全风险，实际应用中应使用更安全的计算方式
      const result = eval(params.expression);
      return { result };
    } catch (error) {
      return { error: error.message };
    }
  }
});

// 注册天气查询工具
toolManager.registerTool('get_weather', {
  name: '天气查询',
  description: '获取指定城市的天气信息',
  parameters: {
    type: 'object',
    properties: {
      city: {
        type: 'string',
        description: '城市名称'
      }
    },
    required: ['city']
  },
  handler: async (params) => {
    // 模拟天气API调用
    const weatherInfo = {
      city: params.city,
      temperature: Math.floor(Math.random() * 30) + 10,
      condition: ['晴朗', '多云', '小雨', '大雨'][Math.floor(Math.random() * 4)],
      humidity: Math.floor(Math.random() * 60) + 30
    };
    return weatherInfo;
  }
});

// 将工具管理器绑定到服务器
server.setToolManager(toolManager);

// 启动服务器
server.start()
  .then(() => console.log('MCP工具服务器已启动'))
  .catch(err => console.error('服务器启动失败:', err));

客户端调用工具的示例：

// 假设已连接到服务器
client.callTool('calculate', { expression: '2+2*3' })
  .then(result => {
    console.log('计算结果:', result);
  })
  .catch(error => {
    console.error('调用工具失败:', error);
  });

client.callTool('get_weather', { city: '北京' })
  .then(result => {
    console.log('天气信息:', result);
  })
  .catch(error => {
    console.error('调用工具失败:', error);
  });

🔐 安全性与权限控制​

MCP提供内置的安全机制，以下是实现认证和权限控制的示例：

const { MCPServer } = require('@mcp/core');
const { JWTAuthenticationProvider } = require('@mcp/core/auth');

// 创建服务器
const server = new MCPServer({
  port: 3000,
  transport: 'websocket',
  authentication: {
    provider: new JWTAuthenticationProvider({
      secret: 'your-secret-key',
      expiresIn: '24h'
    })
  },
  authorization: {
    policies: [
      // 资源访问策略
      {
        resource: 'file://documents/*',
        action: 'read',
        role: 'user'
      },
      {
        resource: 'file://documents/admin/*',
        action: 'read',
        role: 'admin'
      },
      // 工具调用策略
      {
        tool: 'calculate',
        role: 'user'
      },
      {
        tool: 'admin_tool',
        role: 'admin'
      }
    ]
  }
});

// 启动服务器
server.start()
  .then(() => console.log('安全的MCP服务器已启动'))
  .catch(err => console.error('服务器启动失败:', err));

⚡ 性能优化策略​

资源缓存​

// 客户端启用资源缓存
const client = new AdvancedMCPClient({
  url: 'ws://localhost:3000',
  cache: {
    enabled: true,
    ttl: 300000, // 5分钟
    maxSize: 100 // 最大缓存100个资源
  }
});

// 手动清除缓存
client.clearCache();
// 或清除特定资源缓存
client.clearCache('file://document.txt');

连接池管理​

// 服务器端配置连接池
const server = new MCPServer({
  port: 3000,
  transport: 'websocket',
  connectionPool: {
    maxConnections: 100,
    keepAlive: true,
    keepAliveTimeout: 60000
  }
});

🚀 实战应用案例​

案例1：企业知识库MCP服务​

// 整合多种资源的企业知识库MCP服务
const { MCPServer } = require('@mcp/core');
const {
  FileResourceProvider,
  DatabaseResourceProvider,
  APIResourceProvider
} = require('@mcp/resources');

const server = new MCPServer({
  port: 3000,
  transport: 'websocket',
  name: 'Enterprise Knowledge Base'
});

// 注册文件系统资源（文档）
server.registerResourceProvider('docs', new FileResourceProvider({
  basePath: './knowledge-base/docs',
  allowedExtensions: ['.md', '.pdf', '.docx']
}));

// 注册数据库资源（结构化知识）
server.registerResourceProvider('data', new DatabaseResourceProvider({
  connectionString: 'mongodb://localhost:27017/knowledge',
  allowedCollections: ['faq', 'articles', 'manuals']
}));

// 注册API资源（外部知识源）
server.registerResourceProvider('external', new APIResourceProvider({
  baseUrl: 'https://api.enterprise.com/knowledge',
  headers: {
    'Authorization': 'Bearer {API_KEY}'
  },
  allowedEndpoints: ['latest', 'search', 'categories']
}));

// 启动服务器
server.start()
  .then(() => console.log('企业知识库MCP服务已启动'))
  .catch(err => console.error('启动失败:', err));

案例2：AI助手工具集成平台​

// AI助手工具集成平台
const { MCPServer } = require('@mcp/core');
const { ToolManager } = require('@mcp/tools');

const server = new MCPServer({
  port: 3000,
  transport: 'websocket',
  name: 'AI Assistant Tool Platform'
});

const toolManager = new ToolManager();

// 注册常用工具
toolManager.registerTool('web_search', {
  name: '网页搜索',
  description: '搜索互联网获取信息',
  parameters: {
    query: { type: 'string', description: '搜索关键词' }
  },
  handler: async (params) => {
    // 集成搜索引擎API
    // return searchResults;
  }
});

toolManager.registerTool('code_generator', {
  name: '代码生成',
  description: '根据需求生成代码',
  parameters: {
    language: { type: 'string', description: '编程语言' },
    requirement: { type: 'string', description: '功能需求' }
  },
  handler: async (params) => {
    // 集成代码生成模型
    // return generatedCode;
  }
});

// 更多工具注册...

server.setToolManager(toolManager);

// 启动服务器
server.start()
  .then(() => console.log('AI助手工具平台已启动'))
  .catch(err => console.error('启动失败:', err));

📚 延伸阅读​

技术文档​

  1. "MCP Specification" - MCP协议官方规范
  2. "JSON-RPC 2.0 Specification" - JSON-RPC协议规范
  3. "WebSocket Protocol" - WebSocket协议文档
  4. "Security Best Practices" - 安全最佳实践

开源项目​

  1. MCP SDK - MCP官方开发工具包
  2. Claude Desktop - 支持MCP的AI客户端
  3. MCP Servers - 官方MCP服务器示例
  4. MCP Tools - MCP开发工具集

💡 学习提示：MCP是一个相对新的协议，重点在于理解其设计理念和实现原理。建议从简单的文件资源提供者开始，逐步扩展到更复杂的功能。注意安全性和性能优化，特别是在处理大量资源和高并发场景时。实践中要关注错误处理和用户体验，确保MCP服务的稳定性和可用性。