Fable MCP

mcp-server-fable

Un servidor MCP (Model Context Protocol) para Anthropic Claude Fable 5 — el modelo más capaz y más caro de Anthropic ($10 / $50 por 1M de tokens de entrada / salida, ~2× Opus). Construido en Rust, expone Fable como herramientas MCP especializadas (plan, critique, ask) para que cualquier cliente MCP pueda usarlas.

Fable no es un modelo de chat de uso diario aquí. Este servidor está construido para la única cosa que justifica el precio: usar Fable para planificar y criticar, y luego entregar el resultado a un modelo más barato (Sonnet / Haiku / Opus) para que lo ejecute. Funciona en Claude Code, Claude Desktop, Cursor, agentes personalizados y cualquier otro entorno que admita servidores MCP sobre stdio.

Se comunica mediante stdio usando JSON-RPC 2.0. Estructuralmente refleja mcp-server-claude-chat, pero está deliberadamente adaptado a la superficie de la API de Fable y diseñado específicamente para el patrón planificar-luego-ejecutar.

Por qué mcp-server-fable (vs. el asesor integrado de Claude Code)?

Claude Code tiene una potente función de asesor nativa (/advisor fable o la herramienta advisor). Permite que un modelo ejecutor rápido (normalmente Sonnet o Haiku) consulte dinámicamente a Fable para obtener orientación sobre decisiones difíciles dentro de una misma sesión.

Este servidor MCP adopta un enfoque complementario que resulta útil en más situaciones:

• Herramientas explícitas con prompts optimizados para traspaso — plan y critique usan prompts de sistema fijos y cuidadosamente redactados, diseñados para que la salida pueda pasarse literalmente a un modelo más barato. Los planes están numerados, son inequívocos, incluyen rutas/firmas exactas, casos límite, criterios de aceptación y notas sobre lo que queda fuera de alcance. Las críticas están deliberadamente orientadas a la cobertura (informar de todo; filtrar posteriormente).
• Funciona en cualquier lugar donde funcione MCP — No se limita a Claude Code. Úsalo en Claude Desktop, Cursor, Windsurf, frameworks de agentes personalizados, extensiones MCP de VS Code, scripts o cualquier herramienta futura que admita el Model Context Protocol.
• Tú controlas la orquestación — Llama a Fable para planificar o revisar exactamente cuando tú (o tu sistema multiagente) lo decidas, en lugar de depender de que el modelo escale.
• Componibilidad limpia — Trata a Fable como un servicio especialista reutilizable junto a tus otros servidores MCP. Perfecto para flujos de trabajo modernos de "modelo caro para el juicio, modelo barato para la ejecución".
• Comportamiento correcto específico de Fable — Niveles de effort adecuados, manejo de rechazos (sin fallback silencioso), tiempos de espera largos y reporte preciso del costo por llamada a las tarifas de Fable.

Muchos equipos están convergiendo en el mismo patrón que descubrió la comunidad: usar Fable de forma limitada para arquitectura, planificación y revisión, y luego ejecutar con modelos más baratos. Este servidor te ofrece herramientas portátiles de primera clase para las "partes de Fable" de ese patrón.

Consulta la sección "Detalles técnicos" más abajo para conocer las diferencias específicas de la API de Fable que también requirieron una implementación dedicada.

Suscripción vs. créditos de API

Este servidor usa la API de Anthropic con una clave de API (créditos de API) — la única forma admitida y conforme a los términos de uso para impulsar Claude desde una herramienta de terceros. Una suscripción a Claude Pro/Max no es utilizable aquí. Apunta base_url a una puerta de enlace compatible con Anthropic si tienes una.

Detalles técnicos: diferencias de la API de Fable

La API de Messages de Fable difiere de la forma de la era Opus (esta es la razón por la que se necesitó un servidor dedicado en lugar de reutilizar un wrapper general de chat de Claude):

• Sin parámetros de muestreo — temperature / top_p / top_k se rechazan con un 400. No existe el argumento de herramienta temperature.
• Solo pensamiento adaptativo — el razonamiento siempre está activo; la profundidad se controla mediante effort (low / medium / high / xhigh / max), no con un presupuesto de tokens. La cadena de pensamiento cruda nunca se devuelve; ask puede solicitar un resumen legible mediante show_reasoning.
• Los rechazos se detienen limpiamente — este es un servidor dedicado a Fable. Los clasificadores de seguridad de Fable (cibernético / biológico / destilación de modelos) pueden rechazar una solicitud; eso regresa como una respuesta exitosa con stop_reason: "refusal", mostrada con su categoría y explicación en lugar de como una respuesta. Nunca se reintenta silenciosamente en un modelo diferente.
• Retención de datos de 30 días requerida — Fable no está disponible para organizaciones con retención de datos cero; dichas organizaciones reciben un 400 en cada solicitud.

Cada respuesta también imprime un costo estimado en USD (a las tarifas oficiales de Fable), ya que la conciencia del costo es el punto central.

Herramientas

Herramienta	Descripción
plan	Insignia. Convierte un objetivo (+ contexto opcional) en un plan de implementación listo para el ejecutor: pasos numerados, rutas/firmas exactas, casos límite, criterios de aceptación, notas sobre lo que queda fuera de alcance — redactado para entregarse a un modelo más barato y ejecutarse literalmente.
critique	Revisión orientada a la cobertura de código, un diff o un diseño. Informa de cada hallazgo con severidad + confianza para el filtrado posterior. focus opcional.
ask	Consulta única sin procesar a Fable. Historial multiturno, prompt de sistema, esfuerzo, resumen de razonamiento opcional.

plan

Nombre	Tipo	Requerido	Descripción
goal	string	sí	Qué construir o corregir
context	string	no	Código relevante, árbol de archivos, restricciones, salida de errores, intentos previos
effort	string	no	low/medium/high/xhigh/max (predeterminado high)
max_tokens	integer	no	Máximo de tokens a generar (predeterminado del servidor en caso contrario)

critique

Nombre	Tipo	Requerido	Descripción
content	string	sí	Código, diff o diseño a revisar
focus	string	no	Área a ponderar, p. ej. security, concurrency
effort	string	no	low/medium/high/xhigh/max (predeterminado high)
max_tokens	integer	no	Máximo de tokens a generar

ask

Nombre	Tipo	Requerido	Descripción
prompt	string	sí	El mensaje del usuario
system_prompt	string	no	Prompt de sistema
messages	string	no	Historial como un array JSON de {role, content} (solo roles user/assistant)
effort	string	no	low/medium/high/xhigh/max (predeterminado medium)
max_tokens	integer	no	Máximo de tokens a generar
show_reasoning	boolean	no	Devolver un resumen del razonamiento de Fable en un bloque [thinking]

Requisitos previos

• Rust (edición 2024)
• Una clave de API de Anthropic desde console.anthropic.com, en una organización con retención de datos ≥30 días

El servidor espera un archivo de configuración en ~/.config/mcp-server-fable/config.toml que contenga como mínimo tu api_key. Consulta config.toml.example.

api_key = "sk-ant-..."

# Optional overrides:
# base_url = "https://api.anthropic.com/v1"
# default_model = "claude-fable-5"
# default_max_tokens = 8192
# default_effort = "high"   # low | medium | high | xhigh | max

El servidor falla rápidamente al inicio si falta la configuración, api_key está vacío o default_effort (si se establece) no es válido.

Compilación

cargo build --release   # produces target/release/fable
cargo build             # debug build
cargo run               # run in dev mode
RUST_LOG=debug cargo run
cargo test              # unit tests (response formatting, cost, refusal, effort, message building)

Instalación y configuración de MCP

1. Compilar el servidor

cargo build --release
# The binary will be at: target/release/fable

Usa la ruta absoluta completa a target/release/fable en toda la configuración siguiente.

2. Instalación asistida por IA (método moderno recomendado)

Copia el bloque siguiente y pégalo directamente en tu asistente de codificación con IA (Claude Code, Cursor, Grok, etc.). La IA se encargará de clonar (si es necesario), compilar, resolver rutas y registrarlo por ti.

Add the mcp-server-fable MCP server for me.

Repository: https://github.com/<your-username>/mcp-server-fable   (update this URL if you have a fork)

Steps to perform:
1. If the repo isn't cloned locally yet, clone it and cd into it.
2. Build the release binary:
     cargo build --release
3. Determine the absolute path to the built binary (target/release/fable).
4. Set up the config directory and file:
     mkdir -p ~/.config/mcp-server-fable
     cp config.toml.example ~/.config/mcp-server-fable/config.toml
   Then edit the config and add your Anthropic API key (api_key = "sk-ant-...").

5. Register it as an MCP server named "fable".

   For Claude Code, run:
     claude mcp add fable -- <ABSOLUTE_PATH_TO>/target/release/fable

   For Claude Desktop or other MCP clients, add this under the "mcpServers" key (use the real absolute path):
{
  "fable": {
    "command": "<ABSOLUTE_PATH_TO>/target/release/fable"
  }
}

After setup, test that the `plan` tool is available and working.

3. Configuración manual

Claude Desktop o cualquier cliente MCP (~/.config/Claude/claude_desktop_config.json o equivalente):

{
  "mcpServers": {
    "fable": {
      "command": "/absolute/path/to/mcp-server-fable/target/release/fable"
    }
  }
}

Claude Code (una línea):

claude mcp add fable -- /absolute/path/to/mcp-server-fable/target/release/fable

Reemplaza la ruta con tu ruta absoluta real al binario de la versión.

Uso

Una vez registrado, un cliente MCP llama a las herramientas por nombre — la insignia es plan.

Desde un cliente MCP (p. ej. Claude Code)

Pídele al modelo que lo use, entregándole el objetivo más todo el contexto que el ejecutor necesitará:

Usa la herramienta plan de fable. goal: "Añade un flag --json al CLI que imprima los resultados como JSON". context: "Aplicación Rust clap; la salida actualmente pasa por println! en src/main.rs". effort: high

Claude Code emite una tools/call para plan; Fable devuelve un plan numerado y listo para el ejecutor — rutas exactas, firmas, casos límite, criterios de aceptación — que luego entregas a un modelo más barato (Sonnet / Haiku) para que lo implemente literalmente.

JSON-RPC crudo sobre stdio

La misma llamada sin un cliente — una solicitud tools/call que el servidor lee en stdin:

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
  "name":"plan",
  "arguments":{
    "goal":"Add a --json flag to the CLI that prints results as JSON",
    "context":"Rust clap app; output currently via println! in src/main.rs",
    "effort":"high"
  }}}

plan y critique devuelven su contenido seguido de un pie de página con token + costo estimado. Aquí tienes una respuesta real (de una sonda ask diminuta) que muestra ese pie de página:

BINARY-OK
[stop_reason: end_turn]
[tokens: 21 input + 9 output = 30 total]
[cost: ≈ $0.0007 (fable rates)]

Debido a que el servidor solo llama a Fable, esa línea de costo siempre está a las tarifas de Fable de $10 / $50 por 1M — precisa por construcción, no por convención.

Estructura del proyecto

src/
  main.rs    - entry point, config loading, stdio transport setup
  server.rs  - MCP tool definitions (plan, critique, ask) + fixed prompts
  api.rs     - Anthropic HTTP client, Effort enum, Messages types, refusal/cost formatter
  params.rs  - tool parameter types with serde + JSON Schema derives
  config.rs  - TOML config loading + effort validation

Licencia

MIT