D2 · Tool Design & MCP › Cluster 5 · MCP Fundamentals

5.5 · MCP vs Plain Tool Use

Protocol vs per-app wiring

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.

🔑 The one-liner: MCP standardizes tool/data exposure so any MCP host can reuse a server, instead of hand-wiring 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 useMCP equivalent
Hand-written tools=[...] in each requestServer exposes tools; client discovers via tools/list
Tool's name / description / input_schemaSame fields, returned by the server (inputSchema)
Model emits a tool_use blockClient 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-processExecuted by the server, over a connection
Reusable only within your appReusable by any MCP host
Because the shapes match, Claude's MCP connector simply presents a server's tools to the model as if they were ordinary tools — the model doesn't need to know MCP exists. MCP is a distribution and discovery layer around tool use, not a replacement for it.

DIAGRAM Per-app wiring vs. a reusable server

flowchart TD subgraph PLAIN["Plain tool use — wire tools per app"] P1["App A: tools=[…] + executors"] P2["App B: tools=[…] + executors"] P3["App C: tools=[…] + executors"] end subgraph MCPWAY["MCP — one server, every host reuses"] H1["Host A"] --> SV["MCP 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
⚠️ MCP isn't automatically "better" — it adds a server + connection + lifecycle. That overhead pays off through reuse and interoperability. For a single private tool, plain tool use is simpler.

EXAM TRAPS

Trap: "MCP is a different way for the model to call tools." → From the model's view it's the same tool-use mechanism. MCP standardizes exposure and discovery; it doesn't change how the LLM requests a tool.
Trap: "With MCP your app still hand-writes each tool's schema." → No — the server publishes the schemas; the host discovers them via tools/list. That removed per-app wiring is the whole point.
Trap: "Use MCP for everything." → For a single, private, app-specific tool, plain tools=[...] is simpler. MCP earns its overhead when the tool is reused across hosts.
Trap: "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.