使用 MCP 执行代码：构建更高效的智能体

模型上下文协议（MCP）是一种用于将 AI 代理连接到外部系统的开放标准。传统上，将代理与工具和数据连接需要为每一对组合进行定制集成，这会造成碎片化和重复工作，使得构建真正互联的系统难以扩展。MCP 提供了一种通用协议——开发者只需在代理中实现一次 MCP，即可解锁整个集成生态系统。

自 2024 年 11 月推出 MCP 以来，其采用速度非常迅速：社区已构建了数千个 MCP 服务器，SDK 已涵盖所有主流编程语言，业界也已将 MCP 采纳为连接代理与工具和数据的事实标准。

如今，开发者通常会构建能够访问数十个 MCP 服务器上数百或数千种工具的代理。然而，随着所连接工具数量的增加，预先加载所有工具定义并将中间结果通过上下文窗口传递，会拖慢代理速度并增加成本。

在这篇博文中，我们将探讨代码执行如何使代理能够更高效地与 MCP 服务器交互，在使用更少 token 的同时处理更多工具。

工具的过度 token 消耗会降低代理效率

随着 MCP 使用规模的扩大，有两种常见模式会增加代理的成本和延迟：

1. 工具定义使上下文窗口过载；
2. 中间工具结果会消耗额外的 token。

1. 工具定义使上下文窗口过载

大多数 MCP 客户端会预先将所有工具定义直接加载到上下文中，并使用直接的工具调用语法将其暴露给模型。这些工具定义可能如下所示：

gdrive.getDocument
     Description: Retrieves a document from Google Drive
     Parameters:
                documentId (required, string): The ID of the document to retrieve
                fields (optional, string): Specific fields to return
     Returns: Document object with title, body content, metadata, permissions, etc.

salesforce.updateRecord
    Description: Updates a record in Salesforce
    Parameters:
               objectType (required, string): Type of Salesforce object (Lead, Contact,      Account, etc.)
               recordId (required, string): The ID of the record to update
               data (required, object): Fields to update with their new values
     Returns: Updated record object with confirmation

工具描述会占用更多上下文窗口空间，增加响应时间和成本。当代理连接了数千种工具时，它们在读取请求之前需要处理数十万个 token。

2. 中间工具结果会消耗额外的 token

大多数 MCP 客户端允许模型直接调用 MCP 工具。例如，你可能会对代理说：“从 Google Drive 下载我的会议记录，并将其附加到 Salesforce 线索中。”

模型会进行如下调用：

TOOL CALL: gdrive.getDocument(documentId: "abc123")
        → returns "Discussed Q4 goals...\n[full transcript text]"
           (loaded into model context)

TOOL CALL: salesforce.updateRecord(
			objectType: "SalesMeeting",
			recordId: "00Q5f000001abcXYZ",
  			data: { "Notes": "Discussed Q4 goals...\n[full transcript text written out]" }
		)
		(model needs to write entire transcript into context again)

每个中间结果都必须经过模型。在此示例中，完整的通话记录会被传递两次。对于一场 2 小时的销售会议，这可能意味着要额外处理 50,000 个 token。更大的文档甚至可能超出上下文窗口限制，导致工作流中断。

对于大型文档或复杂数据结构，模型在工具调用之间复制数据时可能更容易出错。

使用 MCP 的代码执行可提高上下文效率

随着代码执行环境在代理中变得越来越普遍，一种解决方案是将 MCP 服务器呈现为代码 API，而不是直接的工具调用。然后代理可以编写代码来与 MCP 服务器交互。这种方法解决了这两个挑战：代理可以仅加载所需的工具，并在执行环境中处理数据，然后再将结果传回模型。

实现这一目标有多种方式。一种方法是从已连接的 MCP 服务器生成所有可用工具的文件树。以下是使用 TypeScript 的实现：

servers
├── google-drive
│   ├── getDocument.ts
│   ├── ... (other tools)
│   └── index.ts
├── salesforce
│   ├── updateRecord.ts
│   ├── ... (other tools)
│   └── index.ts
└── ... (other servers)

然后每个工具对应一个文件，类似于：

// ./servers/google-drive/getDocument.ts
import { callMCPTool } from "../../../client.js";

interface GetDocumentInput {
  documentId: string;
}

interface GetDocumentResponse {
  content: string;
}

/* Read a document from Google Drive */
export async function getDocument(input: GetDocumentInput): Promise<GetDocumentResponse> {
  return callMCPTool<GetDocumentResponse>('google_drive__get_document', input);
}

我们上面的 Google Drive 到 Salesforce 示例就变成了如下代码：

// Read transcript from Google Docs and add to Salesforce prospect
import * as gdrive from './servers/google-drive';
import * as salesforce from './servers/salesforce';

const transcript = (await gdrive.getDocument({ documentId: 'abc123' })).content;
await salesforce.updateRecord({
  objectType: 'SalesMeeting',
  recordId: '00Q5f000001abcXYZ',
  data: { Notes: transcript }
});

智能体通过探索文件系统来发现工具：列出 ./servers/ 目录以查找可用的服务器（如 google-drive 和 salesforce），然后读取它需要的特定工具文件（如 getDocument.ts 和 updateRecord.ts）以了解每个工具的接口。这使得智能体仅加载当前任务所需的定义。这将令牌使用量从 150,000 个令牌减少到 2,000 个令牌——节省了 98.7% 的时间和成本。

Cloudflare 发布了类似的发现，将使用 MCP 进行代码执行称为“代码模式”。核心见解是相同的：LLM 擅长编写代码，开发者应利用这一优势来构建更高效地与 MCP 服务器交互的智能体。

使用 MCP 进行代码执行的优势

使用 MCP 进行代码执行使智能体能够通过按需加载工具、在数据到达模型之前过滤数据以及在单个步骤中执行复杂逻辑来更高效地使用上下文。使用这种方法还有安全性和状态管理方面的好处。

渐进式披露

模型非常擅长导航文件系统。将工具以文件系统上的代码形式呈现，允许模型按需读取工具定义，而不是一次性全部读取。

或者，可以向服务器添加一个 search_tools 工具来查找相关定义。例如，当使用上面提到的假设 Salesforce 服务器时，智能体会搜索“salesforce”并仅加载当前任务所需的工具。在 search_tools 工具中包含一个详细级别参数，允许智能体选择所需的详细级别（例如仅名称、名称和描述，或包含架构的完整定义），这也有助于智能体节省上下文并高效查找工具。

上下文高效的工具结果

处理大型数据集时，智能体可以在返回结果之前在代码中过滤和转换结果。考虑获取一个 10,000 行的电子表格：

// Without code execution - all rows flow through context
TOOL CALL: gdrive.getSheet(sheetId: 'abc123')
        → returns 10,000 rows in context to filter manually

// With code execution - filter in the execution environment
const allRows = await gdrive.getSheet({ sheetId: 'abc123' });
const pendingOrders = allRows.filter(row => 
  row["Status"] === 'pending'
);
console.log(`Found ${pendingOrders.length} pending orders`);
console.log(pendingOrders.slice(0, 5)); // Only log first 5 for review

智能体看到的是五行而不是 10,000 行。类似的模式适用于聚合、跨多个数据源的连接或提取特定字段——所有这些都不会使上下文窗口膨胀。

更强大且上下文高效的控制流

循环、条件和错误处理可以使用熟悉的代码模式完成，而不是链接单个工具调用。例如，如果你需要在 Slack 中发送部署通知，智能体可以编写：

let found = false;
while (!found) {
  const messages = await slack.getChannelHistory({ channel: 'C123456' });
  found = messages.some(m => m.text.includes('deployment complete'));
  if (!found) await new Promise(r => setTimeout(r, 5000));
}
console.log('Deployment notification received');

这种方法比通过智能体循环在 MCP 工具调用和 sleep 命令之间交替更高效。

此外，能够写出将被执行的条件树还可以节省“首字延迟”：智能体不必等待模型评估 if 语句，而是可以让代码执行环境来完成。

保护隐私的操作

当智能体使用 MCP 进行代码执行时，中间结果默认保留在执行环境中。这样，智能体只会看到你显式记录或返回的内容，这意味着你不希望与模型共享的数据可以在不进入模型上下文的情况下流经你的工作流。

对于更敏感的工作负载，智能体框架可以自动对敏感数据进行标记化。例如，想象你需要将客户联系信息从电子表格导入 Salesforce。智能体会编写：

const sheet = await gdrive.getSheet({ sheetId: 'abc123' });
for (const row of sheet.rows) {
  await salesforce.updateRecord({
    objectType: 'Lead',
    recordId: row.salesforceId,
    data: { 
      Email: row.email,
      Phone: row.phone,
      Name: row.name
    }
  });
}
console.log(`Updated ${sheet.rows.length} leads`);

MCP 客户端会拦截数据，并在数据到达模型之前对 PII 进行标记化：

// What the agent would see, if it logged the sheet.rows:
[
  { salesforceId: '00Q...', email: '[EMAIL_1]', phone: '[PHONE_1]', name: '[NAME_1]' },
  { salesforceId: '00Q...', email: '[EMAIL_2]', phone: '[PHONE_2]', name: '[NAME_2]' },
  ...
]

然后，当数据在另一次 MCP 工具调用中共享时，会通过 MCP 客户端中的查找进行去标记化。真实的电子邮件地址、电话号码和姓名从 Google Sheets 流向 Salesforce，但绝不会经过模型。这可以防止代理意外记录或处理敏感数据。您还可以使用它来定义确定性安全规则，选择数据可以流向和来自何处。

状态持久化与技能

支持文件系统访问的代码执行使代理能够在操作之间保持状态。代理可以将中间结果写入文件，从而能够恢复工作并跟踪进度：

const leads = await salesforce.query({ 
  query: 'SELECT Id, Email FROM Lead LIMIT 1000' 
});
const csvData = leads.map(l => `${l.Id},${l.Email}`).join('\n');
await fs.writeFile('./workspace/leads.csv', csvData);

// Later execution picks up where it left off
const saved = await fs.readFile('./workspace/leads.csv', 'utf-8');

代理还可以将其自身代码持久化为可重用函数。一旦代理为某项任务开发出可运行的代码，它就可以保存该实现以供将来使用：

// In ./skills/save-sheet-as-csv.ts
import * as gdrive from './servers/google-drive';
export async function saveSheetAsCsv(sheetId: string) {
  const data = await gdrive.getSheet({ sheetId });
  const csv = data.map(row => row.join(',')).join('\n');
  await fs.writeFile(`./workspace/sheet-${sheetId}.csv`, csv);
  return `./workspace/sheet-${sheetId}.csv`;
}

// Later, in any agent execution:
import { saveSheetAsCsv } from './skills/save-sheet-as-csv';
const csvPath = await saveSheetAsCsv('abc123');

这与 Skills 的概念密切相关，Skills 是可重用的指令、脚本和资源文件夹，供模型用于提高在专门任务上的性能。向这些已保存的函数添加 SKILL.md 文件即可创建结构化技能，供模型参考和使用。随着时间的推移，这使您的代理能够构建一个高级能力工具箱，不断演进其最有效工作所需的脚手架。

请注意，代码执行会带来其自身的复杂性。运行代理生成的代码需要一个具备适当 沙箱、资源限制和监控的安全执行环境。这些基础设施要求会增加直接工具调用所避免的运营开销和安全考量。代码执行的好处——降低 token 成本、降低延迟以及改进工具组合——应与这些实施成本进行权衡。

总结

MCP 为代理连接众多工具和系统提供了基础协议。然而，一旦连接了过多服务器，工具定义和结果可能会消耗过多 token，从而降低代理效率。

尽管这里的许多问题感觉很新颖——上下文管理、工具组合、状态持久化——但它们在软件工程中都有已知的解决方案。代码执行将这些既定模式应用于代理，让它们使用熟悉的编程构造更高效地与 MCP 服务器交互。如果您实施了这种方法，我们鼓励您与 MCP 社区 分享您的发现。