Passer au contenu

Guide d'installation

Soyez opérationnel en moins de 5 minutes. Ce guide inclut la configuration pour 24 clients MCP, dont Claude Code, Claude Desktop, Cursor, VS Code / GitHub Copilot et Windsurf, et plus encore.

Prérequis : Vous aurez besoin d'une clé API depuis app.maguyva.ai et d'un dépôt GitHub connecté.

Configuration de l'environnement#

Commencez par définir votre clé API dans une variable d’environnement. Omettez repository lorsque votre client MCP fournit une valeur par défaut pour la requête ou lorsque la clé permet d’accéder à un seul dépôt ; sinon, transmettez-le explicitement.

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

Remplacez mgv_xxxx par votre clé API réelle depuis app.maguyva.ai.

Configuration du client#

Choisissez votre client MCP ci-dessous pour des instructions de configuration spécifiques.

Note de compatibilité : Maguyva utilise le standard MCP. Tout client compatible MCP peut se connecter au même serveur, même si nous n'avons pas encore écrit de guide de configuration officiel pour lui.

Claude Code

Installez le plugin Maguyva depuis la marketplace de Claude Code :

Ajoutez la marketplace Maguyva, puis installez le plugin (lancez chaque commande dans Claude Code) :

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

S'installe pour votre compte utilisateur. Pour une équipe, ajoutez --scope project aux deux commandes pour commiter le plugin dans le .claude/settings.json du dépôt, afin que les coéquipiers le reçoivent automatiquement.

Le plugin s'authentifie via la variable d'environnement MAGUYVA_API_KEY. Définissez-la dans votre shell :

export MAGUYVA_API_KEY=mgv_xxxx

Le direnv (.envrc) par projet est recommandé — les clés sont scopées par dépôt, donc une valeur par projet correspond à l'accès de chaque projet. Un export shell global fonctionne si une seule clé couvre tout votre travail.

Manuel (.mcp.json) — avancé
.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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP 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

Ajoutez à votre fichier de configuration 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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Claude Desktop ne supporte les serveurs distants que comme « connecteurs » OAuth via Settings, pas comme entrée authentifiée par en-tête dans claude_desktop_config.json ; ceci utilise donc le pont mcp-remote (nécessite Node.js / npx).

Docs MCP Claude Desktop →

Cursor

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

Ajoutez à .cursor/mcp.json à la racine de votre projet :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP Cursor →

VS Code / GitHub Copilot

Ajoutez à .vscode/mcp.json dans votre projet (ou aux paramètres utilisateur) :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP VS Code / GitHub Copilot →

Windsurf

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

Ajoutez à votre configuration MCP Windsurf :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP Windsurf →

Codex

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

Ajoutez à votre config 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}"

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP Codex →

GitHub Copilot CLI

Ajoutez à .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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP GitHub Copilot CLI →

Gemini CLI

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

Ajoutez à vos paramètres Gemini CLI (~/.gemini/settings.json) :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP 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

Ajoutez à vos paramètres MCP 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
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP 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

Ajoutez à vos paramètres MCP Roo Code :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP Roo Code →

Goose

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

Ajoutez à votre config 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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP Goose →

LM Studio

LM Studio supporte les serveurs MCP via sa configuration Agent. Ajoutez un nouveau serveur MCP dans Settings → Agent → MCP Servers avec le format JSON mcpServers standard. LM Studio se connecte aux serveurs MCP via stdio. Voir la doc →

Continue

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

Ajoutez à votre config 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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP Continue →

Amazon Q Developer

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

Ajoutez à votre config MCP 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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP Amazon Q Developer →

PyCharm

Ajoutez à .ai/mcp/mcp.json à la racine de votre projet, ou collez dans 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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP PyCharm →

Zed

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

Ajoutez à vos paramètres Zed (~/.config/zed/settings.json) :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP Zed →

Trae

Ajoutez à .trae/mcp.json à la racine de votre projet :

.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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP Trae →

OpenCode

Ajoutez à opencode.json à la racine de votre projet :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP OpenCode →

BoltAI

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

Ajoutez à votre configuration MCP 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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP BoltAI →

LibreChat

Ajoutez à votre configuration 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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Ce client ne supporte pas encore un serveur MCP distant avec un en-tête d'authentification personnalisé, il se connecte donc via le pont mcp-remote (nécessite Node.js / npx). Maguyva tourne entièrement à distance — seul le pont tourne en local.

Docs MCP LibreChat →

Antigravity

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

Ajoutez à votre configuration MCP Antigravity :

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

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP Antigravity →

Claude Cowork

Claude Cowork utilise le même format MCP que les autres clients 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"
      }
    }
  }
}

Remplacez mgv_xxxx par votre clé API depuis app.maguyva.ai.

Docs MCP Claude Cowork →

ChatGPT

ChatGPT supporte les serveurs MCP distants sur les plans Business, Enterprise et Edu via Settings → Apps → Create. Un point de terminaison HTTPS distant est requis — ChatGPT ne supporte pas les serveurs stdio locaux. Voir le guide MCP d'OpenAI pour la configuration. Voir la doc →

Warp

Warp supporte les serveurs MCP en Agent Mode. La configuration se gère via l'interface Warp (Settings → Agent Mode → MCP Servers) et se synchronise via Warp Drive. Collez le JSON mcpServers standard lors de l'ajout d'un serveur. Voir la doc →

Maguyva utilise le standard MCP. N'importe quel client qui prend en charge le protocole peut se connecter — même sans guide officiel ci-dessus.24 clients documentés, d'autres ajoutés régulièrement.

Validez votre configuration#

Une fois connecté, essayez de poser quelques questions à votre agent :

  • "Quels dépôts ai-je connectés ?" — vérifie que la connexion fonctionne
  • "Comment l'authentification est-elle gérée dans cette base de code ?" — teste la recherche sémantique
  • "Trouve toutes les fonctions qui appellent la base de données" — teste la recherche de dépendances
  • "De quoi dépend la classe UserService ?" — teste la recherche de symboles

Vous devriez voir des résultats avec les chemins de fichiers et numéros de ligne de votre dépôt connecté. Sinon, consultez la section troubleshooting section ci-dessous.

Format du dépôt#

Lorsque vous spécifiez des dépôts :

  • Avec branche: "owner/repo:branch" (e.g., "owner/repository:develop")
  • Branche par défaut: "owner/repo"

Conseil : utilisez repository_context(action="info", repository="...") pour vérifier la résolution du dépôt. Le serveur v3 est sans état ; les remplacements de dépôt ne valent donc que pour un appel.

Dépannage#

Problèmes de clé API#

  • Vérifiez que votre clé commence par le préfixe mgv_
  • Vérifiez que la clé est correctement définie dans votre environnement
  • Assurez-vous que la clé n'a pas expiré

Dépôt introuvable#

  • Vérifiez que le dépôt est connecté dans app.maguyva.ai
  • Vérifiez que le format owner/repo est correct
  • Assurez-vous d'avoir accès au dépôt

Problèmes de connexion MCP#

  • Vérifiez que npx est disponible dans votre PATH
  • Vérifiez que votre jeton API est valide et non expiré
  • Testez la connectivité vers https://maguyva.tools/mcp
  • Vérifiez la syntaxe de configuration MCP de votre client

Étapes suivantes#