MCP (tracing) | Respan Docs

Model Context Protocol (MCP) is an open standard for connecting AI applications to tools, prompts, and external context. Respan gives you full observability over MCP client requests, server tool handlers, resource reads, prompt reads, and tool outputs, with optional gateway routing for LLM calls made inside your MCP application.

Set up Respan

Create an account at platform.respan.ai and grab an API key.

Run npx @respan/cli setup to set up with your coding agent.

Use Respan Gateway

See MCP (Model Context Protocol) gateway setup to route this integration through the Respan gateway.

Example projects

Setup

Install packages

$ pip install respan-ai openinference-instrumentation-mcp mcp

Set environment variables

$ export RESPAN_API_KEY="YOUR_RESPAN_API_KEY"

RESPAN_API_KEY is used to export traces to Respan.

Initialize and run

1 import asyncio
2 from mcp import ClientSession, StdioServerParameters
3 from mcp.client.stdio import stdio_client
4 from respan import Respan
5 from openinference.instrumentation.mcp import MCPInstrumentor
6 
7 respan = Respan(
8     app_name="mcp-python-client",
9     instrumentations=[MCPInstrumentor()],
10 )
11 
12 
13 async def main():
14     server_params = StdioServerParameters(
15         command="python",
16         args=["your_mcp_server.py"],
17     )
18 
19     async with stdio_client(server_params) as (read, write):
20         async with ClientSession(read, write) as session:
21             await session.initialize()
22 
23             tools = await session.list_tools()
24             print(f"Available tools: {[tool.name for tool in tools.tools]}")
25 
26             result = await session.call_tool(
27                 "summarize_city",
28                 arguments={"city": "Paris"},
29             )
30             print(result)
31 
32     respan.flush()
33 
34 
35 asyncio.run(main())

View your trace

Open the Traces page to see your MCP workflow with client operations, server tool handlers, resource reads, prompt reads, inputs, outputs, and timing.

Configuration

Parameter	Type	Default	Description
`api_key` / `apiKey`	`str \| None` / `string \| undefined`	`RESPAN_API_KEY`	Respan API key used to export traces.
`base_url` / `baseURL`	`str \| None` / `string \| undefined`	`RESPAN_BASE_URL`	Optional Respan API base URL.
`app_name` / `appName`	`str \| None` / `string \| undefined`	`None` / `undefined`	Service name shown on exported spans.
`instrumentations`	`list` / `array`	`[]`	Plugin instrumentations to activate, such as `MCPInstrumentor()` or `new MCPInstrumentor()`.
`customer_identifier`	`str \| None`	`None`	Default customer identifier for Python spans.
`metadata`	`dict \| None` / `object`	`None` / `undefined`	Default metadata attached to exported spans.
`environment`	`str \| None` / `string \| undefined`	`None` / `undefined`	Environment tag, such as `"production"` or `"test"`.

MCPInstrumentor options

Parameter	Type	Default	Description
`captureClientOperations`	`boolean`	`true`	Capture MCP client methods including connect, tools, resources, and prompts.
`captureServerTools`	`boolean`	`true`	Capture `McpServer.registerTool()` and `McpServer.tool()` handlers.
`clientModule`	`object \| undefined`	Auto-imported	Optional explicit `@modelcontextprotocol/sdk/client/index.js` module reference.
`serverModule`	`object \| undefined`	Auto-imported	Optional explicit `@modelcontextprotocol/sdk/server/mcp.js` module reference.

Attributes

In Respan()

Set defaults at initialization — these apply to exported spans.

1 from respan import Respan
2 from openinference.instrumentation.mcp import MCPInstrumentor
3 
4 respan = Respan(
5     app_name="mcp-api",
6     instrumentations=[MCPInstrumentor()],
7     customer_identifier="user_123",
8     metadata={"service": "mcp-api", "version": "1.0.0"},
9 )

With propagate_attributes

Override per request using a context scope.

1 from respan import Respan, propagate_attributes
2 from openinference.instrumentation.mcp import MCPInstrumentor
3 
4 respan = Respan(instrumentations=[MCPInstrumentor()])
5 
6 
7 async def handle_request(user_id: str, tool_name: str, args: dict):
8     with propagate_attributes(
9         customer_identifier=user_id,
10         thread_identifier="conv_abc_123",
11         metadata={"plan": "pro"},
12     ):
13         result = await session.call_tool(tool_name, arguments=args)
14         print(result)

Attribute	Type	Description
`customer_identifier`	`str`	Identifies the end user in Respan analytics.
`thread_identifier`	`str`	Groups related messages into a conversation.
`metadata`	`dict`	Custom key-value pairs. Merged with default metadata.