MCP项目实战

概述

什么是MCP项目实战

MCP项目实战是通过实际项目案例来学习和应用MCP技术的实践过程。它涵盖了从项目规划到部署上线的完整开发流程，帮助开发者深入理解MCP协议，掌握实际开发技能，并积累项目经验。

实战的重要性

理论结合实践：将理论知识应用到实际项目中
技能提升：通过实战提升MCP开发能力
问题解决：学会解决实际开发中遇到的问题
最佳实践：掌握MCP开发的最佳实践和模式
团队协作：学习在团队中协作开发MCP项目

学习目标

掌握MCP项目的完整开发流程
学会项目架构设计和规划
理解MCP工具的开发模式
掌握测试和部署策略
学会项目维护和优化

项目规划阶段

1. 需求分析

明确项目目标：

解决什么业务问题
目标用户是谁
核心功能是什么
性能要求如何

功能需求梳理：

核心功能列表
功能优先级排序
功能依赖关系
扩展性要求

技术需求分析：

技术栈选择
性能指标要求
安全要求
兼容性要求

2. 技术选型

MCP SDK选择：

TypeScript SDK：适合前端和Node.js开发
Python SDK：适合数据科学和AI应用
Go SDK：适合高性能服务开发

开发工具选择：

代码编辑器：VS Code + MCP扩展
调试工具：MCP Inspector
测试框架：Jest/Pytest
版本控制：Git

部署平台选择：

云函数：AWS Lambda、Azure Functions
容器平台：Docker + Kubernetes
传统服务器：VPS、云服务器

3. 项目架构设计

系统架构设计：

整体架构图
模块划分
接口设计
数据流设计

MCP工具架构：

工具功能模块
资源管理模块
错误处理模块
日志监控模块

集成架构设计：

AI应用集成方式
外部服务集成
数据存储方案
缓存策略

开发实现阶段

1. 环境搭建

开发环境配置：

# 安装Node.js和npm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install 18
nvm use 18

# 安装MCP TypeScript SDK
npm install @modelcontextprotocol/sdk

# 安装开发依赖
npm install --save-dev typescript @types/node jest @types/jest

项目结构创建：

mcp-project/
├── src/
│   ├── tools/
│   │   ├── fileManager.ts
│   │   └── dataAnalyzer.ts
│   ├── resources/
│   │   ├── fileResource.ts
│   │   └── dataResource.ts
│   ├── utils/
│   │   ├── logger.ts
│   │   └── validator.ts
│   └── server.ts
├── tests/
│   ├── unit/
│   └── integration/
├── docs/
├── package.json
├── tsconfig.json
└── README.md

2. 核心功能开发

MCP工具开发：

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { FileManagerTool } from './tools/fileManager.js';

async function main() {
  const server = new Server(
    {
      name: 'file-manager-mcp-server',
      version: '1.0.0',
    },
    {
      capabilities: {
        tools: {},
        resources: {},
      },
    }
  );

  // 注册文件管理工具
  server.setRequestHandler('tools/call', async (request) => {
    const tool = new FileManagerTool();
    return await tool.handleRequest(request);
  });

  // 启动服务器
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main().catch(console.error);

工具实现示例：

export class FileManagerTool {
  async handleRequest(request: any) {
    const { name, arguments: args } = request.params;
    
    switch (name) {
      case 'readFile':
        return await this.readFile(args.path);
      case 'writeFile':
        return await this.writeFile(args.path, args.content);
      case 'listDirectory':
        return await this.listDirectory(args.path);
      default:
        throw new Error(`Unknown tool: ${name}`);
    }
  }

  private async readFile(path: string) {
    try {
      const content = await fs.readFile(path, 'utf-8');
      return {
        content: {
          type: 'text',
          text: content
        }
      };
    } catch (error) {
      throw new Error(`Failed to read file: ${error.message}`);
    }
  }

  private async writeFile(path: string, content: string) {
    try {
      await fs.writeFile(path, content, 'utf-8');
      return { success: true };
    } catch (error) {
      throw new Error(`Failed to write file: ${error.message}`);
    }
  }

  private async listDirectory(path: string) {
    try {
      const files = await fs.readdir(path);
      return {
        files: files.map(file => ({
          name: file,
          path: pathJoin(path, file),
          isDirectory: fs.statSync(pathJoin(path, file)).isDirectory()
        }))
      };
    } catch (error) {
      throw new Error(`Failed to list directory: ${error.message}`);
    }
  }
}

3. 资源管理实现

资源定义：

export class FileResource {
  constructor(private filePath: string) {}

  async getContent(): Promise<string> {
    return await fs.readFile(this.filePath, 'utf-8');
  }

  async getMetadata(): Promise<any> {
    const stats = await fs.stat(this.filePath);
    return {
      name: path.basename(this.filePath),
      size: stats.size,
      modified: stats.mtime,
      type: this.getFileType(this.filePath)
    };
  }

  private getFileType(filePath: string): string {
    const ext = path.extname(filePath).toLowerCase();
    const typeMap: Record<string, string> = {
      '.txt': 'text/plain',
      '.json': 'application/json',
      '.md': 'text/markdown',
      '.js': 'application/javascript',
      '.ts': 'application/typescript'
    };
    return typeMap[ext] || 'application/octet-stream';
  }
}

测试阶段

1. 单元测试

测试框架配置：

{
  "scripts": {
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage"
  },
  "jest": {
    "preset": "ts-jest",
    "testEnvironment": "node",
    "collectCoverageFrom": [
      "src/**/*.ts",
      "!src/**/*.d.ts"
    ]
  }
}

测试用例编写：

import { FileManagerTool } from '../src/tools/fileManager';

describe('FileManagerTool', () => {
  let tool: FileManagerTool;

  beforeEach(() => {
    tool = new FileManagerTool();
  });

  describe('readFile', () => {
    it('should read file content successfully', async () => {
      const mockRequest = {
        params: {
          name: 'readFile',
          arguments: { path: '/test/file.txt' }
        }
      };

      // Mock fs.readFile
      jest.spyOn(fs, 'readFile').mockResolvedValue('test content');

      const result = await tool.handleRequest(mockRequest);

      expect(result.content.type).toBe('text');
      expect(result.content.text).toBe('test content');
    });

    it('should handle file read error', async () => {
      const mockRequest = {
        params: {
          name: 'readFile',
          arguments: { path: '/nonexistent/file.txt' }
        }
      };

      jest.spyOn(fs, 'readFile').mockRejectedValue(new Error('File not found'));

      await expect(tool.handleRequest(mockRequest))
        .rejects.toThrow('Failed to read file: File not found');
    });
  });
});

2. 集成测试

端到端测试：

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

describe('MCP Server Integration', () => {
  let server: Server;
  let transport: StdioServerTransport;

  beforeAll(async () => {
    server = new Server(
      {
        name: 'test-mcp-server',
        version: '1.0.0',
      },
      {
        capabilities: {
          tools: {},
          resources: {},
        },
      }
    );

    transport = new StdioServerTransport();
    await server.connect(transport);
  });

  afterAll(async () => {
    await server.disconnect();
  });

  it('should handle tool call request', async () => {
    const request = {
      jsonrpc: '2.0',
      id: 1,
      method: 'tools/call',
      params: {
        name: 'readFile',
        arguments: { path: '/test/file.txt' }
      }
    };

    const response = await server.handleRequest(request);
    
    expect(response.jsonrpc).toBe('2.0');
    expect(response.id).toBe(1);
    expect(response.result).toBeDefined();
  });
});

3. 性能测试

负载测试：

import { loadTest } from 'k6';

export const options = {
  stages: [
    { duration: '1m', target: 10 }, // 逐步增加到10个用户
    { duration: '3m', target: 10 }, // 保持10个用户3分钟
    { duration: '1m', target: 0 },  // 逐步减少到0个用户
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95%的请求在500ms内完成
    http_req_failed: ['rate<0.1'],    // 错误率小于10%
  },
};

export default function() {
  const response = http.post('http://localhost:3000/mcp', {
    jsonrpc: '2.0',
    id: 1,
    method: 'tools/call',
    params: {
      name: 'readFile',
      arguments: { path: '/test/file.txt' }
    }
  });

  check(response, {
    'status is 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500,
  });
}

部署阶段

1. 容器化部署

Dockerfile配置：

FROM node:18-alpine

WORKDIR /app

# 复制package文件
COPY package*.json ./

# 安装依赖
RUN npm ci --only=production

# 复制源代码
COPY dist/ ./dist/

# 创建非root用户
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nodejs -u 1001
USER nodejs

# 暴露端口
EXPOSE 3000

# 启动命令
CMD ["node", "dist/server.js"]

Docker Compose配置：

version: '3.8'

services:
  mcp-server:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - LOG_LEVEL=info
    volumes:
      - ./logs:/app/logs
      - ./data:/app/data
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - mcp-server
    restart: unless-stopped

2. 云函数部署

AWS Lambda配置：

AWSTemplateFormatVersion: '2010-09-09'
Description: 'MCP Server Lambda Function'

Resources:
  MCPFunction:
    Type: 'AWS::Lambda::Function'
    Properties:
      FunctionName: mcp-server
      Runtime: nodejs18.x
      Handler: index.handler
      Code:
        ZipFile: |
          exports.handler = async (event) => {
            // MCP服务器处理逻辑
            return {
              statusCode: 200,
              body: JSON.stringify({ message: 'MCP Server Running' })
            };
          };
      Role: !GetAtt LambdaExecutionRole.Arn
      Timeout: 30
      MemorySize: 512

  LambdaExecutionRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'

3. 监控和日志

日志配置：

import winston from 'winston';

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: { service: 'mcp-server' },
  transports: [
    new winston.transports.File({ filename: 'logs/error.log', level: 'error' }),
    new winston.transports.File({ filename: 'logs/combined.log' }),
  ],
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

export default logger;

监控配置：

import { register, collectDefaultMetrics } from 'prom-client';

// 收集默认指标
collectDefaultMetrics();

// 自定义指标
const mcpRequestDuration = new register.Histogram({
  name: 'mcp_request_duration_seconds',
  help: 'Duration of MCP requests in seconds',
  labelNames: ['method', 'status'],
  buckets: [0.1, 0.5, 1, 2, 5]
});

const mcpRequestTotal = new register.Counter({
  name: 'mcp_requests_total',
  help: 'Total number of MCP requests',
  labelNames: ['method', 'status']
});

export { mcpRequestDuration, mcpRequestTotal };

维护和优化

1. 性能优化

代码优化：

使用异步操作处理I/O密集型任务
实现连接池管理数据库连接
添加缓存机制减少重复计算
优化数据结构提高查询效率

系统优化：

调整Node.js内存限制
优化垃圾回收配置
使用负载均衡分发请求
实现自动扩缩容

2. 安全加固

认证授权：

实现JWT token验证
添加API密钥认证
实现角色权限控制
添加请求频率限制

数据安全：

加密敏感数据
实现数据脱敏
添加审计日志
定期安全扫描

3. 故障处理

错误监控：

实现错误追踪系统
设置告警机制
建立故障响应流程
定期故障演练

备份恢复：

定期数据备份
测试恢复流程
建立灾难恢复计划
监控备份状态

总结

通过本文的学习，你应该能够：

掌握项目流程：了解MCP项目的完整开发流程
学会架构设计：掌握MCP项目的架构设计方法
实现核心功能：学会开发MCP工具和资源
进行测试验证：掌握单元测试、集成测试和性能测试
部署和维护：学会部署MCP项目并进行维护优化

MCP项目实战是提升开发技能的重要途径，通过实际项目的开发，你将能够深入理解MCP协议，掌握实际开发技能，并为MCP生态系统的发展做出贡献。

概述​

什么是MCP项目实战​

实战的重要性​

学习目标​

项目规划阶段​

1. 需求分析​

2. 技术选型​

3. 项目架构设计​

开发实现阶段​

1. 环境搭建​

2. 核心功能开发​

3. 资源管理实现​

测试阶段​

1. 单元测试​

2. 集成测试​

3. 性能测试​

部署阶段​

1. 容器化部署​

2. 云函数部署​

3. 监控和日志​

维护和优化​

1. 性能优化​

2. 安全加固​

3. 故障处理​

总结​

概述