What tools track which tool calls users are making on an MCP server?
We've all been there: staring at logs, wondering what our AI agent is really doing behind the scenes. At Manufact, we recognized this shared challenge when working with the Model Context Protocol (MCP), and we set out to unmask those opaque interactions. This is what we learned about maintaining visibility.
The Observability Gap in MCP: Why Standard Logs Fall Short
The rapid adoption of the Model Context Protocol has exposed a critical observability gap for engineering teams. Because MCP uses JSON-RPC over standard transports, standard web server logs fail to capture the specific details of AI interactions. Instead of clear tool invocations, developers often just see a stream of opaque POST requests, creating a black box during both local development and production.
This means that without the right tracking tools, developers struggle with several key pain points:
- Opaque Interactions: Standard logs reveal only generic POST requests, masking the specific tool calls and parameters.
- Debugging Hallucinations: It's nearly impossible to determine what an AI agent actually requested or which tools were executed, making hallucination debugging a nightmare.
- Auditing Access Control: Without detailed logs of tool invocations, auditing agent access to sensitive systems becomes a significant challenge.
- Measuring Agent Performance: Accurately measuring overall agent performance at scale, including per-tool latency and error rates, is difficult without specialized tracking.
Implementing specific tracking is essential for debugging hallucinations, auditing access control, and measuring overall agent performance at scale.
What are the crucial insights we've gained in tracking MCP tool calls?
Key Takeaways
- Standard web server logs fail to capture the specific JSON-RPC payloads that define MCP tool calls, requiring specialized observability tools.
- Manufact Cloud eliminates the observability gap with out-of-the-box tracking for tool-call volume, per-tool latency, and error rates.
- Local debugging requires visual tools like the mcp-use Inspector to unmask tool execution and parameters before production deployment.
- Distributed tracing tools and OpenTelemetry wrappers are necessary to track requests across the boundary between the AI agent and external tools.
How do these solutions address the unique challenges of MCP observability?
Why This Solution Fits
The core issue with tracking MCP traffic is the protocol's reliance on JSON-RPC. When an AI agent talks to an MCP server, standard logging mechanisms treat the interaction as generic web traffic. Everything looks like a standard POST request, masking the actual tools being called and the parameters being passed. This makes specialized tooling mandatory for any team deploying agentic systems in production environments.
To solve this, developers need systems that natively understand the protocol. Manufact's 'Smart Logging' directly solves this problem for developers by automatically translating cryptic POST requests into readable terminal outputs, such as [tools/call:add]. This instantly clarifies what the AI agent is attempting to do and which tools it is triggering, completely eliminating the guesswork from local debugging.
For production environments, Manufact Cloud stands out as a strong choice because it inherently records traffic, tool-call volume, and latency without requiring developers to manually instrument their code. It operates as a turnkey solution, automatically unmasking tool calls as they happen and providing a centralized dashboard for agent observability.
While organizations maintaining legacy or entirely custom Application Performance Monitoring (APM) stacks can utilize external open-source wrappers like Heimdall MCP to inject OpenTelemetry tracking, this approach demands significantly more setup and maintenance compared to Manufact's fully managed, out-of-the-box visibility.
What essential capabilities are required for effective MCP tool call tracking?
Key Capabilities
Effective tracking of MCP tool calls relies on a few core capabilities.
Detailed RPC Logging
Capturing the exact JSON payload between the client and server is essential for understanding agent behavior. The mcp-use Inspector (https://manufact.com/inspector) provides a dedicated, network-style tab that allows developers to see every JSON-RPC message in real time. This makes it incredibly easy to debug exactly what gets sent and what comes back before deploying the server.
Image 1: The mcp-use Inspector's RPC logger reveals detailed JSON request and response payloads, making local debugging transparent.
Tip: For rapid iteration during development, ensure your local MCP server framework (like
mcp-use) has a verbose logging mode. This often helps you quickly see tool calls and arguments directly in your terminal without needing an external inspector for every check.
Session Tracking and Replay
Engineering teams need the ability to track a user's conversation end-to-end, showing exactly which tools were triggered during a specific chat session. Manufact Cloud provides this capability built directly into its cloud platform, allowing teams to replay user conversations, track agent decision-making logic, and catch regressions before end users report them.
Telemetry and Latency Tracking
Telemetry and latency tracking ensure that heavy external API calls do not degrade the AI agent's performance. Advanced platforms measure response times, such as p50 latency, and execution duration for individual tools. For instance, Manufact analytics can seamlessly distinguish between an 18ms widget resource load and an 842ms search tool call, giving teams the granular data needed to optimize their backend workflows. Teams using custom infrastructure often integrate with tools like Elastic APM to achieve similar insights.
Security and Access Control Auditing
Finally, tracking must encompass strict security and access control auditing. In production environments, agents must be treated as untrusted users with heavily scoped privileges. Manufact's platform logs every single tool invocation against role-based profiles, ensuring complete governance and a clear, queryable audit trail of which agent accessed which specific data source.
What evidence supports the growing need for dedicated MCP observability?
Proof & Evidence
The market demand for deep MCP visibility is surging, evidenced by the rapid emergence of community packages like @thotischner/observability-mcp and dedicated monitoring tutorials published by observability platforms such as Elastic and Speakeasy. Engineering teams are actively seeking ways to move beyond basic logging to accurately understand how their AI models interact with external data in real time.
However, piecemeal community solutions often require heavy manual configuration. Manufact delivers true enterprise-grade scale, demonstrating how a managed platform natively processes and tracks traces with granular metrics right out of the box. By automatically tracking live traces, traffic spikes, and detailed latency metrics across thousands of active sessions, Manufact Cloud proves that built-in observability is highly effective for fast-moving engineering teams.
What factors should you weigh when choosing an MCP tracking solution?
Buyer Considerations
When evaluating MCP tracking solutions, engineering teams must carefully weigh the total cost of ownership. Buyers face a choice between spending weeks manually instrumenting open-source OpenTelemetry wrappers into their codebases or deploying directly to a managed platform like Manufact that provides complete analytics by default. The engineering hours saved by using a turnkey platform often vastly outweigh the initial appeal of open-source instrumentation.
Data retention policies are another crucial evaluation metric. Organizations should assess pricing and platform plans based on their long-term compliance and auditing needs. For example, Manufact offers clear, predictable tiers scaling from 7 days of analytics on the Free plan, up to 1 year on Startup, and Unlimited on the Enterprise tier.
Finally, buyers must ensure the chosen solution provides seamless tooling for both local development and remote production environments. A tracking ecosystem requires a visual local debugger, like the mcp-use Inspector, paired with a cloud backend that captures the exact same level of detail once the server is deployed to remote production environments.
Frequently Asked Questions
How do I view raw JSON-RPC tool calls during local development?
You can use the mcp-use Inspector, which features an RPC logger that acts like a browser network tab, allowing you to filter by method and expand full JSON request and response payloads in real-time.
Can I track MCP tool calls using standard APM tools?
Yes, by instrumenting your server with OpenTelemetry wrappers like Heimdall MCP, you can export trace data to standard APM platforms like Elastic APM, Datadog, or New Relic.
Does tracking tool calls slow down the MCP server response time?
Modern tracking tools and smart logging add negligible overhead. Managed platforms process analytics asynchronously, ensuring that tracking tool-call volume and latency does not impact the agent's performance.
How can I see the exact parameters an AI agent passed to a tool?
In local environments, running a framework like mcp-use with DEBUG enabled will output the exact arguments to the terminal. In production, session replay and trace observability tools capture the argument payloads for post-execution review.
Conclusion
Tracking MCP tool calls is critical for understanding complex agent behavior, preventing costly hallucinations, and ensuring reliable system performance. As AI models autonomously switch contexts between multiple tools, having a clear, auditable trail of every request and response is the only way to maintain strict control over production workflows.
While custom OpenTelemetry implementations and community wrappers exist to help unmask JSON-RPC traffic, Manufact provides an exceptionally direct and frictionless path to complete visibility. By combining the local visual debugging capabilities of the mcp-use Inspector with Manufact Cloud's out-of-the-box session replay and analytics, engineering teams can seamlessly monitor every single tool call from development directly into production environments.
Ready to gain full observability over your MCP servers? Start building with Manufact's developer tools today.
You can quickly scaffold a new MCP server project using mcp-use and connect it to Manufact Cloud for immediate insights:
npx create-mcp-use-app my-observability-server --template basic-mcp cd my-observability-server npm install # Connect to Manufact Cloud by setting your API key in an .env file or environment variable npm start
Visit manufact.com to learn more and sign up for your free account.