Configuración de clientes

Todos los clientes MCP arrancan o alcanzan el mismo servidor. Lo que cambia de uno a otro es el fichero que leen, la clave bajo la que guardan los servidores, cómo pasan variables de entorno y cabeceras, y si pueden hacerle una pregunta al usuario en mitad de una llamada. Esta página recoge la entrada de cada cliente para cada una de las tres formas de ejecutar arcane-mcp. Puesta en marcha te lleva desde la clave de API de Arcane hasta la primera petición; todos los ajustes que se mencionan aquí están en Configuración.

Tres formas de ejecutarlo

Forma	Qué hace el cliente	Dónde está la credencial de Arcane
Binario por stdio	Arranca `arcane-mcp` como proceso hijo y habla MCP por su entrada y su salida estándar	`ARCANE_URL` y `ARCANE_API_KEY` en el entorno de la entrada (o en un fichero `.env` en el directorio de trabajo del servidor)
Docker por stdio	Arranca `docker run -i --rm … ghcr.io/jmrplens/arcane-mcp:latest` como ese proceso hijo	Las mismas variables, que se pasan al contenedor con `-e`
Streamable HTTP remoto	Envía cada petición a un servidor arrancado con `--http` (o `ARCANE_MCP_HTTP_ADDR`), en `/mcp`	`Authorization: Bearer <ARCANE_MCP_HTTP_TOKEN>` y, por usuario, `X-Arcane-API-Key: <clave de Arcane>` en cada petición; con un servidor en modo `apikey`, solo `Authorization: Bearer <clave de Arcane>`

Antes de elegir una entrada:

El binario sale de cualquiera de los canales de Instalación (el binario de la versión, Homebrew, winget, npm, PyPI, NuGet, go install) o de una compilación como la de Puesta en marcha. Indica a los clientes su ruta absoluta: las aplicaciones de escritorio no heredan el PATH de tu shell. Con npx, uvx o dnx, la orden y los argumentos están en la página de ese canal y el entorno de abajo es el mismo.
La imagen Docker es ghcr.io/jmrplens/arcane-mcp, que el flujo de publicación sube para linux/amd64 y linux/arm64 con cada etiqueta de versión (X.Y.Z, X.Y y latest; consulta Docker); fija una etiqueta de versión siempre que puedas. Sirve stdio salvo que se defina ARCANE_MCP_HTTP_ADDR. En una entrada stdio:
- mantén -i (el protocolo viaja por la entrada estándar) y no añadas nunca -t ni -d;
- -e NOMBRE sin valor reenvía esa variable desde el entorno con el que el cliente arranca docker, de modo que el bloque env de la entrada lleva los valores y los argumentos solo los nombres. Cada ajuste adicional (ARCANE_MCP_TOOL_SURFACE, ARCANE_MCP_READ_ONLY…) necesita su propio -e NOMBRE y además un valor en env;
- ARCANE_URL tiene que ser accesible desde dentro del contenedor. Allí localhost es el propio contenedor: usa el nombre del equipo en la red local, host.docker.internal (Docker Desktop) o --network host (Linux);
- el contenedor no ve un fichero .env de tu directorio de trabajo.
Una entrada HTTP necesita un servidor ya en marcha en modo HTTP, por ejemplo:
Ventana de terminal
```
export ARCANE_MCP_HTTP_TOKEN=$(openssl rand -hex 32)
docker run -d --name arcane-mcp -p 127.0.0.1:8080:8080 \
  -e ARCANE_URL=https://arcane.example.com \
  -e ARCANE_MCP_HTTP_ADDR=:8080 \
  -e ARCANE_MCP_HTTP_ALLOW_PLAINTEXT=true \
  -e ARCANE_MCP_HTTP_TOKEN \
  ghcr.io/jmrplens/arcane-mcp:latest
```
o ./arcane-mcp --http 127.0.0.1:8080 con las mismas variables. Los ejemplos de abajo usan https://arcane-mcp.example.com/mcp, un proxy inverso que termina TLS delante de ese puerto; el servidor en sí habla HTTP sin cifrar, y ARCANE_MCP_HTTP_ALLOW_PLAINTEXT=true lo declara: dentro del contenedor escucha en todas las interfaces, el puerto se publica solo en el loopback del anfitrión y sin la variable registra un aviso al arrancar (consulta HTTP sin cifrar y el modo endurecido). Define ARCANE_MCP_HTTP_ALLOWED_HOSTS=arcane-mcp.example.com cuando el proxy reenvíe ese nombre público: con un listener de loopback, el servidor solo responde a valores de Host de loopback. Cada usuario envía su propia clave de Arcane en X-Arcane-API-Key y actúa con sus permisos; sin esa cabecera, el servidor recurre a su propia ARCANE_API_KEY (o a su usuario y contraseña) y rechaza la petición si no tiene ninguna. Una sesión queda ligada a la clave con la que se abrió, así que el cliente debe enviar las mismas cabeceras en todas las peticiones, cosa que hacen todos los clientes de esta página. Modo HTTP explica los límites, los hosts permitidos y los avisos de arranque.
Un servidor en modo apikey (ARCANE_MCP_HTTP_AUTH=apikey, consulta Autenticación HTTP) necesita un único secreto por usuario: pon la clave de API de Arcane del usuario donde las entradas de abajo ponen el token (Authorization: Bearer <clave de Arcane>) y quita X-Arcane-API-Key. Encaja con los clientes que solo pueden poner Authorization. Un conector cuyas cabeceras comparte una organización (consulta Claude Desktop más abajo) comparte entonces los permisos de Arcane de esa clave con todos.
No pongas secretos en la línea de comandos. ARCANE_MCP_HTTP_TOKEN y ARCANE_API_KEY no tienen opción a propósito. Cuando un cliente puede pedir un valor o expandir una variable de entorno, su entrada lo aprovecha; en los demás el valor queda en el fichero de configuración del cliente, así que protege ese fichero.

Qué admite cada cliente

Cliente	Configuración	stdio	Streamable HTTP	Elicitación	Notas
Claude Desktop	`claude_desktop_config.json`, `mcpServers`	Sí	Solo como conector personalizado (HTTPS público)	No documentada	Los conectores remotos se alcanzan desde la nube de Anthropic, no desde tu equipo
Claude Code	`claude mcp add`, o `.mcp.json` con `mcpServers`	Sí	Sí	Sí	Expande `${VAR}` en `.mcp.json`
VS Code (GitHub Copilot)	`.vscode/mcp.json` con `servers`, o `.mcp.json` con `mcpServers`	Sí	Sí	Sí (desde la 1.102)	Como mucho 128 herramientas por petición de chat
Cursor	`.cursor/mcp.json` o `~/.cursor/mcp.json`, `mcpServers`	Sí	Sí	Sí	Expande `${env:NOMBRE}`
Windsurf (Devin Desktop)	`mcp_config.json`, `mcpServers`	Sí	Sí	No documentada	Pasó a llamarse Devin Desktop en 2026; la ubicación del fichero está en su sección
Zed	`settings.json`, `context_servers`	Sí	Sí	No	Zed solo documenta herramientas y prompts
Cline	`cline_mcp_settings.json`, `mcpServers`	Sí	Sí (`"type": "streamableHttp"`)	No documentada	Sin `type`, una entrada remota se trata como SSE heredado
Continue	`config.yaml` o `.continue/mcpServers/*.yaml`, lista `mcpServers`	Sí	Sí (`type: streamable-http`)	No documentada	Secretos con `${{ secrets.NOMBRE }}`
LM Studio	`mcp.json`, `mcpServers` (la notación de Cursor)	Sí	Sí	No documentada
Kiro	`.kiro/settings/mcp.json` o `~/.kiro/settings/mcp.json`, `mcpServers`	Sí	Sí	Sí	`${VAR}` solo tras aprobar la variable
Gemini CLI	`~/.gemini/settings.json` o `.gemini/settings.json`, `mcpServers`	Sí	Sí (`httpUrl`)	No documentada	Elimina las variables con aspecto de secreto que no figuren en `env`
OpenAI Codex CLI	`~/.codex/config.toml`, `[mcp_servers.<nombre>]`	Sí	Sí	Sí	TOML, no JSON
JetBrains AI Assistant	Diálogo de ajustes, JSON con `mcpServers`	Sí	Solo URL, sin cabeceras documentadas	No documentada	Para un servidor protegido con token, usa mcp-remote
Goose	`~/.config/goose/config.yaml`, `extensions`	Sí	Sí (`type: streamable_http`)	Sí (modo formulario)

Los datos de los clientes de esta página se comprobaron con la documentación de cada cliente en octubre de 2026; los clientes cambian deprisa, así que, si una entrada deja de funcionar, compárala primero con la documentación actual del cliente.

Qué cambia la elicitación

Las acciones destructivas (borrados, purgas, kills, restauraciones, redespliegues…) nunca se ejecutan sin aprobación. En un cliente que admite la elicitación MCP, una llamada destructiva sin confirm: true hace que el servidor pregunte directamente al usuario en la interfaz del propio cliente; en los demás, la llamada se rechaza con un mensaje que indica al modelo que pregunte al usuario y la repita con confirm: true. «No documentada» significa que la documentación del cliente no dice nada al respecto: arcane-mcp lee la capacidad que el cliente declara al conectarse, así que no hay nada que configurar, y un cliente sin ella recibe el rechazo. Consulta Confirmación de las acciones destructivas; ARCANE_MCP_ELICITATION=off desactiva la pregunta para todos los clientes.

Qué superficie para cada cliente

ARCANE_MCP_TOOL_SURFACE (o --tool-surface) decide cuántas herramientas ve el cliente; con cualquier superficie se llega a las 461 acciones. Consulta Superficies de herramientas.

dynamic (la predeterminada, 2 herramientas, unos 400 tokens) sirve para cualquier cliente y es la que conviene mantener en los que limitan el número de herramientas o tienen una ventana de contexto pequeña: VS Code acepta como mucho 128 herramientas por petición de chat, y los modelos locales de LM Studio o Goose pagan en su contexto cada definición de herramienta.
meta (52 herramientas, unos 16 k tokens) cabe dentro de esos límites y permite al modelo leer todos los nombres de acción de antemano.
individual (461 herramientas, unos 111 k tokens) supera el límite de VS Code y resulta pesada para la mayoría de clientes; úsala con exclusiones (ARCANE_MCP_EXCLUDE_TOOLS) cuando quieras aprobaciones o listas de permitidos por herramienta en el cliente.

Varios clientes filtran además herramientas por su cuenta (enabled_tools en Codex, includeTools en Gemini CLI, available_tools en Goose, interruptores por herramienta en Kiro y Windsurf); ARCANE_MCP_EXCLUDE_TOOLS hace lo mismo en el servidor, para todos los clientes a la vez.

Interruptores de seguridad en una entrada

Añádelos al bloque env de la entrada (y, en la forma Docker, el -e NOMBRE correspondiente), o como opciones en args para el binario:

Ajuste	Opción	Efecto
`ARCANE_MCP_READ_ONLY=true`	`--read-only`	Solo existen las acciones de lectura; nada puede cambiar Arcane
`ARCANE_MCP_SAFE_MODE=true`	`--safe-mode`	Las llamadas que modifican devuelven una vista previa de la petición exacta en lugar de ejecutarse
`ARCANE_MCP_EXCLUDE_TOOLS=swarm_node,image.prune`	`--exclude-tools`	Oculta dominios, acciones o nombres de herramienta
`ARCANE_MCP_TOOL_SURFACE=meta`	`--tool-surface meta`	Elige la superficie

En modo HTTP se definen donde corre el servidor, no en la entrada del cliente, y se aplican a todos los usuarios de ese despliegue. Seguridad explica cada uno.

Claude Desktop

La extensión de Claude Desktop instala el servidor desde un único fichero .mcpb con un formulario de ajustes, sin editar JSON. Las entradas de abajo son para usarlo sin la extensión.

Abre Settings → Developer → Edit Config, que abre (y crea) claude_desktop_config.json: en ~/Library/Application Support/Claude/ en macOS, %APPDATA%\Claude\ en Windows y ~/.config/Claude/ en Linux. Cierra Claude Desktop por completo y vuelve a abrirlo después de editar; solo carga los servidores al arrancar.

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

Claude Desktop no hereda el PATH de tu shell; si no encuentra docker, indica su ruta absoluta (which docker).

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

claude_desktop_config.json solo arranca procesos locales. Un servidor remoto se añade como conector personalizado (Customize → Connectors → + Add → Add custom connector): indica un nombre y https://arcane-mcp.example.com/mcp, elige No sign in en Authentication y, en Request headers, añade Authorization con Bearer <ARCANE_MCP_HTTP_TOKEN> y X-Arcane-API-Key con tu clave de Arcane.

Claude se conecta a los conectores personalizados desde la nube de Anthropic, no desde tu equipo, así que la URL tiene que ser HTTPS pública; una dirección de loopback o privada no puede funcionar. En los planes Team y Enterprise, un conector que añade un propietario comparte sus cabeceras con todos los miembros, de modo que una X-Arcane-API-Key allí da a todos los permisos de esa clave en Arcane. Para un servidor al que solo llega tu red, usa mcp-remote como entrada stdio.

Claude Code

Claude Code guarda por defecto el servidor en ~/.claude.json para el proyecto actual; --scope user lo deja disponible en todos los proyectos y --scope project lo escribe en .mcp.json, en el repositorio. En .mcp.json expande ${VAR} y ${VAR:-predeterminado} en command, args, env, url y headers, lo que mantiene las claves fuera de un fichero compartido.

claude mcp add arcane \
  --env ARCANE_URL=https://arcane.example.com \
  --env ARCANE_API_KEY=arc_... \
  -- /ruta/a/arcane-mcp

--env deja la clave en el historial de la shell. Para evitarlo, escribe la entrada en .mcp.json y exporta ARCANE_API_KEY en la shell desde la que arrancas claude:

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${ARCANE_API_KEY}"
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${ARCANE_API_KEY}"
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "type": "http",
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${ARCANE_MCP_HTTP_TOKEN}",
        "X-Arcane-API-Key": "${ARCANE_API_KEY}"
      }
    }
  }
}

claude mcp add --transport http arcane https://arcane-mcp.example.com/mcp --header "Authorization: Bearer …" --header "X-Arcane-API-Key: …" escribe la misma entrada, con los valores en la línea de comandos.

VS Code (GitHub Copilot)

VS Code lee .vscode/mcp.json en el espacio de trabajo, o el mcp.json de tu perfil de usuario (MCP: Open User Configuration), y guarda los servidores bajo servers. Ese formato admite inputs: un input con "password": true pide la clave una vez y la guarda, de modo que nunca acaba en el fichero. VS Code también lee un formato portable, .mcp.json en la raíz del espacio de trabajo o ~/.copilot/mcp-config.json, con los servidores bajo mcpServers, que comparten otras herramientas de Copilot pero que no admite inputs.

{
  "inputs": [
    { "type": "promptString", "id": "arcane-api-key", "description": "Clave de API de Arcane", "password": true }
  ],
  "servers": {
    "arcane": {
      "type": "stdio",
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${input:arcane-api-key}"
      }
    }
  }
}

{
  "inputs": [
    { "type": "promptString", "id": "arcane-api-key", "description": "Clave de API de Arcane", "password": true }
  ],
  "servers": {
    "arcane": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${input:arcane-api-key}"
      }
    }
  }
}

{
  "inputs": [
    { "type": "promptString", "id": "arcane-mcp-token", "description": "Token HTTP de arcane-mcp", "password": true },
    { "type": "promptString", "id": "arcane-api-key", "description": "Clave de API de Arcane", "password": true }
  ],
  "servers": {
    "arcane": {
      "type": "http",
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:arcane-mcp-token}",
        "X-Arcane-API-Key": "${input:arcane-api-key}"
      }
    }
  }
}

Una petición de chat lleva como mucho 128 herramientas, contando las de todos los servidores y las integradas, así que aquí conviene dynamic o meta (consulta Qué superficie para cada cliente). Las sesiones de Copilot que ejecuta el Agent Host no reciben los servidores que necesitan un ${input:…}; para ellas, usa el formato portable .mcp.json.

Cursor

Cursor lee .cursor/mcp.json en el proyecto, o ~/.cursor/mcp.json para todos los proyectos. Expande ${env:NOMBRE} (y ${userHome}, ${workspaceFolder}) en command, args, env, url y headers, así que las entradas de abajo leen los secretos del entorno desde el que arranca Cursor.

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${env:ARCANE_API_KEY}"
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${env:ARCANE_API_KEY}"
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:ARCANE_MCP_HTTP_TOKEN}",
        "X-Arcane-API-Key": "${env:ARCANE_API_KEY}"
      }
    }
  }
}

Windsurf (Devin Desktop)

Windsurf pasó a llamarse Devin Desktop en junio de 2026. La acción Open MCP config file de su agente Cascade abre ~/.config/devin/mcp_config.json (%APPDATA%\devin\mcp_config.json en Windows), el mismo fichero de usuario que leen el agente Devin Local y la CLI de Devin; las versiones anteriores al cambio de nombre leen ~/.codeium/windsurf/mcp_config.json. Usa el fichero que abra esa acción en tu instalación. Los servidores van bajo mcpServers. Un servidor remoto lleva url (Cascade acepta también serverUrl, la clave que documentaban las versiones antiguas de Windsurf). Pulsa el botón de recargar del panel MCP después de editar.

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:ARCANE_MCP_HTTP_TOKEN}",
        "X-Arcane-API-Key": "${env:ARCANE_API_KEY}"
      }
    }
  }
}

Cascade expande ${env:NOMBRE} en command, args, env, serverUrl, url y headers. La documentación de la CLI de Devin describe esa expansión solo para sus campos de OAuth; si allí una cabecera llega sin expandir, escribe el valor, mejor en .devin/mcp_config.local.json, que Git ignora.

En los planes Teams y Enterprise puede que un administrador tenga que activar MCP, y en cuanto se permite un solo servidor en la lista, todos los demás quedan bloqueados.

Zed

Zed guarda los servidores bajo context_servers en su settings.json (zed: open settings file; ~/.config/zed/settings.json en macOS y Linux), o en .zed/settings.json dentro de un proyecto. No documenta la expansión de variables de entorno en estas entradas, así que los valores se escriben en el fichero.

{
  "context_servers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "args": [],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

{
  "context_servers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

{
  "context_servers": {
    "arcane": {
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer change-me",
        "X-Arcane-API-Key": "arc_..."
      }
    }
  }
}

Mantén la cabecera Authorization: una entrada remota sin ella hace que Zed inicie el flujo OAuth de MCP, que arcane-mcp no ofrece, así que para Zed arranca el servidor con ARCANE_MCP_HTTP_TOKEN.

Zed documenta que admite herramientas y prompts de MCP, no la elicitación, así que allí las llamadas destructivas necesitan confirm: true.

Cline

En el panel de Cline, selecciona el icono MCP Servers, abre la pestaña Configure y elige Configure MCP Servers; eso abre cline_mcp_settings.json, esté donde esté en tu instalación. Cline añade sus propias claves disabled y autoApprove; deja autoApprove vacía o limitada a herramientas de lectura.

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Indica "type": "streamableHttp" de forma explícita: sin ese campo, Cline trata una entrada remota como el transporte SSE heredado, que arcane-mcp no sirve.

{
  "mcpServers": {
    "arcane": {
      "type": "streamableHttp",
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer change-me",
        "X-Arcane-API-Key": "arc_..."
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Continue

Continue lee ~/.continue/config.yaml; un espacio de trabajo puede añadir servidores como ficheros de bloque en .continue/mcpServers/, que necesitan la cabecera name, version y schema que se ve aquí. Continue resuelve ${{ secrets.NOMBRE }} por su cuenta, así que el fichero nunca contiene la clave. Las herramientas MCP solo están disponibles en modo agente; recarga la ventana de Continue después de editar.

name: Arcane
version: 0.0.1
schema: v1
mcpServers:
  - name: arcane
    command: /ruta/a/arcane-mcp
    env:
      ARCANE_URL: https://arcane.example.com
      ARCANE_API_KEY: ${{ secrets.ARCANE_API_KEY }}

name: Arcane
version: 0.0.1
schema: v1
mcpServers:
  - name: arcane
    command: docker
    args:
      - run
      - -i
      - --rm
      - -e
      - ARCANE_URL
      - -e
      - ARCANE_API_KEY
      - ghcr.io/jmrplens/arcane-mcp:latest
    env:
      ARCANE_URL: https://arcane.example.com
      ARCANE_API_KEY: ${{ secrets.ARCANE_API_KEY }}

name: Arcane
version: 0.0.1
schema: v1
mcpServers:
  - name: arcane
    type: streamable-http
    url: https://arcane-mcp.example.com/mcp
    requestOptions:
      headers:
        Authorization: Bearer ${{ secrets.ARCANE_MCP_HTTP_TOKEN }}
        X-Arcane-API-Key: ${{ secrets.ARCANE_API_KEY }}

LM Studio

LM Studio sigue la notación de mcp.json de Cursor. Abre el fichero desde la pestaña Program de la barra lateral derecha con Install → Edit mcp.json. Su documentación no describe la expansión de variables de entorno, así que los valores se escriben en el fichero. LM Studio pide confirmación antes de cada llamada a una herramienta salvo que la permitas de forma permanente.

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer change-me",
        "X-Arcane-API-Key": "arc_..."
      }
    }
  }
}

Los modelos locales tienen ventanas de contexto pequeñas; aquí conviene mantener la superficie dynamic.

Kiro

Kiro lee .kiro/settings/mcp.json en el espacio de trabajo, o ~/.kiro/settings/mcp.json para todos; si existen ambos, mandan las entradas del espacio de trabajo. Expande ${NOMBRE_DE_VARIABLE}, pero el IDE solo lo hace con las variables que hayas aprobado en el aviso que muestra la primera vez que una entrada las usa. Hay usuarios que han informado de que la CLI de Kiro deja ${…} sin expandir en algunas versiones; si el servidor responde 401, escribe los valores directamente. Los cambios se aplican al guardar.

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "args": [],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${ARCANE_API_KEY}"
      },
      "disabled": false
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "${ARCANE_API_KEY}"
      },
      "disabled": false
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "url": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${ARCANE_MCP_HTTP_TOKEN}",
        "X-Arcane-API-Key": "${ARCANE_API_KEY}"
      },
      "disabled": false
    }
  }
}

Gemini CLI

Gemini CLI lee ~/.gemini/settings.json, o .gemini/settings.json en un proyecto, y expande $VAR y ${VAR} en sus valores de texto. Cuando arranca un servidor stdio, elimina del entorno heredado todas las variables cuyo nombre parece un secreto (*KEY*, *TOKEN*, *PASSWORD*, *AUTH*…), así que ARCANE_API_KEY solo llega al servidor si el bloque env de la entrada la nombra, como abajo.

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "$ARCANE_API_KEY"
      }
    }
  }
}

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "ARCANE_URL",
        "-e", "ARCANE_API_KEY",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ],
      "env": {
        "ARCANE_URL": "https://arcane.example.com",
        "ARCANE_API_KEY": "$ARCANE_API_KEY"
      }
    }
  }
}

httpUrl es el endpoint de Streamable HTTP; un url a secas se interpretaría como SSE heredado.

{
  "mcpServers": {
    "arcane": {
      "httpUrl": "https://arcane-mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer $ARCANE_MCP_HTTP_TOKEN",
        "X-Arcane-API-Key": "$ARCANE_API_KEY"
      }
    }
  }
}

No definas la opción trust de la entrada: se salta la confirmación que Gemini CLI pide antes de cada llamada a una herramienta.

OpenAI Codex CLI

Codex lee ~/.codex/config.toml, o .codex/config.toml en un proyecto de confianza; la aplicación de escritorio de ChatGPT y la extensión de Codex para el IDE comparten ese fichero. Cada servidor es una tabla [mcp_servers.<nombre>].

[mcp_servers.arcane]
command = "/ruta/a/arcane-mcp"
env_vars = ["ARCANE_API_KEY"]
tool_timeout_sec = 1800

[mcp_servers.arcane.env]
ARCANE_URL = "https://arcane.example.com"

env_vars reenvía ARCANE_API_KEY desde el entorno en el que se ejecuta Codex, de modo que el fichero nunca la contiene; si lo prefieres, ponla en la tabla env.

[mcp_servers.arcane]
command = "docker"
args = ["run", "-i", "--rm", "-e", "ARCANE_URL", "-e", "ARCANE_API_KEY", "ghcr.io/jmrplens/arcane-mcp:latest"]
env_vars = ["ARCANE_API_KEY"]
tool_timeout_sec = 1800

[mcp_servers.arcane.env]
ARCANE_URL = "https://arcane.example.com"

[mcp_servers.arcane]
url = "https://arcane-mcp.example.com/mcp"
bearer_token_env_var = "ARCANE_MCP_HTTP_TOKEN"
env_http_headers = { "X-Arcane-API-Key" = "ARCANE_API_KEY" }
tool_timeout_sec = 1800

bearer_token_env_var y env_http_headers nombran variables de entorno; Codex lee sus valores al conectarse y envía Authorization: Bearer … y X-Arcane-API-Key: ….

Codex concede 60 segundos a cada llamada a una herramienta salvo que tool_timeout_sec diga otra cosa, lo que corta descargas de imágenes, compilaciones y redespliegues; las entradas de arriba lo suben para igualar el valor predeterminado del propio servidor, ARCANE_MCP_ACTION_TIMEOUT, de 30 minutos. Codex admite la elicitación; con un approval_policy granular, mantén mcp_elicitations = true, o Codex rechazará la pregunta de confirmación del servidor y la llamada destructiva quedará denegada.

JetBrains AI Assistant

En IntelliJ IDEA, GoLand, PyCharm y los demás IDE de JetBrains, abre Settings → Tools → AI Assistant → Model Context Protocol (MCP), pulsa Add, elige el transporte y pega el JSON. Indica si el servidor está disponible de forma global o solo en el proyecto actual y pulsa OK y Apply. Import from Claude copia los servidores que ya tengas en la configuración de Claude Desktop.

JetBrains documenta una entrada stdio solo con command y args, más un campo Working directory. arcane-mcp lee un fichero .env en su directorio de trabajo, así que pon ahí las credenciales en lugar de en el JSON:

ARCANE_URL=https://arcane.example.com
ARCANE_API_KEY=arc_...

Pon en Working directory la carpeta que contiene ese .env (/ruta/a/arcane-config) y pega:

{
  "mcpServers": {
    "arcane": {
      "command": "/ruta/a/arcane-mcp",
      "args": []
    }
  }
}

El contenedor no ve el .env del directorio de trabajo, pero Docker puede leer ese mismo fichero con --env-file:

{
  "mcpServers": {
    "arcane": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "--env-file", "/ruta/a/arcane-config/.env",
        "ghcr.io/jmrplens/arcane-mcp:latest"
      ]
    }
  }
}

JetBrains documenta una entrada de Streamable HTTP solo con url, sin cabeceras. Para llegar a un servidor protegido con ARCANE_MCP_HTTP_TOKEN, añade mcp-remote como servidor stdio, que es quien lleva las cabeceras. La entrada simple solo funciona con un servidor que ejecutes sin token en loopback o en una red de confianza, con su propia ARCANE_API_KEY:

{
  "mcpServers": {
    "arcane": {
      "url": "http://127.0.0.1:8080/mcp"
    }
  }
}

Goose

Goose guarda los servidores MCP como extensiones bajo extensions en ~/.config/goose/config.yaml (%APPDATA%\Block\goose\config\config.yaml en Windows). goose configure → Add Extension escribe la misma entrada de forma interactiva, y puede guardar los secretos en el llavero del sistema (env_keys) en lugar de en el fichero. Goose admite la elicitación en modo formulario.

extensions:
  arcane:
    name: arcane
    type: stdio
    enabled: true
    cmd: /ruta/a/arcane-mcp
    args: []
    envs:
      ARCANE_URL: https://arcane.example.com
      ARCANE_API_KEY: arc_...
    timeout: 1800

extensions:
  arcane:
    name: arcane
    type: stdio
    enabled: true
    cmd: docker
    args: [run, -i, --rm, -e, ARCANE_URL, -e, ARCANE_API_KEY, "ghcr.io/jmrplens/arcane-mcp:latest"]
    envs:
      ARCANE_URL: https://arcane.example.com
      ARCANE_API_KEY: arc_...
    timeout: 1800

Una extensión remota lleva uri, no url, y el tipo se escribe streamable_http:

extensions:
  arcane:
    name: arcane
    type: streamable_http
    enabled: true
    uri: https://arcane-mcp.example.com/mcp
    headers:
      Authorization: Bearer change-me
      X-Arcane-API-Key: arc_...
    timeout: 1800

timeout es lo que Goose espera a una llamada a una herramienta, en segundos; las entradas de arriba suben los 300 habituales para que las descargas de imágenes y los redespliegues largos puedan terminar.

mcp-remote (un puente stdio)

mcp-remote es un pequeño programa de Node.js que el cliente arranca como servidor stdio y que lo reenvía todo a uno remoto. Es la forma de llegar a un despliegue HTTP desde un cliente que no puede enviar cabeceras (JetBrains) o que solo se conecta a URL públicas (los conectores de Claude Desktop). Expande ${NOMBRE} en sus argumentos a partir de su propio entorno, así que los secretos quedan en el bloque env de la entrada:

{
  "mcpServers": {
    "arcane": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://arcane-mcp.example.com/mcp",
        "--header", "Authorization:${ARCANE_AUTH}",
        "--header", "X-Arcane-API-Key:${ARCANE_API_KEY}"
      ],
      "env": {
        "ARCANE_AUTH": "Bearer change-me",
        "ARCANE_API_KEY": "arc_..."
      }
    }
  }
}

Escribe cada cabecera sin espacio tras los dos puntos y deja el espacio dentro de la variable: algunos clientes no entrecomillan los argumentos con espacios al arrancar npx. mcp-remote rechaza las URL http:// sin cifrar que no sean localhost salvo que añadas --allow-http.

Cuando algo no funciona

El servidor no arranca. Ejecuta el comando de la entrada en un terminal con las mismas variables. Si falta ARCANE_URL, o en modo stdio falta ARCANE_API_KEY (o el usuario y la contraseña), lo indica y el proceso termina.
Todas las llamadas fallan con un 401 de Arcane. Arcane ha rechazado la clave: en modo stdio revisa ARCANE_API_KEY; por HTTP, la clave de la cabecera X-Arcane-API-Key del cliente (o la ARCANE_API_KEY del propio servidor cuando el cliente no envía ninguna), o con ARCANE_MCP_HTTP_AUTH=apikey la clave que el cliente envía como token Authorization: Bearer. La pista del error nombra la credencial que se envió: ARCANE_API_KEY (o el inicio de sesión) cuando era la del propio servidor, la cabecera X-Arcane-API-Key cuando era la del cliente, y el token Bearer del cliente con ARCANE_MCP_HTTP_AUTH=apikey.
La propia conexión HTTP se rechaza con 401. Un 401 con WWW-Authenticate: Bearer antes de cualquier tráfico MCP significa que falta la cabecera Authorization o que no coincide con ARCANE_MCP_HTTP_TOKEN; con ARCANE_MCP_HTTP_AUTH=apikey, que falta el Bearer o que Arcane no lo acepta como clave de API.
La forma Docker se queda colgada o termina al instante. Comprueba que está -i, que no se ha colado ningún -t ni -d y que ARCANE_URL se resuelve desde dentro del contenedor.
El cliente no muestra herramientas, o muestra demasiadas. Consulta Qué superficie para cada cliente.
Las llamadas destructivas vuelven una y otra vez pidiendo confirmación. Es el rechazo propio de los clientes sin elicitación; el modelo debería preguntarte y repetir la llamada con confirm: true. Consulta Seguridad.
Cualquier otra cosa. Solución de problemas recoge, tal como los escribe el servidor, los errores con los que es más probable que te encuentres, desde el arranque hasta los rechazos HTTP, con su causa y cómo resolverlos.