Saltar al contenido

Guía de instalación

Ponte en marcha en menos de 5 minutos. Esta guía incluye la configuración para 24 clientes MCP, entre ellos Claude Code, Claude Desktop, Cursor, VS Code / GitHub Copilot, y Windsurf, y más.

Requisitos previos: necesitarás una clave de API de app.maguyva.ai y un repositorio de GitHub conectado.

Configuración del entorno#

Primero, configura la clave API en una variable de entorno. Omite repository cuando el cliente MCP proporcione un valor predeterminado para la solicitud o la clave pueda acceder exactamente a un repositorio; de lo contrario, pásalo explícitamente.

macOS/Linux (Bash/Zsh)#

# Add to your shell profile for persistence:
echo 'export MAGUYVA_API_KEY="mgv_xxxx"' >> ~/.zshrc  # or ~/.bashrc
source ~/.zshrc  # reload

Windows (PowerShell)#

# Make it persist in your profile:
'$Env:MAGUYVA_API_KEY="mgv_xxxx"' | Out-File -Append $PROFILE
. $PROFILE

Reemplaza mgv_xxxx con tu clave de API real de app.maguyva.ai.

Configuración del cliente#

Elige tu cliente MCP abajo para ver instrucciones de configuración específicas.

Nota de compatibilidad: Maguyva usa el estándar MCP. Cualquier cliente compatible con MCP puede conectarse al mismo servidor, incluso si todavía no hemos escrito una guía de configuración oficial para él.

Claude Code

Instala el plugin de Maguyva desde el marketplace de Claude Code:

Agrega el marketplace de Maguyva y luego instala el plugin (ejecuta cada comando dentro de Claude Code):

/plugin marketplace add maguyva/claude-code-plugin
/plugin install maguyva@maguyva

Se instala para tu cuenta de usuario. Para un equipo, agrega --scope project a ambos comandos para confirmar el plugin en el .claude/settings.json del repositorio, así tus compañeros lo reciben automáticamente.

El plugin se autentica mediante la variable de entorno MAGUYVA_API_KEY. Configúrala en tu shell:

export MAGUYVA_API_KEY=mgv_xxxx

Se recomienda direnv (.envrc) por proyecto — las claves tienen alcance por repositorio, así que un valor por proyecto coincide con el acceso de cada uno. Un export global del shell funciona si una sola clave cubre todo tu trabajo.

Manual (.mcp.json) — avanzado
.mcp.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Claude Code →

Claude Desktop

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %AppData%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Agrégalo a tu archivo de configuración de Claude Desktop:

claude_desktop_config.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Claude Desktop solo admite servidores remotos como "conectores" de OAuth a través de Settings, no como una entrada autenticada por encabezado en claude_desktop_config.json, así que esto usa el puente mcp-remote (requiere Node.js / npx).

Documentación MCP de Claude Desktop →

Cursor

macOS: ~/.cursor/mcp.json
Windows: %UserProfile%\.cursor\mcp.json
Linux: ~/.cursor/mcp.json

Agrégalo a .cursor/mcp.json en la raíz de tu proyecto:

.cursor/mcp.json
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Cursor →

VS Code / GitHub Copilot

Agrégalo a .vscode/mcp.json en tu proyecto (o a la configuración de usuario):

.vscode/mcp.json
{
  "servers": {
    "maguyva": {
      "type": "http",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de VS Code / GitHub Copilot →

Windsurf

macOS: ~/.codeium/windsurf/mcp_config.json
Windows: %UserProfile%\.codeium\windsurf\mcp_config.json
Linux: ~/.codeium/windsurf/mcp_config.json

Agrégalo a tu configuración MCP de Windsurf:

mcp_config.json
{
  "mcpServers": {
    "maguyva": {
      "serverUrl": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Windsurf →

Codex

macOS: ~/.codex/config.toml
Windows: %UserProfile%\.codex\config.toml
Linux: ~/.codex/config.toml

Agrégalo a tu configuración de Codex CLI (~/.codex/config.toml):

.codex/config.toml
[mcp_servers.maguyva]
url = "https://maguyva.tools/mcp"

[mcp_servers.maguyva.http_headers]
Authorization = "Bearer ${MAGUYVA_API_KEY}"

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Codex →

GitHub Copilot CLI

Agrégalo a .copilot/mcp-config.json:

.copilot/mcp-config.json
{
  "servers": {
    "maguyva": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de GitHub Copilot CLI →

Gemini CLI

macOS: ~/.gemini/settings.json
Windows: %UserProfile%\.gemini\settings.json
Linux: ~/.gemini/settings.json

Agrégalo a tu configuración de Gemini CLI (~/.gemini/settings.json):

settings.json
{
  "mcpServers": {
    "maguyva": {
      "httpUrl": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Gemini CLI →

Cline

macOS: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Windows: %AppData%\Code\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Linux: ~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json

Agrégalo a tu configuración MCP de Cline:

cline_mcp_settings.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      },
      "alwaysAllow": [],
      "disabled": false
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de Cline →

Roo Code

macOS: ~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json
Windows: %AppData%\Code\User\globalStorage\rooveterinaryinc.roo-cline\settings\mcp_settings.json
Linux: ~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json

Agrégalo a tu configuración MCP de Roo Code:

mcp_settings.json
{
  "mcpServers": {
    "maguyva": {
      "type": "streamable-http",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      },
      "alwaysAllow": [],
      "disabled": false
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Roo Code →

Goose

macOS: ~/.config/goose/config.yaml
Windows: %AppData%\goose\config.yaml
Linux: ~/.config/goose/config.yaml

Agrégalo a tu configuración de Goose:

config.yaml
extensions:
  maguyva:
    name: maguyva
    cmd: npx
    args:
      - -y
      - mcp-remote
      - https://maguyva.tools/mcp
      - --header
      - "Authorization: Bearer ${MAGUYVA_API_KEY}"
    enabled: true
    envs:
      MAGUYVA_API_KEY: mgv_xxxx
    type: stdio

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de Goose →

LM Studio

LM Studio admite servidores MCP a través de su configuración de Agent. Agrega un nuevo servidor MCP en Settings → Agent → MCP Servers usando el formato JSON estándar de mcpServers. LM Studio se conecta a los servidores MCP por stdio. Ver documentación →

Continue

macOS: ~/.continue/config.json
Windows: %UserProfile%\.continue\config.json
Linux: ~/.continue/config.json

Agrégalo a tu configuración de Continue (~/.continue/config.json):

config.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de Continue →

Amazon Q Developer

macOS: ~/.aws/amazonq/mcp.json
Windows: %UserProfile%\.aws\amazonq\mcp.json
Linux: ~/.aws/amazonq/mcp.json

Agrégalo a tu configuración MCP de Amazon Q:

mcp.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de Amazon Q Developer →

PyCharm

Agrégalo a .ai/mcp/mcp.json en la raíz de tu proyecto, o pégalo en Settings > Tools > AI Assistant > MCP:

.ai/mcp/mcp.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de PyCharm →

Zed

macOS: ~/.config/zed/settings.json
Windows: %AppData%\Zed\settings.json
Linux: ~/.config/zed/settings.json

Agrégalo a tu configuración de Zed (~/.config/zed/settings.json):

settings.json
{
  "context_servers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Zed →

Trae

Agrégalo a .trae/mcp.json en la raíz de tu proyecto:

.trae/mcp.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de Trae →

OpenCode

Agrégalo a opencode.json en la raíz de tu proyecto:

opencode.json
{
  "mcp": {
    "maguyva": {
      "type": "remote",
      "url": "https://maguyva.tools/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de OpenCode →

BoltAI

macOS: ~/Library/Application Support/BoltAI/mcp_config.json

Agrégalo a tu configuración MCP de BoltAI:

mcp_config.json
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de BoltAI →

LibreChat

Agrégalo a tu configuración de LibreChat:

librechat.yaml
mcpServers:
  maguyva:
    command: npx
    args:
      - -y
      - mcp-remote
      - https://maguyva.tools/mcp
      - --header
      - "Authorization: Bearer ${MAGUYVA_API_KEY}"
    env:
      MAGUYVA_API_KEY: mgv_xxxx

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Este cliente todavía no admite un servidor MCP remoto con un encabezado de autenticación personalizado, así que se conecta a través del puente mcp-remote (requiere Node.js / npx). Maguyva se ejecuta completamente en remoto — solo el puente se ejecuta localmente.

Documentación MCP de LibreChat →

Antigravity

macOS: ~/.gemini/antigravity/mcp_config.json
Windows: %UserProfile%\.gemini\antigravity\mcp_config.json
Linux: ~/.gemini/antigravity/mcp_config.json

Agrégalo a tu configuración MCP de Antigravity:

mcp_config.json
{
  "mcpServers": {
    "maguyva": {
      "serverUrl": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Antigravity →

Claude Cowork

Claude Cowork usa el mismo formato MCP que los demás clientes de Anthropic:

{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://maguyva.tools/mcp",
        "--header",
        "Authorization: Bearer ${MAGUYVA_API_KEY}"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Reemplaza mgv_xxxx con tu clave de API de app.maguyva.ai.

Documentación MCP de Claude Cowork →

ChatGPT

ChatGPT admite servidores MCP remotos en los planes Business, Enterprise y Edu a través de Settings → Apps → Create. Se requiere un endpoint HTTPS remoto — ChatGPT no admite servidores stdio locales. Consulta la guía de MCP de OpenAI para la configuración. Ver documentación →

Warp

Warp admite servidores MCP en Agent Mode. La configuración se gestiona desde la interfaz de Warp (Settings → Agent Mode → MCP Servers) y se sincroniza vía Warp Drive. Pega el JSON estándar de mcpServers al agregar un servidor. Ver documentación →

Maguyva usa el estándar MCP. Cualquier cliente que soporte el protocolo puede conectarse, incluso si no hay una guía propia arriba.24 clientes documentados, y se agregan más con regularidad.

Valida tu configuración#

Después de conectar, prueba a hacerle a tu agente algunas preguntas:

  • "¿Qué repositorios tengo conectados?" — verifica que la conexión funcione
  • "¿Cómo se maneja la autenticación en este código?" — pone a prueba la búsqueda semántica
  • "Encuentra todas las funciones que llaman a la base de datos" — pone a prueba la búsqueda de dependencias
  • "¿De qué depende la clase UserService?" — pone a prueba la búsqueda de símbolos

Deberías ver resultados con rutas de archivo y números de línea de tu repositorio conectado. Si no es así, revisa la sección de troubleshooting section más abajo.

Formato del repositorio#

Al especificar repositorios:

  • Con rama: "owner/repo:branch" (e.g., "owner/repository:develop")
  • Rama predeterminada: "owner/repo"

Consejo: usa repository_context(action="info", repository="...") para verificar la resolución del repositorio. El servidor v3 no mantiene estado, por lo que las sustituciones de repositorio solo se aplican a una llamada.

Solución de problemas#

Problemas con la clave de API#

  • Verifica que tu clave empiece con el prefijo mgv_
  • Comprueba que la clave esté correctamente configurada en tu entorno
  • Asegúrate de que la clave no haya expirado

Repositorio no encontrado#

  • Verifica que el repositorio esté conectado en app.maguyva.ai
  • Comprueba que el formato owner/repo sea correcto
  • Asegúrate de tener acceso al repositorio

Problemas de conexión MCP#

  • Verifica que npx esté disponible en tu PATH
  • Comprueba que tu token de API sea válido y no haya expirado
  • Prueba la conectividad con https://maguyva.tools/mcp
  • Revisa la sintaxis de configuración MCP de tu cliente

Próximos pasos#