Tuần trước mình debug một agent nội bộ: model chọn sai tool liên tục, response chậm, bill API tăng gần gấp đôi so với tháng trước. Code agent không đổi gì, prompt cũng không đổi. Hóa ra team vừa cắm thêm 3 MCP server (GitHub, Postgres, Jira), tổng cộng hơn 90 tool. Request nào cũng phải gửi kèm toàn bộ định nghĩa tool, trước khi user kịp gõ chữ nào đã mất khoảng 38.000 token. Bài này chia sẻ cách mình đo chi phí đó, cắt gọn schema và chuyển sang lazy-load tool, để agent vừa rẻ hơn vừa chọn tool chính xác hơn.
Vì sao MCP tool lại tốn context đến vậy
Khi agent kết nối tới một MCP server, client gọi tools/list và nhận về danh sách tool, mỗi tool gồm name, description và inputSchema (JSON Schema). Phần lớn framework đưa toàn bộ danh sách này vào mọi request gửi tới LLM. Hậu quả:
- Chi phí cố định cho mỗi request: 90 tool × ~400 token mỗi tool = 36k token, kể cả khi user chỉ hỏi chào buổi sáng.
-
Model chọn tool kém đi: càng nhiều tool trùng ý nghĩa (
search_issues,search_code,search_jira...) thì model càng dễ chọn nhầm. - Còn ít chỗ cho dữ liệu thật: context dành cho file, log, kết quả query bị thu hẹp.
flowchart LR
U[User message] --> A[Agent]
S1[GitHub MCP<br/>35 tools] --> A
S2[Postgres MCP<br/>20 tools] --> A
S3[Jira MCP<br/>38 tools] --> A
A -->|system + 93 tool schemas + message| L[LLM]
L --> R[~38k token overhead mỗi request]
Trước khi tối ưu thì phải đo đã. Đừng đoán.
Bước 1: Đo số token của từng MCP server
Mình dùng mcp Python SDK (bản 1.x) để kết nối tới server qua stdio, lấy danh sách tool rồi đếm token. Ở đây mình dùng tiktoken với encoding cl100k_base để ước lượng. Tokenizer của mỗi model sẽ lệch một chút, nhưng để so sánh tương đối giữa các server thì dùng được.
python3 -m venv .venv && source .venv/bin/activate
pip install "mcp>=1.2" tiktoken
# measure_tools.py
import asyncio, json, sys
import tiktoken
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
enc = tiktoken.get_encoding("cl100k_base")
def tool_tokens(tool) -> int:
payload = {
"name": tool.name,
"description": tool.description or "",
"input_schema": tool.inputSchema,
}
return len(enc.encode(json.dumps(payload, ensure_ascii=False)))
async def measure(command: str, args: list[str]):
params = StdioServerParameters(command=command, args=args)
async with stdio_client(params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
result = await session.list_tools()
rows = sorted(
((t.name, tool_tokens(t)) for t in result.tools),
key=lambda x: -x[1],
)
total = sum(n for _, n in rows)
print(f"{len(rows)} tools, ~{total} tokens")
for name, n in rows[:10]:
print(f" {n:>6} {name}")
if __name__ == "__main__":
asyncio.run(measure(sys.argv[1], sys.argv[2:]))
Chạy thử với filesystem server chính thức:
python measure_tools.py npx -y @modelcontextprotocol/server-filesystem /tmp
Kết quả bên mình làm nhiều người bất ngờ: chỉ 10 tool chiếm tới 55% tổng token. Nguyên nhân thường là description dài như tài liệu hướng dẫn, có cả ví dụ, và schema có enum hàng chục giá trị hoặc object lồng 4-5 tầng.
Bước 2: Cắt gọn schema trước khi đưa cho model
Nhiều MCP server là của bên thứ ba nên mình không sửa trực tiếp được. Cách làm là thêm một lớp transform ở phía client: giữ nguyên tên tool để gọi lại server, chỉ rút gọn phần gửi cho LLM.
# slim.py
import copy
DROP_KEYS = {"examples", "$schema", "additionalProperties", "title", "default"}
MAX_DESC = 160
MAX_ENUM = 8
def slim_schema(node):
if isinstance(node, dict):
out = {}
for k, v in node.items():
if k in DROP_KEYS:
continue
if k == "description" and isinstance(v, str):
v = v.strip().split("\n")[0][:MAX_DESC]
if k == "enum" and isinstance(v, list) and len(v) > MAX_ENUM:
# enum quá dài: bỏ enum, ghi gợi ý vào description
out["description"] = (out.get("description", "") +
f" (một trong: {', '.join(map(str, v[:MAX_ENUM]))}, ...)").strip()
continue
out[k] = slim_schema(v)
return out
if isinstance(node, list):
return [slim_schema(x) for x in node]
return node
def slim_tool(tool: dict) -> dict:
t = copy.deepcopy(tool)
t["description"] = (t.get("description") or "").split("\n\n")[0][:MAX_DESC * 2]
t["input_schema"] = slim_schema(t["input_schema"])
return t
Vài kinh nghiệm thực tế:
- Chỉ giữ đoạn đầu của description. Phần ví dụ dài thường không giúp model chọn đúng hơn.
-
Không xóa
requiredvàtype, nếu không model sẽ truyền sai argument và server trả lỗi validation. - Phải test lại: sau khi slim, chạy bộ eval khoảng 50 prompt thật xem tỷ lệ chọn đúng tool có giảm không. Bên mình token giảm khoảng 40%, accuracy giữ nguyên.
Bước 3: Lazy-load tool theo ngữ cảnh
Slim schema chỉ giảm được tuyến tính. Muốn giảm mạnh hơn thì đừng gửi cả 93 tool nữa, mỗi lượt chỉ gửi top-k tool liên quan cộng với một meta-tool find_tools để model tự xin thêm khi cần.
sequenceDiagram
participant U as User
participant R as Tool Router
participant L as LLM
participant M as MCP Servers
U->>R: "Tạo issue cho bug login"
R->>R: Rank 93 tools, chọn top 6 + find_tools
R->>L: message + 7 tool schemas
L->>R: call github.create_issue
R->>M: tools/call
M-->>R: result
R-->>L: tool result
L-->>U: Đã tạo issue #482
Router của mình viết rất đơn giản, chưa cần đến embedding. Chỉ dùng BM25 trên name + description, với ~100 tool chạy chưa tới 1ms:
# router.py (pip install rank-bm25)
import re
from rank_bm25 import BM25Okapi
def tokenize(s: str) -> list[str]:
return re.findall(r"[a-z0-9]+", s.lower().replace("_", " "))
class ToolRouter:
def __init__(self, tools: list[dict], always_on: set[str] = frozenset()):
self.tools = tools
self.always_on = always_on
self.bm25 = BM25Okapi([tokenize(t["name"] + " " + t["description"]) for t in tools])
def select(self, query: str, k: int = 6) -> list[dict]:
scores = self.bm25.get_scores(tokenize(query))
ranked = sorted(zip(scores, self.tools), key=lambda x: -x[0])
picked = [t for s, t in ranked[:k] if s > 0]
picked += [t for t in self.tools if t["name"] in self.always_on and t not in picked]
return picked + [FIND_TOOLS]
FIND_TOOLS = {
"name": "find_tools",
"description": "Tìm thêm tool nếu các tool hiện có không phù hợp. Trả về tên + mô tả ngắn.",
"input_schema": {"type": "object",
"properties": {"query": {"type": "string"}},
"required": ["query"]},
}
Khi model gọi find_tools, router chạy select(query, k=5) và thêm các tool đó vào danh sách cho lượt kế tiếp, các tool đã chọn từ trước vẫn giữ lại. Lưu ý quan trọng: giữ thứ tự tool ổn định giữa các lượt. Nếu provider của bạn có prompt caching, xáo trộn danh sách tool sẽ làm cache miss liên tục và mất luôn phần lợi vừa có được.
Kết quả sau 2 tuần chạy production: token đầu vào trung bình giảm từ ~41k xuống ~9k mỗi request, tỷ lệ chọn sai tool giảm khoảng 1/3 (do ít tool "na ná nhau" hơn). Model gọi find_tools ở khoảng 7% số lượt, đổi lại tốn thêm một round-trip, chấp nhận được.
Kết luận
MCP giúp cắm tool vào agent dễ như cắm USB, nhưng chính vì dễ nên chúng ta hay cắm quá tay. Checklist mình áp dụng cho mọi agent:
-
Đo trước: chạy
measure_tools.pycho từng server, ghi lại số token vào README nội bộ hoặc CI. Server nào vượt 5k token thì phải review. - Chỉ bật tool thực sự dùng: nhiều client hỗ trợ allowlist tool. Một GitHub server 35 tool mà bạn chỉ dùng 6 thì tắt 29 tool kia đi.
-
Slim schema ở phía client: cắt description, bỏ
examplesvà enum dài. Nhớ chạy eval trước và sau khi slim. -
Lazy-load khi có trên ~30 tool: BM25 router + meta-tool
find_toolslà đủ để bắt đầu, chưa cần vector DB. - Giữ thứ tự tool ổn định để không phá prompt cache.
-
Theo dõi liên tục: log
input_tokenstheo từng request. Khi ai đó cắm thêm MCP server mới, bạn sẽ thấy ngay trên dashboard thay vì đợi đến cuối tháng nhìn hóa đơn.
Context window không phải tài nguyên miễn phí. Mỗi token dành cho định nghĩa tool không dùng tới là một token bớt đi cho dữ liệu thật mà agent cần để làm việc.
Top comments (0)