Skip to main content
Glama

llmprobe

llmprobe

Sondea puntos finales de API de LLM. Mide TTFT, latencia y rendimiento. Binario único, cero SDKs.

CI Go License: MIT llmprobe MCP server

llmprobe es una herramienta de CLI que sondea puntos finales de API de LLM y mide las métricas que importan para la fiabilidad en producción: tiempo hasta el primer token (TTFT), latencia total, rendimiento de generación (tokens/seg) y tasas de error.

Úselo como una comprobación de salud puntual, un monitor continuo o una puerta de CI que bloquee despliegues cuando su proveedor de LLM esté degradado.

demo

Inicio rápido

Descargue un binario precompilado desde la versión más reciente (Linux, macOS, Windows; amd64 y arm64).

O instálelo desde el código fuente:

go install github.com/Jwrede/llmprobe@latest

Cree un probes.yml (o copie el ejemplo incluido):

providers:
  - name: openai
    api_key: ${OPENAI_API_KEY}
    models:
      - name: gpt-4o
        thresholds:
          max_ttft: 2s
      - name: gpt-4o-mini
        thresholds:
          max_ttft: 500ms

  - name: anthropic
    api_key: ${ANTHROPIC_API_KEY}
    models:
      - name: claude-sonnet-4-20250514
        thresholds:
          max_ttft: 1s

Ejecute una sonda:

$ llmprobe probe

Provider   Model                    Status    TTFT    Latency  Tok/s  Tokens  Error
--------   -----                    ------    ----    -------  -----  ------  -----
openai     gpt-4o                   healthy   312ms   2100ms   68.4   42
openai     gpt-4o-mini              healthy   98ms    814ms    112.3  56
anthropic  claude-sonnet-4-20250514 healthy   420ms   2831ms   52.1   38
azure      gpt-4o                   healthy   289ms   1950ms   71.2   44
bedrock    anthropic.claude-3-5...  degraded  1820ms  4510ms   28.1   38

4 healthy, 1 degraded, 0 errors

Related MCP server: LLM API Benchmark MCP Server

Qué mide

Métrica

Qué significa

TTFT

Tiempo desde el envío de la solicitud hasta el primer token de contenido. Esto es lo que los usuarios sienten como "retraso" antes de que la respuesta comience a transmitirse.

Latencia

Tiempo total desde la solicitud hasta el cierre de la transmisión.

Tok/s

Rendimiento de generación: tokens producidos por segundo después del primer token. Calculado como token_count / (latency - ttft).

Tokens

Total de tokens de salida. Prefiere los metadatos de uso del proveedor cuando están disponibles, recurre al conteo de eventos SSE en caso contrario.

Estado

healthy si se superan todos los umbrales, degraded si se excede cualquier umbral, error si la solicitud falló.

Comandos

llmprobe probe

Comprobación de salud puntual. Sondea todos los puntos finales configurados e imprime los resultados.

llmprobe probe                        # table output
llmprobe probe -f json                # JSON output
llmprobe probe --fail-on degraded     # exit 1 if any endpoint is degraded
llmprobe probe -c custom-config.yml   # custom config path

Códigos de salida para CI:

--fail-on

Salida 0

Salida 1

error (predeterminado)

saludable o degradado

cualquier error

degraded

solo saludable

degradado o error

none

siempre

nunca

llmprobe watch

Monitoreo continuo. Sondea todos los puntos finales en un intervalo e imprime una línea de resumen por iteración.

llmprobe watch                          # default 60s interval
llmprobe watch --interval 30s           # custom interval
llmprobe watch --tui                    # live terminal dashboard with TTFT chart
llmprobe watch --tui --load data.jsonl  # load historical data into the dashboard
llmprobe watch -f json                  # JSONL output (one line per result)

La bandera --tui inicia un panel de control de terminal en vivo con un gráfico de TTFT, leyenda de colores y tabla de estadísticas. Use --load para importar datos JSONL históricos (desde llmprobe watch -f json > data.jsonl).

llmprobe

$ llmprobe watch --interval 30s

Watching 4 endpoints every 30s (Ctrl+C to stop)

[14:01:02] All 4 endpoints healthy.
[14:01:32] All 4 endpoints healthy.
[14:02:02] 3 healthy, 1 degraded, 0 errors. DEGRADED: openai/gpt-4o (TTFT 1820ms)
[14:02:32] All 4 endpoints healthy.

Integración con CI

Use llmprobe probe como una puerta de pre-despliegue:

# .github/workflows/deploy.yml
- name: Check LLM providers
  env:
    OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    go install github.com/Jwrede/llmprobe@latest
    llmprobe probe --fail-on degraded

Esto bloquea el despliegue si algún proveedor de LLM está experimentando un rendimiento degradado en este momento.

Servidor MCP

llmprobe MCP server

llmprobe incluye un servidor de Protocolo de Contexto de Modelo integrado, lo que permite a Claude Code y otros hosts MCP verificar la salud de la API de LLM directamente desde un flujo de trabajo de agente.

Ejecución del servidor

llmprobe mcp

Esto inicia el servidor MCP a través de stdio.

Registro con Claude Code

claude mcp add --transport stdio llmprobe -- llmprobe mcp

Una vez registrado, Claude Code puede llamar a las herramientas de llmprobe durante cualquier conversación.

Herramientas disponibles

Herramienta

Descripción

probe_all

Sondea todos los puntos finales configurados desde probes.yml. Devuelve TTFT, latencia, rendimiento y estado de salud para cada modelo. Acepta un parámetro opcional config para una ruta de configuración personalizada.

probe_model

Sondea un solo modelo sin un archivo de configuración. Requiere provider (openai, anthropic, google, azure, bedrock), model (el identificador del modelo) y api_key_env (variable de entorno que contiene la clave API).

list_providers

Enumera todos los proveedores y modelos en el archivo de configuración con sus umbrales. Úselo para descubrir modelos disponibles antes de sondear.

get_config

Devuelve la configuración completa analizada, incluyendo valores predeterminados, proveedores, modelos y umbrales.

Caso de uso de ejemplo: Un agente llama a list_providers para ver qué modelos están configurados, luego a probe_all para verificar que estén saludables antes de desplegar cambios.

Configuración

defaults:
  prompt: "Hello"                                # probe prompt
  max_tokens: 20                                 # max output tokens
  timeout: 30s                                   # per-probe timeout
  concurrency: 5                                 # max parallel probes

providers:
  - name: openai                    # openai, anthropic, google, azure, bedrock
    api_key: ${OPENAI_API_KEY}      # env var expansion
    base_url: https://custom.api    # optional, override endpoint
    models:
      - name: gpt-4o
        prompt: "Say hello."        # override default prompt
        max_tokens: 10              # override default max_tokens
        thresholds:
          max_ttft: 2s              # alert if TTFT exceeds this
          max_latency: 10s          # alert if total latency exceeds this
          min_tokens_per_sec: 20    # alert if throughput drops below this

  - name: azure
    api_key: ${AZURE_OPENAI_API_KEY}
    base_url: https://your-resource.openai.azure.com
    api_version: "2024-10-21"       # optional, defaults to 2024-10-21
    models:
      - name: gpt-4o               # deployment name

  - name: bedrock
    access_key: ${AWS_ACCESS_KEY_ID}
    secret_key: ${AWS_SECRET_ACCESS_KEY}
    region: us-east-1
    models:
      - name: anthropic.claude-3-5-sonnet-20241022-v2:0

Las claves API y las credenciales de AWS admiten la sintaxis ${ENV_VAR}. Solo se expanden los campos de credenciales, por lo que las referencias a variables de entorno en prompts o nombres de modelos se dejan tal cual.

Proveedores compatibles con OpenAI

Muchos proveedores (Groq, Together AI, Fireworks, DeepSeek, Mistral, OpenRouter, Ollama, vLLM) exponen una API compatible con OpenAI. Estos funcionan de inmediato configurando base_url:

providers:
  # Groq
  - name: openai
    api_key: ${GROQ_API_KEY}
    base_url: https://api.groq.com/openai
    models:
      - name: llama-3.3-70b-versatile

  # DeepSeek
  - name: openai
    api_key: ${DEEPSEEK_API_KEY}
    base_url: https://api.deepseek.com
    models:
      - name: deepseek-chat

  # Together AI
  - name: openai
    api_key: ${TOGETHER_API_KEY}
    base_url: https://api.together.xyz
    models:
      - name: meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo

  # Local Ollama
  - name: openai
    api_key: unused
    base_url: http://localhost:11434/v1
    models:
      - name: llama3.2

Arquitectura

probes.yml
  -> Config loader (YAML + env var expansion)
    -> Probe engine (concurrent goroutines per provider/model)
      -> Provider clients (raw HTTP + SSE parsing, no SDKs)
        -> Results (TTFT, latency, tokens/sec, status)
          -> Output (table, JSON, JSONL)

Cada cliente de proveedor es un envoltorio HTTP ligero que envía una solicitud de transmisión y analiza la respuesta. No se importan SDKs de LLM. El analizador SSE maneja tanto eventos de solo datos (OpenAI, Google) como eventos con nombre (Anthropic). El cliente de Bedrock implementa la firma SigV4 y el análisis de flujo de eventos binarios de AWS desde cero.

El TTFT se mide desde el momento en que se envía la solicitud HTTP hasta el primer evento que contiene texto de contenido real (no asignaciones de roles o metadatos).

Proveedores

Proveedor

Punto final

Autenticación

Formato de transmisión

OpenAI

/v1/chat/completions

Authorization: Bearer

SSE, centinela [DONE]

Anthropic

/v1/messages

encabezado x-api-key

SSE de evento con nombre

Google

/v1beta/models/{model}:streamGenerateContent?alt=sse

parámetro de consulta key

SSE

Azure OpenAI

/openai/deployments/{model}/chat/completions

encabezado api-key

SSE, centinela [DONE]

AWS Bedrock

/model/{model}/converse-stream

SigV4

Flujo de eventos binarios de AWS

OpenAI-compat

/v1/chat/completions (base_url personalizada)

Authorization: Bearer

SSE

La compatibilidad con OpenAI cubre: Groq, Together AI, Fireworks, DeepSeek, Mistral, OpenRouter, Ollama, vLLM y cualquier punto final que hable la API de chat completions de OpenAI.

Benchmark en vivo

llm-bench utiliza llmprobe para ejecutar un benchmark público continuo de las principales APIs de LLM. Los resultados se publican como un conjunto de datos JSONL abierto y un panel de control de terminal en vivo en bench.jonathanwrede.de.

Hoja de ruta

  • Seguimiento de línea base: almacenar percentiles móviles, alertar cuando la sonda actual exceda la línea base Nx

  • Exportación de métricas de OpenTelemetry para integración con Grafana/Datadog

  • Punto final /metrics de Prometheus

  • Validación de salida estructurada: verificar que las respuestas en modo JSON se analicen correctamente

Licencia

MIT

Available Tools

4 tools
get_configA

Return the full parsed configuration including defaults, providers, models, and thresholds. Useful for understanding the current probe setup or debugging configuration issues.

Inputs: config.

list_providersA

List all providers and models defined in the config file. Returns provider names, model identifiers, and any configured thresholds. Use this to discover what models are available before probing.

Inputs: config.

probe_allA

Probe all configured LLM API endpoints. Returns TTFT (ms), total latency (ms), throughput (tokens/sec), and health status for every model in the config file.

Inputs: config.

probe_modelA

Probe a single LLM model by provider and model name. Use this for ad-hoc checks without a config file. Returns TTFT (ms), total latency (ms), throughput (tokens/sec), and health status.

Inputs: provider (required), model (required), api_key_env (required), base_url, +1 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 4 tools

    Disambiguation5/5

    Each tool has a distinct purpose: configuration retrieval, provider listing, bulk probing, and single model probing. No overlap.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern (get_config, list_providers, probe_all, probe_model) with appropriate verbs.

    Tool Count5/5

    4 tools is well-scoped for the LLM probing domain, covering necessary operations without bloat.

    Completeness5/5

    The tool set covers all essential probe operations: viewing config, listing providers, probing all endpoints, and probing a single endpoint, with no obvious gaps.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers