# Si habla MCP, habla Maguyva.

Canonical source: https://maguyva.ai/es/for-anything

License: text under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/); code samples under [MIT-0](https://opensource.org/license/mit-0); the Maguyva name, logos, brand assets and other code are not covered. Details: [maguyva.ai/license](https://maguyva.ai/license).

La integración no es por herramienta — es el protocolo. Maguyva es un servidor MCP estándar en una sola URL, así que sea cual sea el entorno donde corre tu agente (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity, Zed, Cline, o algo que construiste tú mismo), obtiene el mismo mapa consultable de tu repo. Indexa una vez, y cada cliente que conectes hace las mismas preguntas fundamentadas.

> Un servidor MCP. Todos los clientes. Sin plugin por herramienta, sin lock-in.

## Qué hace cada capa

Cuatro piezas. Cada una tiene su trabajo.

### Cualquier cliente MCP

23 clientes documentados, incluidos Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, o tu propio agente.

### MCP

El estándar abierto que todos ellos ya hablan.

### Maguyva

Un servidor MCP. Datos del repositorio fundamentados, devueltos con file:line.

### Espacios de trabajo, no asientos

Los agentes no pagan asientos. [Ver precios](https://maguyva.ai/es/pricing)

## MCP es la integración. Adóptalo como estándar.

El protocolo abierto es la decisión correcta, no un workaround. Construir sobre [MCP](https://modelcontextprotocol.io/docs/getting-started/intro) en lugar de un plugin por herramienta es exactamente cómo evitas rehacer la integración cada vez que sale un agente mejor. Es el lugar correcto para:

- Un solo bloque de configuración de servidor que funciona en cualquier cliente compatible.
- Herramientas y recursos portables entre editores, CLIs y agentes.
- Un límite que tu equipo de seguridad puede revisar una vez, no por proveedor.
- Libertad para cambiar de cliente sin reconstruir tu stack de contexto.

Sigue haciendo eso. Estandarizarte en MCP es la jugada.

Pero un protocolo es una tubería. Transporta la pregunta y la respuesta — no *conoce* tu base de código. Algo tiene que estar del otro lado que realmente mapee tus símbolos, puntos de llamada y dependencias.

## Dónde el contexto por herramienta deja de escalar

Cuatro modos de falla que ningún archivo de reglas de un solo agente puede arreglar.

### // cada herramienta vuelve a empezar de cero

Elige un agente nuevo y vuelve a empezar ciego en tu repo. Vuelves a pegar los mismos archivos, a fijar el mismo contexto, a reescribir las mismas reglas. El trabajo no se transfiere porque nunca fue una capa compartida.

### // los archivos de reglas no viajan

`CLAUDE.md`, `.cursor/rules`, `AGENTS.md` — cada uno es por herramienta, y ninguno es un índice consultable de tu código. Cambia de cliente y el mapa que construiste a mano se queda atrás.

### // el lock-in de integración es un impuesto

Integrar un contexto detallado de la base de código en el plugin de un solo proveedor significa que el día que pruebes un agente distinto, lo tienes que reconstruir. Mientras mejor sea tu contexto, más caro sale irse.

### // el protocolo es una tubería, no un mapa

MCP mueve herramientas y contexto entre el cliente y el servidor. No conoce tus símbolos, puntos de llamada ni el grafo de dependencias. Algo tiene que estar del otro lado que realmente responda la pregunta.

## Maguyva es la capa del otro lado del protocolo

No es otro agente. Es el servidor de contexto de repo que cualquier cliente MCP puede llamar:

- **Un solo endpoint, todos los clientes**: el mismo `https://maguyva.tools/mcp` sirve a Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, o a un script que escribiste esta mañana.
- **Semántica + AST + grafo + texto**: busca por significado, estructura, dependencia o coincidencia literal. Cada resultado devuelve una ruta de archivo y un número de línea, sin importar qué cliente lo haya pedido.
- **Tiene en cuenta las ramas y abarca todos los paquetes**: Maguyva ve la versión del código que el agente está editando, en todos los paquetes del monorepo.
- **Sin ataduras**: cambia de agente cuando quieras; la capa de contexto no se mueve. Precios por espacio de trabajo, no por asiento — indexa 1 repositorio o 50.

> Tu cliente habla MCP.
> Maguyva es quien responde *cuando pregunta sobre tu código.*

## Tres flujos de trabajo, idénticos desde cualquier cliente

Entre paquetes, entre lenguajes. El cliente cambia; la respuesta fundamentada no.

### 01. Encuentra el flujo de auth entre paquetes, desde cualquier agente

```text
agent> ¿dónde pasa la autenticación en este monorepo?

graph::query("authentication flow")
  packages/web/src/auth/session.ts:42       middleware
  packages/api/src/auth/jwt.ts:88           verificación del token
  packages/shared/src/auth/types.ts:12      AuthContext
  packages/admin/src/auth/admin-only.ts:31  control RBAC

→ 4 puntos de entrada en 4 paquetes, ordenados por densidad de puntos de llamada.
[exit 0]
```

Claude Code, Cursor o tu propio script — no importa qué cliente envió la consulta. Vuelven los mismos cuatro archivos en el mismo orden, fundamentados en el grafo real.

### 02. Encuentra la implementación real, no el stub de prueba

```text
agent> ¿cómo maneja normalizePhoneNumber el formato E.164?

semantic::query("normalize phone E.164")
  packages/shared/util/phone.ts:88     normalizePhoneNumber()  ← impl real
  packages/api/test/phone.spec.ts:14   jest.mock(...)          ← stub
[exit 0]
```

Los nombres mienten. Los mocks tapan el código real. Maguyva ubica la implementación real por encima del mock de prueba — de la misma forma para cada cliente que pregunta.

### 03. Revisa el radio de impacto antes de un refactor

```text
agent> ¿qué llama a QueueDispatcher.publish en todo el monorepo?

graph::callers(QueueDispatcher.publish)
  3 en packages/billing/*
  1 en packages/audit/*
  1 en packages/notifications/*
  1 en services/python-worker/*  ← entre lenguajes vía stub de gRPC
[exit 0]
```

Entre paquetes, y entre lenguajes en un repo políglota, los puntos de llamada aparecen inline. Cambia de agente mañana y el radio de impacto sigue ahí, porque vive en el servidor, no en el cliente.

## Configuración con cualquier cliente MCP

Tres pasos. Nivel Free: 3 repositorios, Hasta 50 mil líneas de repo indexadas, sin tarjeta.

### 01. Indexa un repo en maguyva.ai

Elige uno que conozcas bien para poder verificar las respuestas. El nivel Free cubre 3 repositorios, Hasta 50 mil líneas de repo indexadas.

### 02. Agrega Maguyva como servidor MCP en el cliente que uses

```json
{
  "mcpServers": {
    "maguyva": {
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}
```

### 03. Haz una pregunta cuya respuesta ya conozcas

Empieza con un repo y una pregunta verificable, como “¿qué llama a `formatInvoice` entre paquetes?” Si la respuesta coincide con lo que dirías, cualquier otro cliente que conectes ahí va a obtener el mismo resultado fundamentado.

Las instrucciones por cliente (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity y más) viven en [los docs de compatibilidad de Maguyva](https://maguyva.ai/es/docs/compatibility).

## Indexa un repo que ya conozcas.

Conecta cualquier cliente MCP. Haz una pregunta cuya respuesta puedas verificar.

## Fuentes

- [MCP: introducción oficial](https://modelcontextprotocol.io/docs/getting-started/intro)
- [MCP: clientes de ejemplo](https://modelcontextprotocol.io/clients)
- [Maguyva: compatibilidad y clientes](https://maguyva.ai/es/docs/compatibility)
- [Maguyva: stack y seguridad](https://maguyva.ai/es/stack)
- [Maguyva: precios (por espacio de trabajo, no por usuario)](https://maguyva.ai/es/pricing)