Si alguna vez has configurado servidores MCP "como es debido", seguramente has hecho este baile:

• pegar el JSON de MCP en Claude Code
• pegar un JSON de MCP ligeramente distinto en Codex
• descubrir que OpenCode usa otra ubicación
• repetirlo todo en el portátil y en el servidor

Funciona.

Pero también es la razón de que las sesiones se comporten de forma distinta según la máquina en la que estés.

Lo que de verdad quieres es:

• definir las herramientas una vez
• tenerlas disponibles de forma coherente
• y aun así mantener las herramientas propias de cada máquina en esa máquina

Esta guía trata de ese flujo.

En resumen

1. Decide para qué quieres MCP (automatización del navegador, GitHub, búsqueda en documentación, herramientas internas).
2. El fallo habitual es la deriva de configuración: JSON de MCP distinto en distintas máquinas o proveedores.
3. Un modelo mejor es "una biblioteca de herramientas + ámbitos de aplicación explícitos".
4. En Happier puedes definir servidores MCP una vez, detectar las configuraciones MCP existentes de los proveedores, previsualizar el conjunto efectivo de herramientas de una sesión y aplicar servidores a:
   • todas las máquinas
   • una máquina
   • un espacio de trabajo en una máquina

El problema

MCP es una buena idea, pero la configuración ingenua es frágil:

• varios archivos de configuración
• varias máquinas
• varios proveedores

Así que la pregunta no es "¿puedo ejecutar MCP?"

Es:

¿puedo hacer que el conjunto de herramientas sea lo bastante coherente como para fiarme de él?

Enfoques habituales y sus contrapartidas

• Copiar y pegar JSON en todas partes: funciona hasta que te olvidas de una máquina.
• Configurarlo solo en un proveedor: pierdes justo la portabilidad.
• Mantener las herramientas solo por proyecto: va bien en algunos casos, pero es un engorro para herramientas universales como GitHub.

Si Happier es nuevo para ti

Si no conocías Happier: es una app complementaria de código abierto (móvil/web/escritorio) para ejecutar sesiones como Claude Code, Codex y OpenCode en varias máquinas.

Lo relevante aquí: te da un solo sitio para gestionar servidores MCP y aplicarlos de forma coherente.

Para empezar:

• Cómo usar Happier desde el móvil
• GitHub: https://github.com/happier-dev/happier
• Instalación/descarga: https://github.com/happier-dev/happier#how-it-works
• Discord (comunidad y soporte): https://discord.gg/W6Pb8KuHfg

Un flujo que funciona

1) Trata las herramientas como una biblioteca, no como un montón de JSON

En cuanto tienes más de una máquina, la configuración de MCP se convierte en infraestructura.

Así que trátala como una biblioteca:

• guardada
• revisable
• con ámbito

2) Piensa en "Configurado / Detectado / Vista previa"

En Happier, los servidores MCP se organizan en tres pestañas:

• Configurado (Configured): servidores que gestionas en la app
• Detectado (Detected): servidores encontrados en los archivos de configuración nativos de los proveedores (Claude, Codex, OpenCode)
• Vista previa (Preview): el conjunto efectivo de herramientas para un backend + máquina + espacio de trabajo concretos

La vista previa es la clave.

Responde a: "¿qué va a ver realmente esta sesión?"

3) Aplica el ámbito correcto: todas las máquinas / una máquina / un espacio de trabajo

La mayor parte de la deriva viene de no ser explícito con el ámbito.

Reglas que funcionan:

• servidores remotos HTTP/SSE → Todas las máquinas (All machines)
• servidores stdio locales instalados con npx → Máquina (Machine, una)
• servidores locales de un proyecto → Espacio de trabajo (Workspace, uno en una máquina)

4) Deja los secretos fuera del JSON (y deja de filtrar tokens)

Cada vez que pegas un token directamente en el JSON de MCP, esparces secretos:

• acaba en el historial de la shell
• acaba en los dotfiles
• acaba en capturas de pantalla
• y tarde o temprano acaba en un repositorio por accidente

Funciona mejor tener:

• un sitio donde guardar los secretos una vez
• una forma de referenciarlos desde la configuración de MCP sin incrustarlos
• una forma de reutilizarlos con seguridad entre máquinas

Happier admite tres orígenes de valor para las cabeceras y variables de entorno de los servidores MCP:

• Secretos guardados (Saved Secrets, recomendado)
• referencias a variables de entorno de la máquina como ${MY_TOKEN}
• texto plano (evítalo salvo que de verdad no sea sensible)

La opción de "Secretos guardados" facilita mucho el MCP en varias máquinas.

Vinculas el secreto una vez y la definición del servidor MCP puede ser idéntica en todas las máquinas.

Ejemplo completo: servidor MCP de GitHub con cabecera Authorization (secreto guardado)

Un patrón muy habitual es un servidor MCP remoto (HTTP/SSE) que necesita:

• Authorization: Bearer <token>

Esta es la configuración completa, de principio a fin, sin pegar nunca el token en un JSON.

Paso 1: crea un token de GitHub

Crea un token de GitHub con los permisos mínimos que necesites (PAT clásico o token fine-grained).

(Los permisos dependen de las herramientas MCP que pienses usar: repositorios, issues, PR, etc.)

Paso 2: guarda el token como secreto guardado

En Happier:

• Configuración (Settings) → Secretos guardados (Saved Secrets) (o Configuración (Settings) → Secretos (Secrets))
• Nuevo secreto (New secret)
• Ponle un nombre que reconozcas, por ejemplo github_pat_work
• Pega el valor del token

Ahora el valor vive en el almacén cifrado de ajustes de Happier y no en tus archivos de configuración.

Paso 3: añade el servidor MCP de GitHub en Happier

En Happier:

• Configuración (Settings) → Servidores MCP (MCP servers) → Añadir servidor (Add server)
• Elige HTTP remoto (Remote HTTP) o SSE remoto (Remote SSE) (según lo que admita el servidor)
• Ponle un nombre, por ejemplo github

Luego configura:

• Se aplica a (Applies to): normalmente Todas las máquinas (All machines) (porque los servidores remotos son portátiles)

Paso 4: configura la cabecera Authorization con el secreto guardado

En la configuración del servidor MCP, añade una cabecera:

• Nombre de la cabecera: Authorization
• Valor de la cabecera: Bearer <your-saved-secret>

Lo importante es cómo referencias el secreto:

• no pegues el valor del token
• selecciona o referencia tu secreto guardado (por ejemplo github_pat_work) en el campo del valor de la cabecera

En el editor de cabeceras puedes elegir el origen del valor:

• Valor literal (Literal, texto plano)
• Secreto guardado (Saved Secret)

Cuando eliges Secreto guardado, Happier guarda una referencia al secreto (no su valor) y la resuelve en tiempo de ejecución al probar o lanzar el servidor MCP.

Paso 5: prueba y luego previsualiza

• Usa Probar (Test) para verificar que Happier puede:
  • resolver la referencia al secreto guardado,
  • conectarse al servidor o arrancarlo,
  • y listar las herramientas.
• Usa Vista previa (Preview) (backend + máquina + espacio de trabajo) para confirmar que las herramientas de GitHub están de verdad en la sesión que te interesa.

Si la prueba funciona pero la vista previa muestra 0 herramientas para la sesión, casi siempre es un problema de ámbito (Todas las máquinas / Máquina / Espacio de trabajo).

(Opcional) Por qué funciona (detalle de implementación)

Cuando eliges Secreto guardado en el editor de variables o cabeceras, la interfaz guarda una pequeña referencia tipada (un id de secreto), no el secreto en sí.

Por eso puedes:

• reutilizar la misma definición de servidor MCP en varias máquinas sin ir copiando el token
• rotar el valor del secreto en un solo sitio sin tocar el JSON de MCP

No necesitas conocer los nombres de tipo internos para usarlo, pero es la razón de que el modelo sea robusto.

Ejemplo: servidor MCP stdio local que necesita variables de entorno

Para servidores stdio (comando local), muchos README te dicen que definas variables de entorno.

El truco es evitar que eso se convierta en "todo el mundo exporta secretos en sus archivos rc de la shell para siempre".

Un patrón mejor es:

• guardar el valor una vez como secreto guardado
• vincularlo al nombre de variable de entorno que necesita ese servidor

5) Define un servidor MCP personalizado (stdio local)

Happier admite servidores MCP de comando local (stdio).

En Configuración (Settings) → Servidores MCP (MCP servers) → Añadir servidor (Add server) puedes:

• pegar una línea de comandos (Happier separa el comando y los argumentos)
• elegir el ámbito (para instalaciones locales suele ser Máquina (Machine))
• añadir variables de entorno (mejor con secretos guardados)

Luego usa Probar para confirmar que arranca y lista herramientas.

6) Define un servidor MCP personalizado (HTTP/SSE remoto)

Para servidores remotos:

• pon el ámbito en Todas las máquinas
• añade cabeceras (mejor con secretos guardados)
• pruébalo una vez

7) Previsualiza el conjunto efectivo de herramientas antes de una sesión importante

Si te quedas con un solo hábito de esta guía, que sea este:

• usa Vista previa para ver qué herramientas va a tener realmente la sesión

La vista previa combina:

• los servidores MCP gestionados por Happier que se aplican por defecto
• los servidores MCP nativos del proveedor detectados para ese backend o contexto
• los servidores disponibles pero no aplicados ahora mismo

Convierte "¿por qué esta sesión no tiene la herramienta de GitHub?" en una respuesta de 10 segundos.

8) Prueba el servidor antes de fiarte de él

Un pequeño hábito que ahorra tiempo:

• prueba el servidor MCP
• comprueba que lista herramientas

Así detectas pronto líneas de comandos erróneas e instalaciones que faltan.

Por qué funciona (y qué lo rompe)

Esta configuración funciona porque separa tres cosas que suelen enredarse:

1. Definición (qué es el servidor MCP)
2. Ámbito (dónde debe aplicarse)
3. Secretos (cómo se autentica)

Cuando falla, suele ser por una de estas razones:

• ámbito incorrecto (todas las máquinas / máquina)
• falta la instalación en la máquina de un servidor stdio local
• el secreto no se puede resolver (secreto guardado sin vincular, variable de entorno ausente)
• una configuración MCP nativa del proveedor tapa lo que esperabas

Solución de problemas

El servidor MCP no arranca

• revisa la línea de comandos
• comprueba que existe en la máquina seleccionada
• si es npx, comprueba que Node está instalado y accesible en esa máquina

Las herramientas aparecen en Configurado, pero no en una sesión

• revisa la Vista previa de ese backend + máquina + espacio de trabajo
• confirma que el ámbito de "Se aplica a" coincide con esta sesión

Falla la autenticación (401/403)

• sustituye los tokens en línea por secretos guardados
• asegúrate de que la cabecera o la variable de entorno referencia bien el secreto guardado
• vuelve a probar el servidor

Guías relacionadas

• Cómo ejecutar varias sesiones de Claude Code, Codex y OpenCode en paralelo (sin perder el hilo)