Servidor MCP

Servidor MCP de Dcision en https://api.dcision.io/mcp — autenticación, las catorce herramientas con entradas y salidas, errores y configuración para Claude Code, Cursor, VS Code, Claude Desktop, Codex, Gemini CLI y curl.

Endpoint    https://api.dcision.io/mcp
Transport   Streamable HTTP (stateless, JSON responses)
Auth        Authorization: Bearer dcs_live_… | dcs_test_…

El servidor del Model Context Protocol permite que los agentes de IA y los asistentes de programación usen Dcision: listar tus decisiones, leer su contrato, comprobar y ejecutar estados, leer ejecuciones, explorar plantillas y validar esquemas de decisión. Forma parte de la API de Dcision — las mismas claves, los mismos límites y la misma facturación que la API REST.

Para una configuración paso a paso en Claude Code, con la skill de Dcision, consulta Usar Dcision en Claude Code.

Autenticación

Envía una clave de API del workspace como token Bearer en cada solicitud. El servidor no mantiene sesión ni guarda credenciales: cada solicitud se autentica por sí sola, y las herramientas actúan sobre el workspace de la clave.

  • Sin clave, con una clave mal formada o con una clave revocada → HTTP 401, con un header WWW-Authenticate: Bearer y un mensaje que indica dónde crear una clave.
  • Solo se aceptan claves de API — nunca una sesión de la app.
  • Prefiere una clave dcs_test_… mientras experimentas: las ejecuciones son reales y cuentan como uso, pero los destinos entregan con livemode: false.

Límites y facturación

Cada solicitudCuenta en la ventana de rate limit de lectura, compartida con GET /v1/me, GET /v1/decisions y GET /v1/executions. Las lecturas no se facturan.
run_decisionTambién cuenta en la ventana de decisiones, compartida con POST /v1/decisions/{slug}. Se factura como una llamada a la API, con la misma cuota.
SolicitudesSolo POST /mcp. GET /mcp y DELETE /mcp responden 405: no hay sesiones ni stream de server-sent events.
Tamaño del bodyHasta 1 MB, así que validate_schema, create_decision y update_decision aceptan esquemas grandes (los prompts de agentes llegan hasta 32,000 caracteres). El state de check_state y run_decision sigue limitado a 128 KB (INVALID_STATE). Los bodies más grandes responden 413 PAYLOAD_TOO_LARGE.

Herramientas

Cada herramienta devuelve su resultado como JSON — como texto en el content del resultado, y como structuredContent. Las lecturas se anotan con readOnlyHint: true. run_decision, create_decision, update_decision y deploy_decision se anotan como ni de solo lectura ni idempotentes, y deploy_decision también como destructiva (cambia lo que ejecuta producción), para que los clientes puedan preguntar antes de llamarlas.

HerramientaSolo lecturaArgumentosDevuelve
get_accountSí—El workspace de la clave, la clave, el plan y el uso de este período — el body de GET /v1/me.
list_decisionsSí—Las decisiones del workspace con slug, nombre, estado y versión activa — el body de GET /v1/decisions.
get_decisionSíslugEl contrato de una decisión — esquema del estado, preguntas con sus opciones, acciones, acción de fallback y un estado de ejemplo — el body de GET /v1/decisions/{slug}.
check_stateSíslug, state{ "valid": true }, o { "valid": false, "message" } con el motivo por el que una ejecución fallaría con 422 INVALID_STATE. Comprueba el esquema del estado de la versión activa y el límite de tokens propio del estado; no se ejecuta nada. Una ejecución aún puede responder 422 cuando el estado más la pregunta más larga superan el presupuesto de tokens del motor.
run_decisionNo — se facturaslug, state, include_probabilities opcional (boolean)La respuesta de la decisión, tal como la devuelve POST /v1/decisions/{slug}.
list_executionsSídecision (slug), status (success o error), limit (1–100, predeterminado 20), cursor, opcionalesEjecuciones recientes, nunca las entradas — el body de GET /v1/executions.
list_templatesSí—{ "data": [...] } con el id, name, description, category y patterns de cada plantilla.
get_templateSíidEl resumen de la plantilla más su esquema de decisión completo en schema y un sample_state.
validate_schemaSíschema (objeto){ "valid": true, "schema" } con el esquema normalizado — other agregado, valores predeterminados completados — o { "valid": false, "issues": [{ "path", "message" }] }. Las mismas reglas que el editor y la API.
create_decisionNoname (1–80), schema (objeto), slug y description (≤ 500) opcionalesCrea una decisión en borrador. Devuelve la decisión con su slug y status: "draft". Cuenta para el límite de decisiones del plan (PLAN_LIMIT_REACHED).
update_decisionNoslug, schema, name, description opcionalesReemplaza el esquema del borrador y/o renombra la decisión. Lo que se ejecuta no cambia hasta deploy_decision.
deploy_decisionNo — destructivaslugPublica el borrador como una nueva versión: las siguientes ejecuciones la usan.
list_workspacesSíexternal_id, limit (1–100), cursor opcionalesModo socio: tus subespacios con límites y uso — el body de GET /v1/workspaces.
upsert_workspaceNoexternal_id, name, seed_decisions (slugs) y deploy (boolean) opcionalesModo socio: crea el subespacio de un cliente (o lo renombra), opcionalmente copiando en él decisiones desplegadas.

Cada herramienta publica su esquema de entrada exacto en tools/list: consúltalo ahí cuando construyas tu propio cliente.

Actuar en un subespacio

Los socios envían el header Dcision-Workspace: ext:<external_id> (o el id del subespacio) con su propia clave de API: así cada herramienta lee, ejecuta, crea y despliega en el subespacio de ese cliente, y el rate limit sigue siendo el de tu workspace. Un subespacio de otro workspace responde 404 (error JSON-RPC -32004).

claude mcp add --transport http dcision-acme https://api.dcision.io/mcp \
  --header "Authorization: Bearer $DCISION_API_KEY" --header "Dcision-Workspace: ext:acme"

Ejecutar decisiones

El flujo habitual, que la skill de Dcision enseña a los agentes:

  1. list_decisions — elige una decisión cuyo status sea deployed.
  2. get_decision — lee state_schema y parte de example_state.
  3. check_state — corrige el estado hasta que pase; no cuesta nada.
  4. run_decision — ejecútala una vez y luego actúa según action.

run_decision envía el estado como lo hace la API: un objeto, un string o un array, según el tipo de estado de la decisión. No tiene clave de idempotencia: cada llamada que llega al motor se ejecuta y se factura. Si una llamada falla en la red, busca la ejecución con list_executions antes de volver a intentarlo. Para reintentos seguros por construcción, llama a la API REST con un Idempotency-Key.

Escribir decisiones

Un agente puede construir una decisión de principio a fin:

  1. get_template — parte de una plantilla cuando alguna encaje.
  2. validate_schema — corrige el esquema hasta que no tenga problemas.
  3. create_decision — la crea como borrador.
  4. update_decision — itera sobre el borrador; nada cambia en producción.
  5. deploy_decision — publícala. Pregunta al usuario antes de este paso.

Las escrituras se hacen en nombre de la persona que creó la clave de API; una clave sin autor se rechaza (FORBIDDEN). Eliminar o desactivar una decisión, el equipo, los secretos de destinos y la facturación siguen en la app.

Errores

DóndeQué recibes
Error HTTP + JSON-RPC401 sin una clave de API válida (con WWW-Authenticate: Bearer), 429 cuando se agota la ventana de lectura, 405 para cualquier método que no sea POST, 406 sin Accept: application/json, text/event-stream, 400 para un batch JSON-RPC (envía un mensaje por solicitud). El body es un error JSON-RPC cuyo message dice qué hacer. Un body que no es JSON en absoluto recibe el objeto de error 400 INVALID_REQUEST propio de la API.
Resultado de la herramientaisError: true y { "error": { "code", "message", "details" } } como texto, para todo lo que la API respondería con un error — DECISION_NOT_FOUND, DECISION_NOT_DEPLOYED, INVALID_STATE, CREDITS_EXHAUSTED, SPEND_CAP_REACHED, QUOTA_EXCEEDED, RATE_LIMITED en run_decision, errores del motor — y también para una herramienta desconocida (NOT_FOUND) o argumentos no válidos (INVALID_REQUEST, con cada problema en details). Consulta Errores.

Un agente debe leer el message del error — dice qué corregir — y no reintentar un 4xx sin cambios.

Claude Code

claude mcp add --transport http dcision https://api.dcision.io/mcp \
  --header "Authorization: Bearer $DCISION_API_KEY" \
  --scope user

Quita --scope user para agregarlo solo al proyecto actual, o haz commit de un .mcp.json que lea la clave del entorno de cada persona:

.mcp.json
{
  "mcpServers": {
    "dcision": {
      "type": "http",
      "url": "https://api.dcision.io/mcp",
      "headers": { "Authorization": "Bearer ${DCISION_API_KEY}" }
    }
  }
}

Más información en Usar Dcision en Claude Code.

Otros clientes

Cualquier cliente MCP que admita servidores remotos por Streamable HTTP con un header personalizado puede conectarse.

{
  "mcpServers": {
    "dcision": {
      "url": "https://api.dcision.io/mcp",
      "headers": { "Authorization": "Bearer ${env:DCISION_API_KEY}" }
    }
  }
}
  • Cursor — ~/.cursor/mcp.json para todos los proyectos, o .cursor/mcp.json en un repositorio.
  • VS Code — .vscode/mcp.json; VS Code pide la clave una vez y la guarda de forma segura.
  • Claude Desktop — Settings → Developer → Edit Config (claude_desktop_config.json). Claude Desktop se conecta a servidores remotos a través de mcp-remote, un puente de la comunidad que requiere Node.js; el header se pasa mediante una variable de entorno para que el espacio después de Bearer se conserve en todas las plataformas. Reinicia Claude Desktop después de editar.
  • Codex — ~/.codex/config.toml, con DCISION_API_KEY exportada donde se ejecuta Codex.
  • Gemini CLI — ~/.gemini/settings.json o .gemini/settings.json en un proyecto.

ChatGPT y claude.ai

Los conectores de ChatGPT y de claude.ai inician sesión con OAuth, que el servidor MCP de Dcision todavía no ofrece: solo acepta una clave de API en un header. Usa uno de los clientes anteriores, o la API REST.

Llamar al servidor con curl

El servidor habla JSON-RPC 2.0 simple sobre HTTP y no tiene estado — no hace falta el handshake initialize. Envía Content-Type: application/json y Accept: application/json, text/event-stream:

curl -s https://api.dcision.io/mcp \
  -H "Authorization: Bearer $DCISION_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Llama a una herramienta con tools/call, su name y sus arguments:

curl -s https://api.dcision.io/mcp \
  -H "Authorization: Bearer $DCISION_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": { "name": "get_decision", "arguments": { "slug": "lead-qualification" } }
  }' | jq '.result.structuredContent'

La respuesta es una respuesta JSON-RPC: result.content[0].text contiene el JSON de la herramienta como texto y result.structuredContent el mismo valor como objeto (resumido):

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "content": [{ "type": "text", "text": "{\"slug\": \"lead-qualification\", \"status\": \"deployed\", \"version\": 3}" }],
    "structuredContent": { "slug": "lead-qualification", "status": "deployed", "version": 3 }
  }
}

Así es también como la skill de Dcision llega a validate_schema, check_state y las plantillas cuando no hay ningún cliente MCP configurado.

Seguridad

  • El servidor actúa solo sobre el workspace de la clave; una clave no puede llegar a las decisiones de otro workspace.
  • Las herramientas nunca devuelven las entradas de ejecuciones pasadas, secretos, la configuración de los destinos (URLs, headers) ni el esquema completo de una decisión — solo el contrato de su versión activa. Los resultados de run_decision y list_executions sí incluyen las entradas destinations de cada ejecución, que pueden llevar valores mapeados desde el estado (params de funciones, respuestas de LLM o de agentes): trátalos como cualquier salida de una decisión.
  • Trata una clave usada por un agente como cualquier secreto de producción: mantenla en el entorno, limítala a una clave de test mientras experimentas, y revócala en API Keys si se filtra.

En esta página