模型上下文协议 (MCP)

模型上下文协议 (Model Context Protocol, MCP) 是 Trae 平台用于管理 AI 模型上下文信息的标准化协议。本文档详细介绍 MCP 的设计原理、实现方式和使用方法。

概述

MCP 是一个开放标准，旨在解决 AI 模型在处理复杂任务时的上下文管理问题。它提供了一套统一的接口和规范，使得不同的 AI 模型能够高效地共享和管理上下文信息。

核心概念

上下文 (Context)

上下文是指 AI 模型在执行任务时需要的所有相关信息，包括：

• 代码上下文：当前文件、项目结构、依赖关系
• 对话历史：用户与 AI 的交互记录
• 任务状态：当前任务的进度和状态信息
• 环境信息：开发环境、配置、工具链
• 知识库：相关文档、API 参考、最佳实践

上下文提供者 (Context Provider)

上下文提供者是实现 MCP 接口的组件，负责收集、管理和提供特定类型的上下文信息。

interface ContextProvider {
  readonly name: string;
  readonly version: string;
  readonly capabilities: string[];
  
  initialize(config: ProviderConfig): Promise<void>;
  getContext(request: ContextRequest): Promise<ContextResponse>;
  updateContext(update: ContextUpdate): Promise<void>;
  cleanup(): Promise<void>;
}

上下文消费者 (Context Consumer)

上下文消费者是使用上下文信息的组件，通常是 AI 模型或相关的处理器。

interface ContextConsumer {
  readonly modelId: string;
  readonly supportedContextTypes: string[];
  
  processWithContext(context: Context, task: Task): Promise<Result>;
  getContextRequirements(task: Task): ContextRequirement[];
}

协议规范

消息格式

MCP 使用 JSON 格式进行消息传递，所有消息都遵循统一的结构：

{
  "version": "1.0",
  "type": "request|response|notification",
  "id": "unique-message-id",
  "timestamp": "2024-01-01T00:00:00Z",
  "source": "provider-or-consumer-id",
  "target": "target-component-id",
  "payload": {
    // 具体的消息内容
  }
}

请求类型

获取上下文 (GetContext)

{
  "type": "request",
  "method": "getContext",
  "params": {
    "contextTypes": ["code", "conversation", "environment"],
    "scope": {
      "files": ["src/main.js", "src/utils.js"],
      "directories": ["src/components"],
      "timeRange": {
        "start": "2024-01-01T00:00:00Z",
        "end": "2024-01-01T23:59:59Z"
      }
    },
    "maxTokens": 4096,
    "priority": "high"
  }
}

更新上下文 (UpdateContext)

{
  "type": "request",
  "method": "updateContext",
  "params": {
    "contextId": "ctx-12345",
    "updates": [
      {
        "operation": "add|update|remove",
        "path": "/code/files/src/main.js",
        "value": {
          "content": "// 更新的代码内容",
          "lastModified": "2024-01-01T12:00:00Z"
        }
      }
    ]
  }
}

订阅上下文变化 (SubscribeContext)

{
  "type": "request",
  "method": "subscribeContext",
  "params": {
    "contextTypes": ["code"],
    "filters": {
      "filePatterns": ["*.js", "*.ts"],
      "events": ["file-changed", "file-created", "file-deleted"]
    },
    "callback": "ws://localhost:8080/context-updates"
  }
}

响应格式

成功响应

{
  "type": "response",
  "id": "request-id",
  "status": "success",
  "result": {
    "contextId": "ctx-12345",
    "context": {
      "code": {
        "files": {
          "src/main.js": {
            "content": "console.log('Hello, World!');",
            "language": "javascript",
            "lastModified": "2024-01-01T12:00:00Z",
            "size": 1024
          }
        },
        "dependencies": [
          {
            "name": "lodash",
            "version": "4.17.21",
            "type": "npm"
          }
        ]
      },
      "conversation": {
        "messages": [
          {
            "role": "user",
            "content": "请帮我优化这个函数",
            "timestamp": "2024-01-01T11:30:00Z"
          },
          {
            "role": "assistant",
            "content": "我来帮您优化这个函数...",
            "timestamp": "2024-01-01T11:31:00Z"
          }
        ]
      }
    },
    "metadata": {
      "tokenCount": 2048,
      "generatedAt": "2024-01-01T12:00:00Z",
      "ttl": 3600
    }
  }
}

错误响应

{
  "type": "response",
  "id": "request-id",
  "status": "error",
  "error": {
    "code": "CONTEXT_NOT_FOUND",
    "message": "指定的上下文不存在",
    "details": {
      "contextId": "ctx-invalid",
      "availableContexts": ["ctx-12345", "ctx-67890"]
    }
  }
}

实现示例

代码上下文提供者

class CodeContextProvider implements ContextProvider {
  readonly name = 'code-context-provider';
  readonly version = '1.0.0';
  readonly capabilities = ['file-reading', 'dependency-analysis', 'ast-parsing'];
  
  private fileSystem: FileSystem;
  private dependencyAnalyzer: DependencyAnalyzer;
  private astParser: ASTParser;
  
  async initialize(config: ProviderConfig): Promise<void> {
    this.fileSystem = new FileSystem(config.rootPath);
    this.dependencyAnalyzer = new DependencyAnalyzer();
    this.astParser = new ASTParser();
  }
  
  async getContext(request: ContextRequest): Promise<ContextResponse> {
    const context: CodeContext = {
      files: {},
      dependencies: [],
      structure: {}
    };
    
    // 读取文件内容
    for (const filePath of request.scope.files) {
      try {
        const content = await this.fileSystem.readFile(filePath);
        const language = this.detectLanguage(filePath);
        const ast = await this.astParser.parse(content, language);
        
        context.files[filePath] = {
          content,
          language,
          ast,
          lastModified: await this.fileSystem.getLastModified(filePath),
          size: content.length
        };
      } catch (error) {
        console.warn(`无法读取文件 ${filePath}:`, error.message);
      }
    }
    
    // 分析依赖关系
    context.dependencies = await this.dependencyAnalyzer.analyze(
      request.scope.directories
    );
    
    // 构建项目结构
    context.structure = await this.buildProjectStructure(
      request.scope.directories
    );
    
    return {
      contextId: this.generateContextId(),
      context: { code: context },
      metadata: {
        tokenCount: this.calculateTokenCount(context),
        generatedAt: new Date().toISOString(),
        ttl: 3600
      }
    };
  }
  
  async updateContext(update: ContextUpdate): Promise<void> {
    for (const operation of update.updates) {
      switch (operation.operation) {
        case 'add':
        case 'update':
          await this.handleFileUpdate(operation.path, operation.value);
          break;
        case 'remove':
          await this.handleFileRemoval(operation.path);
          break;
      }
    }
  }
  
  private detectLanguage(filePath: string): string {
    const extension = filePath.split('.').pop()?.toLowerCase();
    const languageMap: Record<string, string> = {
      'js': 'javascript',
      'ts': 'typescript',
      'py': 'python',
      'java': 'java',
      'cpp': 'cpp',
      'c': 'c',
      'go': 'go',
      'rs': 'rust',
      'php': 'php',
      'rb': 'ruby'
    };
    return languageMap[extension || ''] || 'text';
  }
  
  private generateContextId(): string {
    return `ctx-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  }
  
  private calculateTokenCount(context: CodeContext): number {
    let tokenCount = 0;
    for (const file of Object.values(context.files)) {
      tokenCount += Math.ceil(file.content.length / 4); // 粗略估算
    }
    return tokenCount;
  }
  
  async cleanup(): Promise<void> {
    // 清理资源
  }
}

对话上下文提供者

class ConversationContextProvider implements ContextProvider {
  readonly name = 'conversation-context-provider';
  readonly version = '1.0.0';
  readonly capabilities = ['message-history', 'intent-analysis', 'context-summarization'];
  
  private messageStore: MessageStore;
  private intentAnalyzer: IntentAnalyzer;
  private summarizer: ContextSummarizer;
  
  async initialize(config: ProviderConfig): Promise<void> {
    this.messageStore = new MessageStore(config.database);
    this.intentAnalyzer = new IntentAnalyzer();
    this.summarizer = new ContextSummarizer();
  }
  
  async getContext(request: ContextRequest): Promise<ContextResponse> {
    const messages = await this.messageStore.getMessages({
      timeRange: request.scope.timeRange,
      limit: request.maxTokens ? Math.floor(request.maxTokens / 100) : 50
    });
    
    const intents = await this.intentAnalyzer.analyzeMessages(messages);
    const summary = await this.summarizer.summarize(messages);
    
    const context: ConversationContext = {
      messages,
      intents,
      summary,
      statistics: {
        totalMessages: messages.length,
        userMessages: messages.filter(m => m.role === 'user').length,
        assistantMessages: messages.filter(m => m.role === 'assistant').length
      }
    };
    
    return {
      contextId: this.generateContextId(),
      context: { conversation: context },
      metadata: {
        tokenCount: this.calculateTokenCount(context),
        generatedAt: new Date().toISOString(),
        ttl: 1800
      }
    };
  }
  
  async updateContext(update: ContextUpdate): Promise<void> {
    for (const operation of update.updates) {
      if (operation.path.startsWith('/conversation/messages')) {
        await this.handleMessageUpdate(operation);
      }
    }
  }
  
  private async handleMessageUpdate(operation: ContextUpdateOperation): Promise<void> {
    switch (operation.operation) {
      case 'add':
        await this.messageStore.addMessage(operation.value);
        break;
      case 'update':
        await this.messageStore.updateMessage(operation.path, operation.value);
        break;
      case 'remove':
        await this.messageStore.removeMessage(operation.path);
        break;
    }
  }
  
  async cleanup(): Promise<void> {
    await this.messageStore.close();
  }
}

MCP 客户端

class MCPClient {
  private providers: Map<string, ContextProvider> = new Map();
  private consumers: Map<string, ContextConsumer> = new Map();
  private contextCache: Map<string, CachedContext> = new Map();
  
  async registerProvider(provider: ContextProvider): Promise<void> {
    await provider.initialize({});
    this.providers.set(provider.name, provider);
  }
  
  async registerConsumer(consumer: ContextConsumer): Promise<void> {
    this.consumers.set(consumer.modelId, consumer);
  }
  
  async getContext(request: ContextRequest): Promise<ContextResponse> {
    // 检查缓存
    const cacheKey = this.generateCacheKey(request);
    const cached = this.contextCache.get(cacheKey);
    
    if (cached && !this.isCacheExpired(cached)) {
      return cached.context;
    }
    
    // 收集上下文
    const contexts: Partial<Context> = {};
    
    for (const contextType of request.contextTypes) {
      const provider = this.findProviderForType(contextType);
      if (provider) {
        const response = await provider.getContext({
          ...request,
          contextTypes: [contextType]
        });
        Object.assign(contexts, response.context);
      }
    }
    
    const response: ContextResponse = {
      contextId: this.generateContextId(),
      context: contexts as Context,
      metadata: {
        tokenCount: this.calculateTotalTokenCount(contexts),
        generatedAt: new Date().toISOString(),
        ttl: 3600
      }
    };
    
    // 缓存结果
    this.contextCache.set(cacheKey, {
      context: response,
      cachedAt: Date.now(),
      ttl: response.metadata.ttl * 1000
    });
    
    return response;
  }
  
  async processWithContext(
    modelId: string,
    task: Task,
    contextRequest?: Partial<ContextRequest>
  ): Promise<Result> {
    const consumer = this.consumers.get(modelId);
    if (!consumer) {
      throw new Error(`未找到模型 ${modelId} 的消费者`);
    }
    
    // 获取上下文需求
    const requirements = consumer.getContextRequirements(task);
    
    // 构建上下文请求
    const request: ContextRequest = {
      contextTypes: requirements.map(r => r.type),
      scope: this.mergeScopes(requirements.map(r => r.scope)),
      maxTokens: Math.max(...requirements.map(r => r.maxTokens || 4096)),
      priority: 'high',
      ...contextRequest
    };
    
    // 获取上下文
    const contextResponse = await this.getContext(request);
    
    // 处理任务
    return consumer.processWithContext(contextResponse.context, task);
  }
  
  private findProviderForType(contextType: string): ContextProvider | undefined {
    for (const provider of this.providers.values()) {
      if (provider.capabilities.includes(contextType)) {
        return provider;
      }
    }
    return undefined;
  }
  
  private generateCacheKey(request: ContextRequest): string {
    return btoa(JSON.stringify(request)).slice(0, 32);
  }
  
  private isCacheExpired(cached: CachedContext): boolean {
    return Date.now() > cached.cachedAt + cached.ttl;
  }
  
  private generateContextId(): string {
    return `ctx-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  }
}

使用示例

基础使用

// 初始化 MCP 客户端
const mcpClient = new MCPClient();

// 注册上下文提供者
const codeProvider = new CodeContextProvider();
const conversationProvider = new ConversationContextProvider();

await mcpClient.registerProvider(codeProvider);
await mcpClient.registerProvider(conversationProvider);

// 注册模型消费者
const deepseekConsumer = new DeepSeekConsumer();
await mcpClient.registerConsumer(deepseekConsumer);

// 处理代码生成任务
const task: Task = {
  type: 'code-generation',
  description: '创建一个用户认证组件',
  requirements: {
    language: 'typescript',
    framework: 'react',
    features: ['login', 'register', 'password-reset']
  }
};

const result = await mcpClient.processWithContext(
  'deepseek-coder',
  task,
  {
    contextTypes: ['code', 'conversation'],
    scope: {
      directories: ['src/components', 'src/auth'],
      files: ['src/types/user.ts', 'src/api/auth.ts']
    }
  }
);

console.log('生成的代码:', result.code);
console.log('使用的上下文:', result.contextUsed);

实时上下文更新

// 监听文件变化
const fileWatcher = new FileWatcher('src/');

fileWatcher.on('change', async (filePath: string, content: string) => {
  // 更新代码上下文
  await codeProvider.updateContext({
    contextId: 'current-session',
    updates: [{
      operation: 'update',
      path: `/code/files/${filePath}`,
      value: {
        content,
        lastModified: new Date().toISOString()
      }
    }]
  });
  
  // 通知相关消费者
  await mcpClient.notifyContextUpdate({
    contextType: 'code',
    affectedFiles: [filePath],
    timestamp: new Date().toISOString()
  });
});

// 监听对话更新
const chatInterface = new ChatInterface();

chatInterface.on('message', async (message: Message) => {
  // 更新对话上下文
  await conversationProvider.updateContext({
    contextId: 'current-conversation',
    updates: [{
      operation: 'add',
      path: '/conversation/messages/-',
      value: message
    }]
  });
});

自定义上下文提供者

class DatabaseContextProvider implements ContextProvider {
  readonly name = 'database-context-provider';
  readonly version = '1.0.0';
  readonly capabilities = ['schema-analysis', 'query-history', 'performance-metrics'];
  
  private database: Database;
  
  async initialize(config: ProviderConfig): Promise<void> {
    this.database = new Database(config.connectionString);
  }
  
  async getContext(request: ContextRequest): Promise<ContextResponse> {
    const context: DatabaseContext = {
      schema: await this.database.getSchema(),
      recentQueries: await this.database.getRecentQueries(100),
      performanceMetrics: await this.database.getPerformanceMetrics(),
      indexes: await this.database.getIndexes(),
      constraints: await this.database.getConstraints()
    };
    
    return {
      contextId: this.generateContextId(),
      context: { database: context },
      metadata: {
        tokenCount: this.calculateTokenCount(context),
        generatedAt: new Date().toISOString(),
        ttl: 1800
      }
    };
  }
  
  async updateContext(update: ContextUpdate): Promise<void> {
    // 处理数据库上下文更新
    for (const operation of update.updates) {
      if (operation.path.startsWith('/database/schema')) {
        await this.handleSchemaUpdate(operation);
      } else if (operation.path.startsWith('/database/queries')) {
        await this.handleQueryUpdate(operation);
      }
    }
  }
  
  async cleanup(): Promise<void> {
    await this.database.close();
  }
}

// 注册自定义提供者
const dbProvider = new DatabaseContextProvider();
await mcpClient.registerProvider(dbProvider);

最佳实践

性能优化

1. 上下文缓存：

class ContextCache {
  private cache = new Map<string, CachedContext>();
  private maxSize = 1000;
  
  set(key: string, context: ContextResponse, ttl: number): void {
    if (this.cache.size >= this.maxSize) {
      const oldestKey = this.cache.keys().next().value;
      this.cache.delete(oldestKey);
    }
    
    this.cache.set(key, {
      context,
      cachedAt: Date.now(),
      ttl: ttl * 1000
    });
  }
  
  get(key: string): ContextResponse | null {
    const cached = this.cache.get(key);
    if (!cached || this.isExpired(cached)) {
      this.cache.delete(key);
      return null;
    }
    return cached.context;
  }
  
  private isExpired(cached: CachedContext): boolean {
    return Date.now() > cached.cachedAt + cached.ttl;
  }
}

2. 增量更新：

class IncrementalContextProvider {
  private lastSnapshot: ContextSnapshot;
  
  async getContextDelta(request: ContextRequest): Promise<ContextDelta> {
    const currentSnapshot = await this.createSnapshot(request);
    const delta = this.calculateDelta(this.lastSnapshot, currentSnapshot);
    this.lastSnapshot = currentSnapshot;
    return delta;
  }
  
  private calculateDelta(
    previous: ContextSnapshot,
    current: ContextSnapshot
  ): ContextDelta {
    return {
      added: this.findAddedItems(previous, current),
      modified: this.findModifiedItems(previous, current),
      removed: this.findRemovedItems(previous, current)
    };
  }
}

3. 并行处理：

async function getContextParallel(
  providers: ContextProvider[],
  request: ContextRequest
): Promise<ContextResponse> {
  const promises = providers.map(provider => 
    provider.getContext(request).catch(error => {
      console.warn(`Provider ${provider.name} failed:`, error);
      return null;
    })
  );
  
  const results = await Promise.all(promises);
  const validResults = results.filter(result => result !== null);
  
  return this.mergeContexts(validResults);
}

错误处理

class RobustMCPClient extends MCPClient {
  async getContext(request: ContextRequest): Promise<ContextResponse> {
    const retryOptions = {
      maxRetries: 3,
      backoffFactor: 2,
      initialDelay: 1000
    };
    
    return this.withRetry(
      () => super.getContext(request),
      retryOptions
    );
  }
  
  private async withRetry<T>(
    operation: () => Promise<T>,
    options: RetryOptions
  ): Promise<T> {
    let lastError: Error;
    
    for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
      try {
        return await operation();
      } catch (error) {
        lastError = error as Error;
        
        if (attempt === options.maxRetries) {
          break;
        }
        
        const delay = options.initialDelay * Math.pow(options.backoffFactor, attempt);
        await new Promise(resolve => setTimeout(resolve, delay));
      }
    }
    
    throw new Error(`操作失败，已重试 ${options.maxRetries} 次: ${lastError.message}`);
  }
}

安全考虑

class SecureMCPClient extends MCPClient {
  private sanitizer: ContextSanitizer;
  
  async getContext(request: ContextRequest): Promise<ContextResponse> {
    // 验证请求
    this.validateRequest(request);
    
    // 获取上下文
    const response = await super.getContext(request);
    
    // 清理敏感信息
    response.context = await this.sanitizer.sanitize(response.context);
    
    return response;
  }
  
  private validateRequest(request: ContextRequest): void {
    // 检查权限
    if (!this.hasPermission(request.contextTypes)) {
      throw new Error('权限不足');
    }
    
    // 检查范围限制
    if (this.exceedsLimits(request.scope)) {
      throw new Error('请求范围超出限制');
    }
    
    // 检查令牌限制
    if (request.maxTokens && request.maxTokens > this.getMaxAllowedTokens()) {
      throw new Error('令牌数量超出限制');
    }
  }
}

总结

模型上下文协议 (MCP) 为 Trae 平台提供了强大而灵活的上下文管理能力。通过标准化的接口和协议，MCP 使得：

1. 统一管理：不同类型的上下文信息可以通过统一的接口进行管理
2. 高效共享：多个 AI 模型可以共享和复用上下文信息
3. 实时更新：支持上下文的实时更新和同步
4. 可扩展性：易于添加新的上下文提供者和消费者
5. 性能优化：通过缓存、增量更新等机制提升性能

正确实施 MCP 可以显著提升 AI 模型的效果和用户体验，是构建智能开发环境的重要基础设施。