# Se parla MCP, parla Maguyva.

Canonical source: https://maguyva.ai/it/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).

L'integrazione non dipende dal singolo strumento — dipende dal protocollo. Maguyva è un server MCP standard su un solo URL, così qualunque ambiente ospiti il tuo agente (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity, Zed, Cline, o qualcosa che hai costruito tu) ottiene la stessa mappa consultabile del tuo repo. Indicizza una volta, e ogni client che colleghi pone le stesse domande basate sul codice reale.

> Un server MCP. Ogni client. Nessun plugin dedicato al singolo strumento, nessun lock-in.

## Cosa fa ogni livello

Quattro pezzi. Ognuno ha un compito.

### Qualsiasi client MCP

23 client documentati, inclusi Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, o il tuo agente personale.

### MCP

Lo standard aperto che ognuno di loro già parla.

### Maguyva

Un solo server MCP. Fatti sul repository ancorati al codice reale, restituiti con file:line.

### Workspace, non utenti

Nessun costo separato per ciascun agente. [Vedi i prezzi](https://maguyva.ai/it/pricing)

## MCP è l'integrazione. Adottalo come standard.

Il protocollo aperto è la scelta giusta, non un ripiego. Costruire su [MCP](https://modelcontextprotocol.io/docs/getting-started/intro) invece di un plugin specifico per ogni strumento è esattamente come eviti di reintegrare ogni volta che esce un agente migliore. È il posto giusto per:

- Un unico blocco di configurazione del server che funziona in qualsiasi client conforme.
- Strumenti e risorse portabili tra editor, CLI e agenti.
- Un confine che il tuo team di sicurezza può revisionare una sola volta, non per ogni fornitore.
- Libertà di cambiare client senza ricostruire il tuo stack di contesto.

Continua a farlo. Adottare MCP come standard è la mossa giusta.

Ma un protocollo è un tubo. Trasporta la domanda e la risposta — non *conosce* il tuo codebase. Qualcosa deve stare dall'altra parte a mappare davvero i tuoi simboli, punti di chiamata e dipendenze.

## Dove il contesto specifico per ogni strumento smette di scalare

Quattro modalità di fallimento che nessun singolo file di regole può risolvere.

### // ogni strumento riparte da zero

Scegli un nuovo agente e riparte cieco sul tuo repo. Reincolli gli stessi file, rifissi lo stesso contesto, riscrivi le stesse regole. Il lavoro non si trasferisce perché non è mai stato un livello condiviso.

### // i file di regole non viaggiano

`CLAUDE.md`, `.cursor/rules`, `AGENTS.md` — ognuno è legato a uno specifico strumento, e nessuno è un indice consultabile del tuo codice. Cambia client e la mappa che hai costruito a mano resta indietro.

### // il lock-in dell'integrazione è una tassa

Collegare un contesto del codebase approfondito al plugin di un solo fornitore significa che il giorno in cui provi un agente diverso, devi ricostruirlo. Migliore è il tuo contesto, più costa andarsene.

### // il protocollo è un tubo, non una mappa

MCP muove strumenti e contesto tra client e server. Non conosce i tuoi simboli, punti di chiamata o grafo delle dipendenze. Qualcosa deve stare dall'altra parte a rispondere davvero alla domanda.

## Maguyva è il livello dall'altra parte del protocollo

Non è un altro agente. È il server di contesto del repo che qualsiasi client MCP può chiamare:

- **Un endpoint, ogni client**: lo stesso `https://maguyva.tools/mcp` serve Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, o uno script che hai scritto stamattina.
- **Semantica + AST + grafo + testo**: cerca per significato, struttura, dipendenza o corrispondenza letterale. Ogni risultato restituisce un percorso di file e un numero di riga, qualunque sia il client che ha chiesto.
- **Consapevole dei branch, cross-package**: Maguyva vede la versione del codice che l'agente sta modificando, in ogni pacchetto del monorepo.
- **Nessun lock-in**: cambia agente quando vuoi; il livello di contesto non si sposta. Prezzi per workspace, non per utente — indicizza 1 repository o 50.

> Il tuo client parla MCP.
> Maguyva è ciò che risponde *quando chiede del tuo codice.*

## Tre flussi di lavoro, identici da ogni client

Tra pacchetti, tra linguaggi. Il client cambia; la risposta fondata no.

### 01. Trova il flusso di autenticazione tra i pacchetti, da qualsiasi agente

```text
agent> dove avviene l'autenticazione in questo monorepo?

graph::query("authentication flow")
  packages/web/src/auth/session.ts:42       middleware
  packages/api/src/auth/jwt.ts:88           token verify
  packages/shared/src/auth/types.ts:12      AuthContext
  packages/admin/src/auth/admin-only.ts:31  rbac gate

→ 4 punti di ingresso in 4 pacchetti, ordinati per densità di punti di chiamata.
[exit 0]
```

Claude Code, Cursor, o un tuo script — non importa quale client ha inviato la query. Vengono restituiti gli stessi quattro file nello stesso ordine, sulla base del grafo reale.

### 02. Trova l'implementazione reale, non lo stub di test

```text
agent> come gestisce normalizePhoneNumber il formato E.164?

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

I nomi mentono. I mock oscurano il codice reale. Maguyva classifica l'implementazione reale sopra il mock di test — allo stesso modo per ogni client che lo chiede.

### 03. Controlla il raggio d'impatto prima di un refactoring

```text
agent> cosa chiama QueueDispatcher.publish in tutto il monorepo?

graph::callers(QueueDispatcher.publish)
  3 in packages/billing/*
  1 in packages/audit/*
  1 in packages/notifications/*
  1 in services/python-worker/*  ← tra linguaggi via stub gRPC
[exit 0]
```

Tra pacchetti, e tra linguaggi su un repo poliglotta, i punti di chiamata emergono inline. Cambia agente domani e il raggio d'impatto è ancora lì, perché vive nel server, non nel client.

## Configurazione con qualsiasi client MCP

Tre passaggi. Piano Free: 3 repository, Fino a 50K righe di repository indicizzate, senza carta di credito.

### 01. Indicizza un repo su maguyva.ai

Scegline uno che conosci bene così puoi verificare le risposte. Il piano Free copre 3 repository, Fino a 50K righe di repository indicizzate.

### 02. Aggiungi Maguyva come server MCP nel client che usi

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

### 03. Fai una domanda di cui conosci già la risposta

Inizia con un repo e una domanda verificabile, come “cosa chiama `formatInvoice` tra i pacchetti?” Se la risposta corrisponde a quello che diresti, ogni altro client che colleghi otterrà lo stesso risultato basato sul codice reale.

Le istruzioni per singolo client (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity e altri) si trovano nella [documentazione di compatibilità di Maguyva](https://maguyva.ai/it/docs/compatibility).

## Indicizza un repo che già conosci.

Collega qualsiasi client MCP. Fai una domanda di cui puoi verificare la risposta.

## Fonti

- [MCP: introduzione ufficiale](https://modelcontextprotocol.io/docs/getting-started/intro)
- [MCP: client di esempio](https://modelcontextprotocol.io/clients)
- [Maguyva: compatibilità e client](https://maguyva.ai/it/docs/compatibility)
- [Maguyva: stack e sicurezza](https://maguyva.ai/it/stack)
- [Maguyva: prezzi (per workspace, non per utente)](https://maguyva.ai/it/pricing)