Skip to main content
Glama
Logfire MCP Server

Logfire MCP Server

Official
by pydantic

Servidor MCP de Logfire

Este repositorio contiene un servidor de Protocolo de contexto de modelo (MCP) con herramientas que pueden acceder a los seguimientos y métricas de OpenTelemetry que ha enviado a Logfire.

Este servidor MCP permite a los LLM recuperar datos de telemetría de su aplicación, analizar seguimientos distribuidos y utilizar los resultados de consultas SQL arbitrarias ejecutadas mediante las API de Logfire.

Herramientas disponibles

  • find_exceptions - Obtener recuentos de excepciones de los seguimientos agrupados por archivo

    • Argumentos obligatorios:

      • age (int): Número de minutos para mirar hacia atrás (por ejemplo, 30 para los últimos 30 minutos, máximo 7 días)

  • find_exceptions_in_file : obtiene información de seguimiento detallada sobre las excepciones en un archivo específico

    • Argumentos obligatorios:

      • filepath (cadena): Ruta al archivo a analizar

      • age (int): Número de minutos para mirar atrás (máximo 7 días)

  • arbitrary_query : ejecuta consultas SQL personalizadas en tus seguimientos y métricas de OpenTelemetry

    • Argumentos obligatorios:

      • query (cadena): consulta SQL a ejecutar

      • age (int): Número de minutos para mirar atrás (máximo 7 días)

  • get_logfire_records_schema : obtiene el esquema de OpenTelemetry para ayudar con consultas personalizadas

    • No se requieren argumentos

Related MCP server: Observe MCP Server

Configuración

Instalar uv

Lo primero que debe hacer es asegurarse de que uv esté instalado, ya que uv se utiliza para ejecutar el servidor MCP.

Para obtener instrucciones de instalación, consulte los documentos de instalación uv .

Si ya tiene instalada una versión anterior de uv , es posible que necesite actualizarla con uv self update .

Obtener un token de lectura de Logfire

Para realizar solicitudes a las API de Logfire, el servidor Logfire MCP requiere un "token de lectura".

Puede crear uno en la sección "Tokens de lectura" de la configuración de su proyecto en Logfire: https://logfire.pydantic.dev/-/redirect/latest-project/settings/read-tokens

[!IMPORTANTE] Los tokens de lectura de Logfire son específicos del proyecto, por lo que debe crear uno para el proyecto específico que desea exponer al servidor Logfire MCP.

Ejecutar el servidor manualmente

Una vez que tenga uv instalado y tenga un token de lectura de Logfire, puede ejecutar manualmente el servidor MCP usando uvx (que es proporcionado por uv ).

Puede especificar su token de lectura utilizando la variable de entorno LOGFIRE_READ_TOKEN :

LOGFIRE_READ_TOKEN=YOUR_READ_TOKEN uvx logfire-mcp

o usando el indicador --read-token :

uvx logfire-mcp --read-token=YOUR_READ_TOKEN

[!NOTA]
Si utiliza Cursor, Claude Desktop, Cline u otros clientes MCP que administran sus servidores MCP, NO necesita ejecutar el servidor manualmente. La siguiente sección le mostrará cómo configurar estos clientes para usar el servidor MCP de Logfire.

Configuración con clientes MCP conocidos

Configurar para el cursor

Cree un archivo .cursor/mcp.json en la raíz de su proyecto:

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

El cursor no acepta el campo env , por lo que debe utilizar el indicador --read-token en su lugar.

Configurar para Claude Desktop

Añade a tu configuración de Claude:

{
  "command": ["uvx"],
  "args": ["logfire-mcp"],
  "type": "stdio",
  "env": {
    "LOGFIRE_READ_TOKEN": "YOUR_TOKEN"
  }
}

Configurar para Cline

Agregue a su configuración de Cline en cline_mcp_settings.json :

{
  "mcpServers": {
    "logfire": {
      "command": "uvx",
      "args": ["logfire-mcp"],
      "env": {
        "LOGFIRE_READ_TOKEN": "YOUR_TOKEN"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Personalización - URL base

De forma predeterminada, el servidor se conecta a la API de Logfire en https://logfire-api.pydantic.dev . Puede anular esto mediante:

  1. Usando el argumento --base-url :

uvx logfire-mcp --base-url=https://your-logfire-instance.com
  1. Configuración de la variable de entorno:

LOGFIRE_BASE_URL=https://your-logfire-instance.com uvx logfire-mcp

Ejemplos de interacciones

  1. Encuentre todas las excepciones en los seguimientos de la última hora:

{
  "name": "find_exceptions",
  "arguments": {
    "age": 60
  }
}

Respuesta:

[
  {
    "filepath": "app/api.py",
    "count": 12
  },
  {
    "filepath": "app/models.py",
    "count": 5
  }
]
  1. Obtenga detalles sobre las excepciones de los seguimientos en un archivo específico:

{
  "name": "find_exceptions_in_file",
  "arguments": {
    "filepath": "app/api.py",
    "age": 1440
  }
}

Respuesta:

[
  {
    "created_at": "2024-03-20T10:30:00Z",
    "message": "Failed to process request",
    "exception_type": "ValueError",
    "exception_message": "Invalid input format",
    "function_name": "process_request",
    "line_number": "42",
    "attributes": {
      "service.name": "api-service",
      "code.filepath": "app/api.py"
    },
    "trace_id": "1234567890abcdef"
  }
]
  1. Ejecutar una consulta personalizada en los seguimientos:

{
  "name": "arbitrary_query",
  "arguments": {
    "query": "SELECT trace_id, message, created_at, attributes->>'service.name' as service FROM records WHERE severity_text = 'ERROR' ORDER BY created_at DESC LIMIT 10",
    "age": 1440
  }
}

Ejemplos de preguntas para Claude

  1. "¿Qué excepciones ocurrieron en los seguimientos de la última hora en todos los servicios?"

  2. "Muéstrame los errores recientes en el archivo 'app/api.py' con su contexto de seguimiento"

  3. "¿Cuántos errores hubo en las últimas 24 horas por servicio?"

  4. "¿Cuáles son los tipos de excepciones más comunes en mis seguimientos, agrupados por nombre de servicio?"

  5. "Consígueme el esquema de OpenTelemetry para seguimientos y métricas"

  6. "Encuentra todos los errores de ayer y muestra sus contextos de seguimiento"

Empezando

  1. Primero, obtenga un token de lectura de Logfire desde: https://logfire.pydantic.dev/-/redirect/latest-project/settings/read-tokens

  2. Ejecute el servidor MCP:

    uvx logfire-mcp --read-token=YOUR_TOKEN
  3. Configure su cliente preferido (Cursor, Claude Desktop o Cline) utilizando los ejemplos de configuración anteriores

  4. ¡Comience a utilizar el servidor MCP para analizar sus seguimientos y métricas de OpenTelemetry!

Contribuyendo

Agradecemos sus contribuciones para mejorar el servidor Logfire MCP. Ya sea que desee agregar nuevas herramientas de análisis de trazas, mejorar la funcionalidad de consulta de métricas o mejorar la documentación, su opinión es valiosa.

Para obtener ejemplos de otros servidores MCP y patrones de implementación, consulte el repositorio de servidores de Protocolo de contexto de modelo .

Licencia

Logfire MCP cuenta con la licencia MIT. Esto significa que usted tiene libertad de usar, modificar y distribuir el software, sujeto a los términos y condiciones de la licencia MIT.

Available Tools

4 tools
arbitrary_queryB

Run an arbitrary query on the Pydantic Logfire database.

The SQL reference is available via the `sql_reference` tool.

Inputs: query (required), age (required). Returns: result

find_exceptions_in_fileA

Get the details about the 10 most recent exceptions on the file.

Inputs: filepath (required), age (required). Returns: result

schema_referenceA

The database schema for the Logfire DataFusion database.

This includes all tables, columns, and their types as well as descriptions.
For example:

```sql
-- The records table contains spans and logs.
CREATE TABLE records (
    message TEXT, -- The message of the record
    span_name TEXT, -- The name of the span, message is usually templated from this
    trace_id TEXT, -- The trace ID, identifies a group of spans in a trace
    exception_type TEXT, -- The type of the exception
    exception_message TEXT, -- The message of the exception
    -- other columns...
);
```
The SQL syntax is similar to Postgres, although the query engine is actually Apache DataFusion.

To access nested JSON fields e.g. in the `attributes` column use the `->` and `->>` operators.
You may need to cast the result of these operators e.g. `(attributes->'cost')::float + 10`.

You should apply as much filtering as reasonable to reduce the amount of data queried.
Filters on `start_timestamp`, `service_name`, `span_name`, `metric_name`, `trace_id` are efficient.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 4 tools

    Disambiguation5/5

    Each tool serves a unique purpose: querying, exception viewing, link generation, and schema reference. No overlap or ambiguity.

    Naming Consistency5/5

    All tools use consistent snake_case naming with clear verbs (arbitrary_query, find_exceptions_in_file, logfire_link, schema_reference).

    Tool Count5/5

    With 4 tools, the set is concise and well-scoped for querying and debugging Logfire databases, covering key workflows without bloat.

    Completeness4/5

    The set covers querying, schema exploration, exception analysis, and UI linking. Missing explicit write operations, but that may be by design.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      Not graded
      maintenance
      A Model Context Protocol server that enables AI assistants to interact with Datadog's observability platform through natural language.
      72
      MIT
    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      A Model Context Protocol server that provides access to Observe API functionality, enabling LLMs to execute OPAL queries, manage datasets/monitors, and leverage vector search for documentation and troubleshooting runbooks.
      1
      -
    • A
      license
      A
      quality
      C
      maintenance
      A Model Context Protocol server that enables LLMs to interact with MLflow tracking servers, allowing users to query experiments, analyze runs, compare metrics, manage the model registry, and promote models through natural language.
      40
      338 PyPI
      15
      MIT