ลดการใช้โทเค็นของ MCP: เราลดคำจำกัดความของเครื่องมือลง 60% ได้อย่างไร

วันที่ 27 ตุลาคม ผู้ใช้แบบชำระเงินรายหนึ่งยกเลิกการสมัครสมาชิก AgentsRoom โดยให้เหตุผลว่าเป็นเรื่องโทเค็น ก่อนจะโต้แย้งอะไร เราวัดก่อนว่าแอปของเราเพิ่มอะไรเข้าไปในเอเจนต์ทุกตัวที่มันเปิดขึ้นมา

ตัวเลขที่ใหญ่ที่สุดไม่ได้อยู่ในจุดที่เราคาดไว้ คำแนะนำตอนเริ่มต้นของเรามีขนาดเล็ก แต่เครื่องมือ MCP ที่เรามอบให้เอเจนต์ทุกตัว (แบ็กล็อก หน่วยความจำของโปรเจกต์ ระบบข้อความระหว่างเอเจนต์ เทอร์มินัล SSH ฐานข้อมูล และอื่น ๆ) มีทั้งหมด 191 ตัว และ JSON ราว 380 KB ที่ประมาณ 4 ไบต์ต่อโทเค็น นั่นคือ คำจำกัดความของเครื่องมือราว 95,000 โทเค็น หนึ่งสัปดาห์ก่อนหน้านั้นตัวเลขอยู่ที่ 78,000 ไม่มีใครตัดสินใจให้เป็นแบบนั้น เครื่องมือใหม่แต่ละตัวแค่เพิ่มย่อหน้าของตัวเองเข้าไป

เราพัฒนา AgentsRoom แอปเดสก์ท็อปที่รัน Claude Code, Codex และ CLI เขียนโค้ดตัวอื่นไปพร้อมกัน และมอบเครื่องมือเหล่านี้ให้พวกมัน นี่คือสิ่งที่เราวัด สิ่งที่เราตัดออกโดยไม่ลบเครื่องมือแม้แต่ตัวเดียว และการตรวจสอบที่ไม่ปล่อยให้ปัญหากลับมา คุณนำทั้งหมดนี้ไปใช้กับเซิร์ฟเวอร์ MCP ของคุณเองได้

คำตอบสั้น ๆ

• คำจำกัดความของเครื่องมือคือ JSON ที่โมเดลอาจอ่านในทุกคำขอ: ชื่อ คำอธิบาย สคีมาอินพุต นับคร่าว ๆ ว่า 4 ไบต์ต่อโทเค็น
• คุณจะจ่ายต้นทุนนี้ทุกรอบหรือไม่ ขึ้นอยู่กับ CLI Claude Code เลื่อนการโหลดเครื่องมือ MCP โดยค่าเริ่มต้น และโหลดคำจำกัดความเมื่อจำเป็น CLI บางตัวส่งสคีมาทั้งหมดไปกับทุกคำขอ
• วัดก่อนตัด ใช้ /context ใน Claude Code หรือสคริปต์ 40 บรรทัดที่ขอรายการเครื่องมือจากเซิร์ฟเวอร์ใดก็ได้
• ย่อข้อความ แต่เก็บเครื่องมือไว้ คำอธิบายบอกว่าทำอะไรและเมื่อไร ส่วนคู่มือย้ายไปอยู่ในเอกสารที่เอเจนต์อ่านเมื่อต้องการ ของเราลดจากราว 95,000 เหลือราว 38,000 โทเค็น น้อยลง 2.5 เท่า
• ใส่เพดานไว้ในบิลด์ ถ้าไม่มี คำจำกัดความจะกลับมาบวมขึ้นเอง

คำจำกัดความของเครื่องมือมีต้นทุนเท่าไร และใครเป็นคนจ่าย

เมื่อไคลเอนต์ MCP เชื่อมต่อกับเซิร์ฟเวอร์ มันจะขอรายการเครื่องมือ แต่ละรายการประกอบด้วยชื่อ คำอธิบายที่เขียนไว้ให้โมเดลอ่าน และสคีมา JSON ของพารามิเตอร์ ไคลเอนต์จะแปลงรายการนี้เป็นคำจำกัดความของเครื่องมือที่ส่งไปยังโมเดล ซึ่งเป็นวิธีที่โมเดลรู้ว่าเครื่องมือนั้นมีอยู่และต้องเรียกใช้อย่างไร

ดังนั้นทุกคำในคำอธิบายคืออินพุตที่โมเดลอ่าน ส่วนจะอ่านบ่อยแค่ไหนขึ้นอยู่กับไคลเอนต์:

• Claude Code เลื่อนการโหลดเครื่องมือ MCP โดยค่าเริ่มต้น เอกสารของมัน ซึ่งเราอ่านเมื่อวันที่ 3 พฤศจิกายน 2026 โดยติดตั้ง Claude Code 2.1.314 อยู่ ระบุว่าตอนเริ่มเซสชันจะโหลดเพียงชื่อเครื่องมือและคำแนะนำของเซิร์ฟเวอร์ และคำจำกัดความจะถูกโหลดผ่านการค้นหาเครื่องมือเมื่อ Claude ต้องใช้เครื่องมือนั้น เมื่อตั้ง ENABLE_TOOL_SEARCH=false เมื่อใช้ auto แล้วต่ำกว่าเกณฑ์ 10% ของหน้าต่างบริบท บนโมเดลที่เก่ากว่า Claude Opus 4 และ Sonnet 4 หรือสำหรับเซิร์ฟเวอร์ที่ทำเครื่องหมาย alwaysLoad คำจำกัดความจะถูกโหลดตั้งแต่แรก
• CLI ตัวอื่นทำต่างออกไป ในการทดสอบของเราเองเมื่อวันที่ 28 ตุลาคม โดยให้เอเจนต์ตอบว่า "OK": Claude Code เริ่มต้นที่ 67,500 โทเค็นโดยเครื่องมือของเราถูกเลื่อนการโหลด Codex CLI 0.164 เริ่มต้นที่ 25,000 โทเค็นและไม่ได้ส่งสคีมาของเราไปเป็นก้อนเดียว ส่วน OpenCode โหลดเครื่องมือของเรา 175 ตัวบวกเครื่องมือเบราว์เซอร์อีก 19 ตัวตอนเชื่อมต่อ และส่งไปกับทุกคำขอ เซิร์ฟเวอร์เดียวกัน แต่บิลต่างกันมาก

แคชพรอมต์ช่วยบรรเทาต้นทุนเมื่อรายการเครื่องมือไม่เปลี่ยน: หลังคำขอแรก ส่วนต้นที่คงที่จะถูกอ่านจากแคชในราคาเพียงเศษเสี้ยวของราคาอินพุต แต่มันไม่ได้คืนพื้นที่ให้ คำจำกัดความยังคงอยู่ในหน้าต่างบริบทในทุกคำขอ ข้างโค้ดและบทสนทนาของคุณ และโหมดเลื่อนการโหลดก็มีต้นทุนของตัวเอง: ขั้นตอนค้นหาก่อนใช้เครื่องมือแต่ละตัวเป็นครั้งแรก

วัดของคุณภายในสองนาที

ใน Claude Code ให้รัน /context คำสั่งนี้แยกหน้าต่างบริบทตามแหล่งที่มา และระบุเครื่องมือ MCP ที่ถูกเลื่อนการโหลดหรือโหลดเมื่อต้องการ รันในเซสชันใหม่ในโปรเจกต์ของคุณก่อนจะพิมพ์อะไร แล้วคุณจะเห็นว่าการตั้งค่าของคุณมีต้นทุนเท่าไรก่อนเริ่มงาน

สำหรับเซิร์ฟเวอร์ใดและ CLI ใดก็ได้ ให้ถามเซิร์ฟเวอร์โดยตรง เซิร์ฟเวอร์ MCP ที่ทำงานผ่าน stdio สื่อสารด้วย JSON-RPC บรรทัดละหนึ่งข้อความ: คุณส่ง initialize ตามด้วย tools/list แล้ววัดสิ่งที่ได้กลับมา สคริปต์นี้ทำแบบนั้นพอดี ด้วย Node และไม่มี dependency ใด ๆ:

// Usage: node mcp-tool-cost.mjs <command that starts the server> [args...]
import { spawn } from 'node:child_process';

const [cmd, ...args] = process.argv.slice(2);
const server = spawn(cmd, args, { stdio: ['pipe', 'pipe', 'ignore'], shell: process.platform === 'win32' });
const tools = [];
let buffer = '';

const send = (msg) => server.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...msg }) + '\n');
const listTools = (cursor) => send({ id: 2, method: 'tools/list', params: cursor ? { cursor } : {} });

server.stdout.on('data', (chunk) => {
  buffer += chunk;
  let end;
  while ((end = buffer.indexOf('\n')) >= 0) {
    const line = buffer.slice(0, end).trim();
    buffer = buffer.slice(end + 1);
    if (line) handle(JSON.parse(line));
  }
});

function handle(msg) {
  if (msg.id === 1) {
    send({ method: 'notifications/initialized' });
    listTools();
  } else if (msg.id === 2) {
    tools.push(...msg.result.tools);
    if (msg.result.nextCursor) listTools(msg.result.nextCursor);
    else { report(); server.kill(); }
  }
}

function report() {
  const rows = tools
    .map((tool) => ({ name: tool.name, bytes: Buffer.byteLength(JSON.stringify(tool)) }))
    .sort((a, b) => b.bytes - a.bytes);
  const total = rows.reduce((sum, row) => sum + row.bytes, 0);
  for (const row of rows.slice(0, 10)) {
    console.log(`${String(row.bytes).padStart(7)} bytes  ~${Math.round(row.bytes / 4)} tokens  ${row.name}`);
  }
  console.log(`${rows.length} tools, ${total} bytes, about ${Math.round(total / 4)} tokens`);
}

send({
  id: 1,
  method: 'initialize',
  params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'tool-cost', version: '1.0.0' } },
});

รันด้วยคำสั่งเดียวกับที่ CLI ของคุณใช้เปิดเซิร์ฟเวอร์ เช่น node mcp-tool-cost.mjs npx -y @playwright/mcp@latest สคริปต์จะแสดงเครื่องมือที่หนักที่สุดสิบตัวและยอดรวม นี่คือสิ่งที่เราได้เมื่อวันที่ 3 พฤศจิกายน 2026:

สี่ไบต์ต่อโทเค็นเป็นค่าประมาณ ดีพอสำหรับเปรียบเทียบเซิร์ฟเวอร์และดูแนวโน้ม แต่ไม่พอสำหรับคาดการณ์บิล tokenizer จริงแตกต่างกันไปตามโมเดลและข้อความ อย่างที่เราพบตอน นับโทเค็นของเราเอง 3.8 พันล้านโทเค็น

เซิร์ฟเวอร์ไฟล์ด้านบนมีขนาดสมเหตุสมผล ปัญหาอยู่ที่ผลรวม: เซิร์ฟเวอร์ขนาดนั้นห้าตัวก็เป็น 20,000 โทเค็นแล้ว ก่อนจะมีเซิร์ฟเวอร์อย่างของเราเข้ามาด้วยซ้ำ

สิ่งที่เราตัด และสิ่งที่เราไม่แตะ

กฎที่เราตั้งไว้: ไม่ลบเครื่องมือ ไม่ลบพารามิเตอร์ ไม่ลบค่าที่อนุญาตหรือฟิลด์บังคับใด ๆ เอเจนต์ต้องคงความสามารถไว้ครบทุกอย่าง มีแค่ข้อความเท่านั้นที่เปลี่ยนได้

1. คำอธิบายเครื่องมือบอกว่าทำอะไรและเมื่อไร ในหนึ่งถึงสามประโยค ไม่ใช่ทำอย่างไร ส่วน "อย่างไร" คือที่ที่ไบต์ทั้งหมดอยู่: กฎ ค่าเริ่มต้น กรณีพิเศษ ตัวอย่าง และคำเตือนที่เขียนเพิ่มหลังจากเอเจนต์เคยใช้เครื่องมือผิดสักครั้ง
2. พารามิเตอร์ได้หนึ่งประโยค หรือไม่ต้องมีเลย เมื่อชื่อ ชนิด และรายการค่าที่อนุญาตบอกไว้ครบแล้ว พารามิเตอร์ที่ซ้ำกันหลายเครื่องมือ (project, author, รหัสทิกเก็ต) ได้ประโยคมาตรฐานเดียวกันทุกที่
3. คู่มือถูกย้าย ไม่ได้ถูกลบ เครื่องมือแต่ละตระกูลมีไฟล์คำแนะนำที่เอเจนต์อ่านก่อนเรียกใช้ตระกูลนั้นครั้งแรก สำหรับเครื่องมือที่ใหญ่ที่สุดของเรา ตัวที่บันทึกทีมเอเจนต์ ตอนนี้ข้อมูลอ้างอิงฟิลด์ฉบับเต็มจะถูกส่งกลับผ่านการเรียกเครื่องมือเมื่อเอเจนต์ขอ แทนที่จะติดไปกับสคีมาตลอด
4. รอบที่สองตรวจทุกข้อเท็จจริง ทุกประโยคที่ถูกตัดออกจากคำอธิบายถูกค้นหาในไฟล์คำแนะนำ และถูกใส่กลับไว้ที่นั่นถ้ายังไม่มี

ผลลัพธ์บางส่วน เป็นไบต์ของ JSON ต่อเครื่องมือ:

รวมแล้ว 380 KB กลายเป็น 152 KB เครื่องมือสิบสามตัวเคยเกิน 4 KB ตอนนี้ยังเกินอยู่สี่ตัว เพราะจำนวนฟิลด์ที่มันต้องมี แนวคิดเบื้องหลังการตัดทั้งหมด: ในการเลือกเครื่องมือ โมเดลต้องรู้แค่ว่าเครื่องมือนั้นมีอยู่และควรเรียกเมื่อไร รายละเอียดรอไว้จนถึงตอนที่มันใช้งานจริงได้

ถ้าคุณเขียนเซิร์ฟเวอร์ MCP Claude Code ให้เหตุผลเพิ่มอีกข้อ มันตัดคำอธิบายเครื่องมือที่โหลดตั้งแต่แรกไว้ที่ 4,096 อักขระ และเมื่อจับคู่การค้นหากับคำอธิบาย มันอ่านเฉพาะส่วนที่อยู่ในขีดจำกัดนั้น อะไรที่สำคัญแต่อยู่หลังจุดนั้นอาจไม่มีวันถูกอ่าน

เทคนิคเดียวกันสำหรับไฟล์ตอนเริ่มต้น

สคีมาของเครื่องมือไม่ใช่ต้นทุนคงที่เพียงอย่างเดียว เอเจนต์ของเรายังอ่านไฟล์คำแนะนำเกี่ยวกับเครื่องมือก่อนใช้งาน และไฟล์นั้นโตจนถึง 57.7 KB ราว 14,000 โทเค็น ซึ่งถูกอ่านทั้งไฟล์ทุกครั้งที่เริ่มและทุกครั้งที่กลับมาทำต่อ ผู้ใช้รายหนึ่งรายงานว่าเอเจนต์ Codex ที่กลับมาทำต่อชนขีดจำกัดบริบทการทำงานภายในไม่กี่นาที

การแก้ใช้แนวคิดเดียวกัน ไฟล์นั้นกลายเป็น ดัชนีขนาดราว 11 KB: กฎที่ใช้กับเครื่องมือทุกตัว และหนึ่งบรรทัดต่อเครื่องมือหนึ่งตระกูลที่ชี้ไปยังไฟล์ของตระกูลนั้น ไฟล์ตระกูลทั้ง 31 ไฟล์จะถูกอ่านก็ต่อเมื่อจะเรียกใช้ตระกูลนั้นเป็นครั้งแรก เนื้อหาไม่เปลี่ยนแม้แต่คำเดียว เอเจนต์ที่ทำงานกับแบ็กล็อกอย่างเดียวจะไม่มีวันอ่านส่วนที่ว่าด้วยฐานข้อมูล

วิธีนี้ใช้ได้กับ CLAUDE.md หรือ AGENTS.md ที่ยาว ๆ ด้วย: เก็บไว้ในไฟล์ที่โหลดเสมอเฉพาะสิ่งที่ทุกงานต้องใช้ แล้วลิงก์ไปยังส่วนที่เหลือ เราเขียนเรื่องนี้ไว้มากกว่านี้ในคู่มือเรื่อง AGENTS.md และไฟล์บริบท

งบประมาณที่ทำให้การพุชล้มเหลว

ตัวเลขที่เรากังวลที่สุดไม่ใช่ 95,000 แต่เป็น 78,000 เมื่อหนึ่งสัปดาห์ก่อนหน้า เครื่องมือแต่ละตัวเพิ่มหนึ่งย่อหน้า แต่ละย่อหน้าก็สมเหตุสมผล แต่ผลรวมโตขึ้น 20% ในเจ็ดวัน

ขนาดจึงกลายเป็นการตรวจสอบในบิลด์ ไฟล์ JSON หนึ่งไฟล์เก็บงบประมาณไว้:

{
  "totalBytes": 160000,
  "perToolBytes": 4000,
  "oversized": {
    "teams_save": 9791,
    "triggers_save": 4071,
    "backlog_update": 4253,
    "backlog_create": 4399
  }
}

สคริปต์จะเปิดเซิร์ฟเวอร์ MCP ของเราในแซนด์บ็อกซ์ ขอรายการเครื่องมือจากแต่ละตัว วัด JSON.stringify(tool) เป็นไบต์ และจบการทำงานด้วยข้อผิดพลาดเมื่อยอดรวมเกิน totalBytes หรือเมื่อเครื่องมือตัวใดเกิน perToolBytes เครื่องมือสี่ตัวที่ใหญ่เกินอยู่แล้วถูกระบุพร้อมขนาด: เป็นกลไกแบบเฟืองล็อก มันเล็กลงได้แต่ห้ามใหญ่ขึ้น และเมื่อตัวใดเล็กลง สคริปต์จะขอให้ลดตัวเลขลง สคริปต์นี้รันก่อนการพุชทุกครั้งและในบิลด์สำหรับรีลีส การยกเพดานขึ้นยังทำได้ แต่เป็นการตัดสินใจที่ต้องเขียนไว้ในไฟล์ ไม่ใช่ทางลัดให้ผ่านการตรวจ

วันที่ 3 พฤศจิกายน หกวันต่อมา การตรวจเดียวกันอ่านได้ 203 เครื่องมือและ 159,957 ไบต์: เพิ่มเครื่องมือสิบสองตัว และต่ำกว่าเพดาน 43 ไบต์ เครื่องมือตัวถัดไปจะต้องหาที่ว่างให้ตัวเอง นั่นคือหน้าที่ของการตรวจนี้พอดี

ปิดสิ่งที่คุณไม่ได้ใช้

โทเค็นที่ถูกที่สุดคือเครื่องมือที่เอเจนต์ของคุณไม่เคยเห็น

• จำกัดเซิร์ฟเวอร์ไว้เฉพาะโปรเจกต์ที่ต้องใช้ เซิร์ฟเวอร์ที่ประกาศไว้ในระดับผู้ใช้จะตามคุณไปทุกรีโพ ใน Claude Code ไฟล์ .mcp.json ของโปรเจกต์จะเก็บมันไว้ในที่ที่มีประโยชน์
• สงวน alwaysLoad ไว้ให้เครื่องมือเพียงไม่กี่ตัว เอกสารของ Claude Code บอกไว้ตรง ๆ: เครื่องมือทุกตัวที่โหลดตั้งแต่แรกกินบริบทที่ควรจะเหลือไว้ให้บทสนทนาของคุณ
• ดูว่าผลลัพธ์ของเครื่องมือเพิ่มอะไรเข้ามา ไม่ใช่แค่คำจำกัดความ เครื่องมือที่ส่งกลับมาทั้งหน้าหรือทั้งตารางอาจมีต้นทุนในการเรียกครั้งเดียวมากกว่าต้นทุนของคำจำกัดความทั้งวัน

ใน AgentsRoom หน้า การตั้งค่า > เครื่องมือ AgentsRoom แสดงเครื่องมือของเราทุกตระกูลพร้อมน้ำหนัก และคุณปิดได้ทั้งตระกูลหรือทีละเครื่องมือ สำหรับทุกโปรเจกต์ โปรเจกต์เดียว โฟลเดอร์หนึ่ง หรือเอเจนต์ตัวเดียว เครื่องมือที่ถูกปิดจะไม่ถูกแสดงให้เอเจนต์เห็นเลย จึงไม่กินบริบท หน้า AgentsRoom MCP อธิบายเครื่องมือเหล่านี้ และ การติดตามเซสชัน แสดงว่าอะไรเติมบริบทของเอเจนต์ รวมถึงเครื่องมือ MCP โดยเรียงตามขนาด

สิ่งที่เราไม่ได้เปลี่ยน

ต้นทุนอีกสองอย่างโผล่ขึ้นมาจากการวัดครั้งเดียวกัน และเราตั้งใจปล่อยไว้ตามเดิม

• บรีฟตอนเริ่มต้น ที่บอกเอเจนต์แต่ละตัวว่ามีบทบาทอะไรและต้องรายงานสถานะอย่างไร: ค่ามัธยฐานราว 5,000 โทเค็นสำหรับ Claude ราว 2.5% ของหน้าต่างบริบทขนาด 200,000 โทเค็น และถูกอ่านจากแคชตั้งแต่คำขอที่สองเป็นต้นไป
• ไฟล์สถานะที่เอเจนต์แต่ละตัวเขียนตอนจบแต่ละรอบ: วัดจากทรานสคริปต์ Claude ในเครื่อง 71 รายการ ได้ราว 2.5% ของโทเค็นบริบท

การย่ออย่างใดอย่างหนึ่งจะประหยัดได้ไม่ถึง 3% ของหน้าต่างบริบท และเสี่ยงต่อคุณภาพงานของเอเจนต์ ขณะที่คำจำกัดความของเครื่องมือหนักถึง 95,000 โทเค็น นั่นคือที่ที่เราใช้เวลาไป

คำถามที่คนถามกันจริง ๆ

เครื่องมือ MCP ใช้โทเค็นเท่าไร

เครื่องมือแต่ละตัวมีต้นทุนเท่ากับคำจำกัดความทั้งหมดของมัน: ชื่อ คำอธิบาย และสคีมาอินพุต ซึ่งส่งไปเป็น JSON กฎคร่าว ๆ คือ 4 ไบต์ต่อโทเค็น วัดเมื่อวันที่ 3 พฤศจิกายน 2026: เซิร์ฟเวอร์ filesystem อย่างเป็นทางการมีเครื่องมือ 14 ตัว ราว 3,100 โทเค็น ส่วน Playwright MCP มี 25 ตัว ราว 5,300 โทเค็น เครื่องมือของ AgentsRoom หนักราว 95,000 โทเค็นก่อนที่เราจะย่อให้สั้นลง และราว 40,000 โทเค็นในวันนี้

Claude Code โหลดเครื่องมือ MCP ทุกตัวเข้าหน้าต่างบริบทหรือไม่

โดยค่าเริ่มต้นไม่ใช่ การค้นหาเครื่องมือของ Claude Code (tool search) จะเลื่อนการโหลดคำจำกัดความของเครื่องมือ MCP ออกไป: ตอนเริ่มเซสชันจะโหลดเพียงชื่อเครื่องมือและคำแนะนำของเซิร์ฟเวอร์ แล้ว Claude จะโหลดคำจำกัดความเมื่อต้องใช้เครื่องมือนั้น การตั้งค่า ENABLE_TOOL_SEARCH=false การใช้โมเดลที่เก่ากว่า Claude Opus 4 และ Sonnet 4 หรือเซิร์ฟเวอร์ที่ทำเครื่องหมาย alwaysLoad จะทำให้คำจำกัดความกลับเข้าไปอยู่ในบริบทตั้งแต่แรก

เซิร์ฟเวอร์ MCP ช่วยลดการใช้โทเค็นได้หรือไม่

ได้ เมื่อเครื่องมือส่งคำตอบสั้น ๆ กลับมาแทนสิ่งที่เอเจนต์จะต้องอ่านทั้งหมด เช่น คิวรีฐานข้อมูลแทนการดัมป์ข้อมูลทั้งก้อน แต่คำจำกัดความก็กินบริบท และผลลัพธ์ก็เช่นกัน: Claude Code จะเตือนเมื่อผลลัพธ์ MCP รายการเดียวเกิน 10,000 โทเค็น และตัดทิ้งที่ 25,000 โทเค็นโดยค่าเริ่มต้น เซิร์ฟเวอร์ MCP จะประหยัดโทเค็นได้ก็ต่อเมื่อผลลัพธ์ของมันเล็กกว่าสิ่งที่มันมาแทนที่

จะดูได้อย่างไรว่าเครื่องมือ MCP ของฉันกินบริบทไปเท่าไร

ใน Claude Code ให้รัน /context: คำสั่งนี้แยกบริบทตามแหล่งที่มา และระบุว่าเครื่องมือ MCP ตัวไหนถูกเลื่อนการโหลด สำหรับเซิร์ฟเวอร์ใดและ CLI ใดก็ได้ ให้ขอรายการเครื่องมือจากเซิร์ฟเวอร์แล้ววัดขนาด JSON ซึ่งก็คือสิ่งที่สคริปต์ 40 บรรทัดในบทความนี้ทำ

คำอธิบายเครื่องมือ MCP ที่ดีเป็นอย่างไร

หนึ่งถึงสามประโยคที่บอกว่าเครื่องมือทำอะไรและควรเรียกใช้เมื่อไร โดยวางคำที่เอเจนต์น่าจะใช้ค้นหาไว้ช่วงต้น พารามิเตอร์ได้หนึ่งประโยค หรือไม่ต้องมีเลยเมื่อชื่อ ชนิด และค่าที่อนุญาตบอกไว้ครบแล้ว กฎ กรณีพิเศษ และตัวอย่างยาว ๆ ให้ย้ายไปอยู่ในเอกสารที่เอเจนต์อ่านเมื่อต้องการ อย่างไรก็ตาม Claude Code ก็ตัดคำอธิบายที่โหลดตั้งแต่แรกไว้ที่ 4,096 อักขระอยู่แล้ว

จะป้องกันไม่ให้คำจำกัดความของเครื่องมือกลับมาบวมอีกได้อย่างไร

กำหนดงบประมาณที่บิลด์ตรวจสอบได้ เราเก็บไฟล์ JSON ที่มีเพดานรวมและเพดานต่อเครื่องมือ มีสคริปต์ที่เปิดเซิร์ฟเวอร์ MCP ของเรา วัดเครื่องมือทุกตัว และจบการทำงานด้วยข้อผิดพลาดเมื่อเกินขีดจำกัดใดขีดจำกัดหนึ่ง และเรารันสคริปต์นี้ก่อนพุชทุกครั้ง เครื่องมือที่ใหญ่เกินอยู่แล้วเล็กลงได้ แต่ห้ามใหญ่ขึ้น

สรุปสั้น ๆ

เครื่องมือ MCP ของคุณคือข้อความที่โมเดลอ่าน และไม่มีใครรีวิวข้อความนั้นแบบที่รีวิวโค้ด วัดมันสักครั้ง: /context ใน Claude Code หรือสคริปต์ด้านบนสำหรับเซิร์ฟเวอร์ใดก็ได้ จากนั้นให้คำอธิบายแต่ละรายการบอกว่าทำอะไรและเมื่อไร ย้ายส่วน "อย่างไร" ไปไว้ในไฟล์ที่เอเจนต์อ่านเมื่อต้องการ และใส่ตัวเลขไว้ในบิลด์เพื่อไม่ให้มันค่อย ๆ บวมกลับมา

เราลดจากราว 95,000 เหลือราว 38,000 โทเค็นโดยไม่ลบเครื่องมือแม้แต่ตัวเดียว ถ้าคุณรันหลายเอเจนต์ด้วยเครื่องมือชุดเดียวกัน AgentsRoom ดาวน์โหลดได้ฟรี และ หน้าเซิร์ฟเวอร์ MCP แสดงวิธีประกาศเซิร์ฟเวอร์ครั้งเดียวสำหรับทุก CLI และทุกโปรเจกต์