Saras Growth Space

Posted on May 7

How MCP Actually Works Under the Hood (Without Getting Lost in Protocols)

#ai #mcp #softwareengineering #architecture

So far, we’ve built a solid understanding of:

tools
MCP client
MCP server
tools vs resources

Now let’s answer a practical question:

What actually happens internally when a tool is used?

🧠 The Big Idea

MCP works through structured communication between components.

In simple terms:

Systems talk to each other using structured messages, not plain text.

🔄 The End-to-End Flow

Let’s walk through a real example.

User asks:

“Show my last 3 orders”

Step 1 — Client sends context to the model

The MCP client sends:

user query
list of tools

Step 2 — Model decides

It generates something like:

{
  "tool": "get_user_orders",
  "arguments": {
    "user_id": "123",
    "limit": 3
  }
}

Step 3 — Client translates this into a request

This is where things become more “system-level”.

The MCP client converts this into a structured request.

Step 4 — Request goes to MCP server

The server receives:

tool name
arguments

Step 5 — Server executes

validates input
runs logic
returns result

Step 6 — Client sends result back to model

Step 7 — Model generates final response

🧠 What’s Really Happening Behind the Scenes

Under the hood, this communication usually follows a standard like:

JSON-RPC (a structured request/response format)

You don’t need to memorize it, but here’s a simplified view.

Example Request

{
  "method": "tools.call",
  "params": {
    "name": "get_user_orders",
    "arguments": {
      "user_id": "123"
    }
  }
}

Example Response

{
  "result": {
    "orders": [ ... ]
  }
}

🔥 Key Insight

The model never sees this.

👉 The MCP client handles:

converting model output → structured request
converting server response → model-friendly input

🧠 Why Structured Communication Matters

Without structure:

hard to parse
error-prone
inconsistent behavior

With structure:

reliable execution
predictable results
easier scaling

⚠️ Error Handling (Important)

If something goes wrong, the server returns:

{
  "error": {
    "message": "Invalid user_id"
  }
}

The client then:

handles the error
sends a safe message to the model

🧠 Mental Model

Think of it like this:

Model → speaks natural language
Server → speaks structured data
Client → translates between both

🧭 Why This Matters

Understanding this helps you:

debug issues
design better systems
reason about failures

🧭 What’s Next

Now that we understand how MCP works internally,
we’ll move to something very practical:

How to design good tools that actually work well with LLMs

Because in real systems, tool design makes or breaks everything.

DEV Community