用代码执行降低 MCP Agent 的工具调用成本

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

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

servers/
├── google-drive/
│   ├── getDocument.ts
│   ├── getSheet.ts
│   └── searchFiles.ts
├── salesforce/
│   ├── updateRecord.ts
│   ├── query.ts
│   └── createRecord.ts
├── slack/
│   ├── getChannelHistory.ts
│   └── sendMessage.ts
└── jira/
    ├── createIssue.ts
    └── updateIssue.ts

ls ./servers

ls ./servers/google-drive
ls ./servers/salesforce

cat ./servers/google-drive/getDocument.ts
cat ./servers/salesforce/updateRecord.ts

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,
  },
});

SalesMeeting 00Q5f000001abcXYZ updated successfully.

// 伪代码：模型可以用文件系统探索工具
const services = await fs.readdir('./servers');
// ['google-drive', 'salesforce', 'slack', 'jira']

const gdriveTools = await fs.readdir('./servers/google-drive');
// ['getDocument.ts', 'getSheet.ts', 'searchFiles.ts']

const matches = await searchTools('update salesforce record');
// 返回 salesforce.updateRecord 的路径和简要描述

TOOL CALL: gdrive.getSheet(sheetId: 'abc123')

import * as gdrive from './servers/google-drive';

const allRows = await gdrive.getSheet({
  sheetId: 'abc123',
});

const pendingOrders = allRows.filter(
  row => row['Status'] === 'pending',
);

console.log(`发现 ${pendingOrders.length} 个待处理订单`);
console.log(pendingOrders.slice(0, 5));

发现 238 个待处理订单
[
  { "OrderId": "A1001", "Status": "pending", "Amount": 129.5 },
  { "OrderId": "A1042", "Status": "pending", "Amount": 88.0 },
  { "OrderId": "A1088", "Status": "pending", "Amount": 299.0 },
  { "OrderId": "A1097", "Status": "pending", "Amount": 45.5 },
  { "OrderId": "A1130", "Status": "pending", "Amount": 760.0 }
]

模型调用工具 -> 工具返回 -> 模型判断 -> 模型再次调用工具 -> 工具返回 -> 模型再判断

import * as slack from './servers/slack';

let found = false;

while (!found) {
  const messages = await slack.getChannelHistory({
    channel: 'C123456',
    limit: 20,
  });

  found = messages.some(message =>
    message.text.includes('deployment complete'),
  );

  if (!found) {
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}

console.log('部署完成通知已收到');

async function retry<T>(
  fn: () => Promise<T>,
  maxRetries = 3,
): Promise<T> {
  let lastError: unknown;

  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }

  throw lastError;
}

const result = await retry(() =>
  salesforce.updateRecord({
    objectType: 'Lead',
    recordId: '00Q5f000001abcXYZ',
    data: { Status: 'Contacted' },
  }),
);

const row = {
  name: 'Alice Chen',
  email: 'alice@example.com',
  phone: '+1-555-123-4567',
};

console.log(row.email);
console.log(row.phone);

[EMAIL_1]
[PHONE_1]

const leads = await gdrive.getSheet({
  sheetId: 'lead-sheet',
});

for (const lead of leads) {
  await salesforce.createRecord({
    objectType: 'Lead',
    data: {
      Name: lead.name,
      Email: lead.email,
      Phone: lead.phone,
    },
  });
}

import * as fs from 'node:fs/promises';
import * as salesforce from './servers/salesforce';

const leads = await salesforce.query({
  soql: `
    SELECT Id, Name, Email, Company
    FROM Lead
    WHERE Status = 'Open'
  `,
});

const csvData = [
  'Id,Name,Email,Company',
  ...leads.map(lead =>
    [
      lead.Id,
      lead.Name,
      lead.Email,
      lead.Company,
    ].join(','),
  ),
].join('\n');

await fs.writeFile('./workspace/open-leads.csv', csvData);

console.log(`已导出 ${leads.length} 条线索到 ./workspace/open-leads.csv`);

const csvData = await fs.readFile(
  './workspace/open-leads.csv',
  'utf-8',
);

// ./skills/save-sheet-as-csv.ts
import * as fs from 'node:fs/promises';
import * as gdrive from '../servers/google-drive';

export async function saveSheetAsCsv(sheetId: string, outputPath: string) {
  const rows = await gdrive.getSheet({ sheetId });

  if (rows.length === 0) {
    await fs.writeFile(outputPath, '');
    return outputPath;
  }

  const headers = Object.keys(rows[0]);

  const csv = [
    headers.join(','),
    ...rows.map(row =>
      headers.map(header => JSON.stringify(row[header] ?? '')).join(','),
    ),
  ].join('\n');

  await fs.writeFile(outputPath, csv);
  return outputPath;
}

import { saveSheetAsCsv } from './skills/save-sheet-as-csv';

const csvPath = await saveSheetAsCsv(
  'abc123',
  './workspace/orders.csv',
);

console.log(`CSV 已保存到 ${csvPath}`);

// ./servers/google-drive/getDocument.ts

export interface GetDocumentInput {
  /**
   * Google Drive document id.
   */
  documentId: string;

  /**
   * Optional list of fields to return.
   * Example: ['title', 'content']
   */
  fields?: string[];
}

export interface GoogleDocument {
  id: string;
  title: string;
  content: string;
  metadata: Record<string, unknown>;
}

export async function getDocument(
  input: GetDocumentInput,
): Promise<GoogleDocument> {
  return callMcpTool('gdrive.getDocument', input);
}

// ./servers/google-drive/index.ts
export { getDocument } from './getDocument';
export { getSheet } from './getSheet';
export { searchFiles } from './searchFiles';

import { getDocument } from './servers/google-drive';

const document = await getDocument({
  documentId: 'abc123',
});

sandbox:
  timeoutSeconds: 30
  maxMemoryMB: 512
  maxCpuCores: 1
  filesystem:
    writablePaths:
      - ./workspace
    readonlyPaths:
      - ./servers
      - ./skills
  network:
    mode: allowlist
    allowedHosts:
      - mcp-gateway.internal
  tools:
    allowed:
      - google-drive.getDocument
      - google-drive.getSheet
      - salesforce.updateRecord
      - slack.getChannelHistory
  logging:
    redact:
      - email
      - phone
      - api_key
      - access_token

const plan = leads.map(lead => ({
  recordId: lead.Id,
  changes: {
    Status: 'Contacted',
  },
}));

console.log(JSON.stringify(plan, null, 2));

// 等待用户确认后再执行真正更新

servers/
├── google-drive/
│   ├── index.ts
│   └── getDocument.ts
└── salesforce/
    ├── index.ts
    └── updateRecord.ts

const files = await listFiles('./servers');
const source = await readFile('./servers/google-drive/getDocument.ts');

const result = await runInSandbox({
  code,
  timeoutMs: 30_000,
  memoryLimitMb: 512,
  writableDirectory: './workspace',
});

{
  "status": "success",
  "logs": [
    "发现 238 个待处理订单",
    "已更新 238 条 Salesforce 记录"
  ]
}