CONCEPT Same model machinery, different distribution model
Both approaches end up giving the model tools to call. The difference is where the tool definitions live and who can reuse them.
- Plain Messages-API tool use: you hand-write a
tools=[...]array in each request — every tool'sname,description, andinput_schema. When the model emits atool_useblock, your application executes it and returns atool_result. The wiring lives inside your one app. - MCP: a server exposes tools (and resources, prompts) over the protocol.
Any MCP-compatible host can discover them via
tools/listand call them viatools/call— with no per-app tool wiring. Write the server once, reuse everywhere.
tools=[...] per application. Plain tool use is per-app
integration; MCP is a shared, reusable protocol.CONCEPT The mapping is nearly 1:1
MCP didn't reinvent tool use — it wraps the same concepts in a portable protocol. The primitives line up:
| Plain Messages-API tool use | MCP equivalent |
|---|---|
Hand-written tools=[...] in each request | Server exposes tools; client discovers via tools/list |
Tool's name / description / input_schema | Same fields, returned by the server (inputSchema) |
Model emits a tool_use block | Client issues tools/call |
You return a tool_result (can set is_error) | Server returns a result content array |
tool_choice (auto / any / tool / none) | Host still controls choice — MCP just supplies the tools |
| Executed by your app, in-process | Executed by the server, over a connection |
| Reusable only within your app | Reusable by any MCP host |
DIAGRAM Per-app wiring vs. a reusable server
(tools/list · tools/call)"] H2["Host B"] --> SV H3["Host C"] --> SV end classDef ok fill:#d4edda,stroke:#28a745,color:#155724; classDef bad fill:#f8d7da,stroke:#dc3545,color:#721c24; class SV ok; class P1,P2,P3 bad;
CODE Same capability, two ways
A weather tool, hand-wired into one app vs. reused from a server via Claude's MCP connector:
# A) Plain tool use — you define + execute the tool in THIS app resp = client.messages.create( model="claude-opus-4-8", max_tokens=1024, tools=[{ "name": "get_weather", "description": "Get current weather for a location", "input_schema": { "type": "object", "properties": { "location": { "type": "string" } }, "required": ["location"] }, }], messages=[{ "role": "user", "content": "Weather in Paris?" }], ) # → model returns a tool_use block; YOUR code runs it and sends tool_result # B) MCP connector — reuse a server's tools; no per-tool wiring here resp = client.beta.messages.create( model="claude-opus-4-8", max_tokens=1024, betas=["mcp-client-2025-11-20"], mcp_servers=[{ "type": "url", "name": "weather", "url": "https://example.com/mcp" }], tools=[{ "type": "mcp_toolset", "mcp_server_name": "weather" }], messages=[{ "role": "user", "content": "Weather in Paris?" }], ) # → the server is discovered & called for you; the same server works in any host
TRADE-OFFS When to hand-wire, when to reach for MCP
✅ MCP server
- Reusable across every MCP host — build once
- Dynamic discovery + shared lifecycle/auth
- Best when a capability is shared across apps/teams or is a common integration (GitHub, DBs)
✅ Plain tools=[...]
- Zero extra moving parts — no server to run
- Full in-process control over execution
- Best for one-off, app-specific tools only your app will ever call
EXAM TRAPS
tools/list. That removed per-app
wiring is the whole point.tools=[...] is simpler. MCP earns its overhead when the tool is reused across hosts.tool_choice doesn't exist with MCP." → The host still controls tool
choice (auto/any/tool/none). MCP only supplies which tools are available.PRACTICE
Q1 · State the core difference between MCP and plain Messages-API tool use in one sentence.
Plain tool use hand-wires tools=[...] and executors per application; MCP
exposes tools from a reusable server that any MCP-compatible host can discover and call — the same
server works everywhere.
Q2 · Map tool_use / tool_result onto MCP.
A model tool_use block corresponds to the client issuing tools/call;
the returned tool_result corresponds to the server's result content. The tool
name/description/input_schema map to the server's advertised tool
definitions (inputSchema).
Q3 · You have a one-off internal tool only your app will ever use. MCP or plain tool use?
Plain tool use. There's no reuse or interoperability to gain, so the added server,
connection, and lifecycle of MCP aren't worth it — just define it in tools=[...] and execute it
in-process. Reach for MCP when the capability should be shared across hosts.