**JSON-RPC** is the message format MCP uses. Every request the client sends carries an `id` field, like a tracking number. The server is supposed to copy that same id into its response so the client knows which request the answer belongs to.
The client keeps a table of pending requests, keyed by id. When a response comes in, it looks up that id, finds the waiting callback, and resolves the call. This is how it tells apart five tool calls that are all in flight at once.
The common bug tracing reveals is an `id` mismatch. A buggy server generates a brand-new id for the response instead of echoing the one it received. The client gets the response, looks up its id, finds nothing in the table, and silently discards it. The original call never resolves, so it looks like the server hung.
Tracing makes this obvious: you log the outgoing request id and the incoming response id side by side, and the mismatch jumps out. Without tracing you would chase a phantom timeout for hours.
The bug tracing surfaces most often is a broken `id` correlation.
JSON-RPC 2.0 pairs each request with its response using the `id` field. The client holds a pending-request map keyed by that id. When a response arrives, it looks up the id, finds the waiting promise, and resolves it. A buggy server that mints a fresh id, or omits it, breaks that lookup. The client finds no match, drops the response, and the call hangs until it times out.
This is hard to diagnose blind. The server logs look healthy. The tool ran fine. The wire even carried a valid response. The only visible symptom is a call that never returns. Tracing fixes that by logging method, id, and latency per call, showing request and response ids together so the mismatch is obvious.
A second classic find is a notification mistaken for a request. JSON-RPC notifications carry no id and expect no reply. If the server answers one anyway, or never replies to a real request, the trace exposes the asymmetry instantly.
Quick reference
TL;DR
The classic MCP tracing find is an `id` mismatch: the server mints a fresh response id instead of echoing the request id, so the client can never correlate it and the call hangs forever.
Picture a busy coat check. You hand over your coat and get ticket number 47. Later you come back with ticket 47, and the attendant matches the number to find your coat. The number is the only link between you and your coat. Now imagine the attendant hands your coat back to someone holding a brand-new ticket they printed themselves, number 999. Your ticket 47 never matches anything, so you stand there waiting forever, even though your coat is sitting right on the rack. JSON-RPC works the same way: the `id` field is the ticket. The client keeps a list of tickets it is waiting on. If the server replies with the wrong ticket number, the client cannot find the matching entry, so it waits, the response is thrown away, and the call looks like it silently hung.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
A call fails with an explicit JSON-RPC error object and a matching id Correlation already worked; the problem is the tool's error contract, so look at the error code and message instead.
The transport itself dropped the connection mid-session No response arrives because the pipe closed, not because an id mismatched; check transport health and the initialize handshake first.
You only need aggregate latency percentiles, not per-call correlation A metrics counter is cheaper than full message tracing; reserve id-level tracing for debugging hangs and dropped calls.
Quick scan · 2–4 min
Everything important, quickly.
4 min: how the id correlates request to response, the pending-request map, why a mismatch silently drops the response and hangs the call, and the method, id, and latency trace that exposes it.
Side-by-side
Symptom in trace
Likely cause
What to log
Request sent, no response line ever
Server crashed, dropped the call, or never replied
Outgoing id plus a timeout marker
Response arrives with a different id
Server minted a new id instead of echoing it
Both request and response ids side by side
Response arrives slowly but matches
Slow tool, not a correlation bug
Per-call latency from send to receive
Reply sent to a message with no id
Server answered a notification it should ignore
Direction plus whether an id was present
Real-world examples
Real products, models, and research that use this idea.
1The official mcp-inspector tool logs every JSON-RPC message with method and id so you can watch correlation live while testing a server.
2Claude Code emits an MCP debug log that records each request id and round-trip latency, surfacing hung calls during a session.
3LangSmith and OpenTelemetry-based tracing wrap MCP clients to record method, id, and per-call latency as spans for production debugging.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you distinguish a dropped JSON-RPC call from a tool that is merely slow?
Sign in or go Pro to see the approach for this follow-up.
QWhy are JSON-RPC ids unique only per connection, and how does that bite multi-server hosts?
Sign in or go Pro to see the approach for this follow-up.
QWhat does the trace look like when the bug is a notification answered as a request?
Sign in or go Pro to see the approach for this follow-up.
QHow would you instrument an MCP client to make these bugs visible in production?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Blaming a hung MCP call on a slow tool or a crashed server when tracing shows the response arrived fine but carried the wrong id, so the client dropped it.