Turn Your AI Assistant Into a Debugging Detective

Stop context-switching between your IDE and Logfire's web interface every time you need to investigate production issues. The Logfire MCP Server connects your AI assistant directly to your OpenTelemetry traces and metrics, letting you debug with natural language queries.

The Problem Every Developer Knows

You're deep in a coding session when alerts start firing. Now you need to:

1. Open Logfire in your browser
2. Navigate through traces manually
3. Switch back to your code
4. Correlate the error with your implementation
5. Repeat this dance until you find the root cause

Meanwhile, your AI assistant sits idle, unable to help with the most time-consuming part of debugging.

Query Your Production Data Like a Pro

With Logfire MCP, your AI assistant becomes your debugging partner. Instead of manual trace hunting, you can ask:

• "What exceptions happened in the last hour across all services?"
• "Show me recent errors in app/api.py with their trace context"
• "Find the most common exception types by service name"
• "Get me all database timeout errors from yesterday"

Your assistant executes these queries directly against your Logfire data and provides actionable insights without you leaving your development environment.

Four Powerful Tools, Zero Learning Curve

find_exceptions: Get exception counts grouped by file path. Perfect for spotting which parts of your codebase are throwing errors most frequently.

find_exceptions_in_file: Drill down into specific files to see detailed trace information, including stack traces, attributes, and trace IDs.

arbitrary_query: Run custom SQL queries against your OpenTelemetry data. Full access to your traces and metrics with the flexibility of SQL.

get_logfire_records_schema: Understand your data structure to craft better queries.

Each tool works with a simple time window parameter (up to 7 days back), so you can focus on recent issues or investigate historical patterns.

Real-World Debugging Scenarios

Production Fire Drill: When alerts fire at 2 AM, ask "What new exceptions appeared in the last 30 minutes?" Get immediate insight into what broke without clicking through dozens of trace views.

Performance Investigation: Run queries like SELECT AVG(duration_ms), service_name FROM traces WHERE operation_name = 'database_query' AND created_at > NOW() - INTERVAL '24 hours' GROUP BY service_name to identify slow services.

Code Review Context: Before deploying, ask "Show me all errors from the payment_processor.py file in the last week" to understand the stability of code you're about to modify.

Post-Mortem Analysis: Query specific time ranges around incidents with full SQL flexibility: SELECT trace_id, message, attributes FROM records WHERE severity_text = 'ERROR' AND created_at BETWEEN '2024-03-20 10:00:00' AND '2024-03-20 11:00:00'

Setup Takes 2 Minutes

1. Get your Logfire read token from your project settings
2. Install with uvx (comes with uv): uvx logfire-mcp --read-token=YOUR_TOKEN
3. Configure your MCP client with a simple JSON config

That's it. No complex authentication flows, no additional infrastructure, no learning new query languages.

For Cursor users, just add this to .cursor/mcp.json:

{
  "mcpServers": {
    "logfire": {
      "command": "uvx",
      "args": ["logfire-mcp", "--read-token=YOUR-TOKEN"]
    }
  }
}

Works Where You Work

Built by the Pydantic team, this server integrates seamlessly with:

• Cursor: Native MCP support for contextual debugging
• Claude Desktop: Full conversational access to your telemetry data
• Cline: Automated debugging workflows with your traces
• Any MCP-compatible client: Standard protocol means broad compatibility

Production-Ready from Day One

This isn't a proof-of-concept. The server handles real production workloads with:

• Project-specific read tokens: Secure, scoped access to your data
• Custom base URLs: Works with self-hosted Logfire instances
• Flexible time windows: Query from minutes to a full week of data
• SQL power: Full query capabilities for complex investigations

Stop Manual Trace Hunting

Your observability data is already structured and queryable. Your AI assistant is already capable of complex reasoning. The Logfire MCP Server is the missing link that turns hours of manual investigation into seconds of natural language queries.

Install it, configure it, and start debugging with the efficiency you've been waiting for.