Passer au contenu

Pour tout client compatible MCP

S'il parle MCP,
il parle Maguyva.

L'intégration ne se fait pas outil par outil — c'est le protocole. Maguyva est un serveur MCP standard sur une seule URL, donc quel que soit l'environnement de votre agent (Claude Code, Codex, Cursor, Gemini, Windsurf, Antigravity, Zed, Cline, ou quelque chose que vous avez construit vous-même), il obtient la même carte interrogeable de votre dépôt. Indexez une fois, et chaque client que vous connectez pose les mêmes questions ancrées dans le réel.

Palier Free : 3 dépôts, Jusqu'à 50 000 lignes de dépôt indexées, sans carte.

Un seul serveur MCP. Tous les clients. Pas de plugin par outil, pas d'enfermement propriétaire.

Le rôle de chaque couche

Quatre pièces. Chacune a un rôle.

// votre client

N'importe quel client MCP

24 clients documentés, dont Claude Code, Codex CLI, Gemini CLI, Cursor, Windsurf, Antigravity, ou votre propre agent.

// protocole

MCP

Le standard ouvert que chacun d'eux parle déjà.

// base de code

Maguyva

Un seul serveur MCP. Des faits de dépôt ancrés, renvoyés avec fichier:ligne.

// qui paie

Des espaces de travail, pas des sièges

Les agents ne paient pas de siège. Voir les tarifs

MCP, c'est l'intégration. Standardisez dessus.

Le protocole ouvert est le bon choix, pas un contournement. Construire sur MCP plutôt que sur un plugin par outil, c'est exactement comme ça qu'on évite de tout réintégrer à chaque fois qu'un meilleur agent sort. C'est le bon endroit pour :

  • Un seul bloc de configuration serveur qui s'installe dans n'importe quel client conforme.
  • Des outils et ressources portables entre éditeurs, CLI et agents.
  • Une frontière que votre équipe sécurité peut auditer une fois, pas par fournisseur.
  • La liberté de changer de client sans reconstruire toute votre pile de contexte.

Continuez comme ça. Standardiser sur MCP, c'est le bon mouvement.

Mais un protocole est un tuyau. Il transporte la question et la réponse — il ne connaît pas votre dépôt. Il faut quelque chose de l'autre côté qui cartographie vraiment vos symboles, points d'appel et dépendances.

Où le contexte par outil cesse de tenir la charge

Quatre modes d'échec qu'aucun fichier de règles d'agent ne peut réparer à lui seul.

// chaque outil recommence à zéro

Choisissez un nouvel agent, et il redémarre aveugle sur votre dépôt. Vous recollez les mêmes fichiers, réépinglez le même contexte, réécrivez les mêmes règles. Le travail ne se transfère pas, parce que ce n'était jamais une couche partagée.

// les fichiers de règles ne voyagent pas

CLAUDE.md, .cursor/rules, AGENTS.md — chacun est propre à un outil, et aucun n'est un index interrogeable de votre code. Changez de client, et la carte que vous avez construite à la main reste derrière vous.

// l'enfermement d'intégration est une taxe

Câbler un contexte de dépôt profond dans le plugin d'un seul fournisseur veut dire que le jour où vous essayez un autre agent, vous devez tout reconstruire. Plus votre contexte est bon, plus il coûte cher de partir.

// le protocole est un tuyau, pas une carte

MCP déplace outils et contexte entre client et serveur. Il ne connaît ni vos symboles, ni vos points d'appel, ni votre graphe de dépendances. Il faut quelque chose de l'autre côté qui réponde vraiment à la question.

Maguyva est la couche à l'autre bout du protocole

Pas un agent de plus. Le serveur de contexte-dépôt que n'importe quel client MCP peut appeler :

  • Un seul endpoint, tous les clients le même https://maguyva.tools/mcp dessert Claude Code, Codex CLI, Gemini CLI, Cursor, Windsurf, Antigravity, ou un script que vous avez écrit ce matin.
  • Sémantique + AST + graphe + texte recherchez par sens, par structure, par dépendance, ou en texte littéral. Chaque résultat renvoie un chemin de fichier et un numéro de ligne, quel que soit le client qui a demandé.
  • Conscient des branches, multi-packages Maguyva voit la version du code que l'agent est en train d'éditer, sur tous les packages du monorepo.
  • Aucun verrouillage changez d'agent quand vous voulez ; la couche de contexte ne bouge pas. Tarification par espace de travail, pas par siège — indexez 1 dépôt ou 50.

Votre client parle MCP.

Maguyva est ce qui répond quand il pose une question sur votre code.

Trois workflows, identiques depuis chaque client

Multi-paquets, multi-langages. Le client change ; la réponse ancrée dans le réel, non.

// workflow 01

Trouver le flux d'auth à travers les paquets, depuis n'importe quel agent

agent> où se passe l'authentification dans ce monorepo ?

graph::query("authentication flow")
  packages/web/src/auth/session.ts:42       middleware
  packages/api/src/auth/jwt.ts:88           vérification du token
  packages/shared/src/auth/types.ts:12      AuthContext
  packages/admin/src/auth/admin-only.ts:31  porte RBAC

 4 points d'entrée dans 4 paquets, classés par densité de points d'appel.
[exit 0]

Claude Code, Cursor, ou votre propre script — peu importe le client qui a envoyé la requête. Les quatre mêmes fichiers reviennent dans le même ordre, ancrés dans le vrai graphe.

// workflow 02

Trouver la vraie implémentation, pas le stub de test

agent> comment normalizePhoneNumber gère-t-il le E.164 ?

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

Les noms mentent. Les mocks masquent le vrai code. Maguyva classe l'implémentation réelle avant le mock de test — de la même façon pour chaque client qui pose la question.

// workflow 03

Vérifier le rayon d'impact avant une refonte

agent> qui appelle QueueDispatcher.publish dans le monorepo ?

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

Multi-paquets, et multi-langages sur un dépôt polyglotte, les points d'appel remontent directement. Changez d'agent demain, le rayon d'impact est toujours là, parce qu'il vit dans le serveur, pas dans le client.

Configuration avec n'importe quel client MCP

Trois étapes. Palier Free : 3 dépôts, Jusqu'à 50 000 lignes de dépôt indexées, sans carte.

  1. // step 01

    Indexez un dépôt sur maguyva.ai

    Choisissez-en un que vous connaissez bien pour pouvoir vérifier les réponses. Le palier Free couvre 3 dépôts, Jusqu'à 50 000 lignes de dépôt indexées.

  2. // step 02

    Ajoutez Maguyva comme serveur MCP dans le client de votre choix

    // any MCP client: add a remote MCP server
    {
      "mcpServers": {
        "maguyva": {
          "url": "https://maguyva.tools/mcp",
          "headers": {
            "Authorization": "Bearer <your-key>"
          }
        }
      }
    }
    
    // CLI clients can use the same endpoint:
    //   https://maguyva.tools/mcp
  3. // step 03

    Posez une question dont vous connaissez déjà la réponse

    Commencez par un dépôt et une question vérifiable, comme « qui appelle formatInvoice dans les paquets ? » Si la réponse correspond à ce que vous diriez, tous les autres clients que vous y pointerez obtiendront le même résultat ancré dans le réel.

Sources