Zum Inhalt springen

Installationsanleitung

Sei in unter 5 Minuten startklar. Diese Anleitung enthält das Setup für 23 MCP-Clients, darunter Claude Code, Claude Desktop, Cursor, VS Code / GitHub Copilot und Devin Desktop (Windsurf) und mehr.

Voraussetzungen: Du brauchst einen API-Key von app.maguyva.ai und ein verbundenes GitHub-Repository.

Umgebungseinrichtung

#

Lege zuerst deinen API-Schlüssel in einer Umgebungsvariable fest. Lass repository weg, wenn dein MCP-Client einen Standardwert für die Anfrage bereitstellt oder der Schlüssel auf genau ein Repository zugreifen kann; übergib es andernfalls ausdrücklich.

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

Ersetze mgv_xxxx durch deinen tatsächlichen API-Key von app.maguyva.ai.

Client-Konfiguration

#

Wähle unten deinen MCP-Client für spezifische Einrichtungsanweisungen.

Kompatibilitätshinweis: Maguyva verwendet Standard-MCP. Jeder Client mit MCP-Unterstützung kann sich mit demselben Server verbinden, auch wenn wir noch keine offizielle Einrichtungsanleitung dafür geschrieben haben.

Claude Code

Installiere das Maguyva-Plugin aus dem Claude Code Marketplace:

Füge den Maguyva-Marketplace hinzu und installiere dann das Plugin (führe jeden Befehl innerhalb von Claude Code aus):

/plugin marketplace add maguyva/agent-plugins
/plugin install maguyva@maguyva

/plugin install öffnet die Details des Plugins, wo du den Installationsbereich wählst: nur du (user), alle, die in diesem Repository arbeiten (project), oder nur du in diesem Repository (local). Diese Befehle innerhalb der Sitzung haben kein --scope-Flag.

Das Plugin authentifiziert sich über die Umgebungsvariable MAGUYVA_API_KEY. Setze sie in deiner Shell:

export MAGUYVA_API_KEY=mgv_xxxx

Projektspezifisches direnv (.envrc) wird empfohlen — Keys sind repository-scoped, daher passt ein projektspezifischer Wert zum Zugriff jedes Projekts. Ein globaler Shell-Export funktioniert, wenn ein einziger Key deine gesamte Arbeit abdeckt.

Für ein Team kannst du stattdessen die Shell-Form beider Befehle im Stammverzeichnis des Repositorys ausführen, außerhalb von Claude Code:

claude plugin marketplace add maguyva/agent-plugins --scope project
claude plugin install maguyva@maguyva --scope project

Der Bereich project trägt das Plugin in die .claude/settings.json des Repositorys ein, die du committest. Damit ist das Plugin für Teammitglieder aktiviert, wird aber nicht heruntergeladen, deshalb führt jedes Teammitglied den Installationsbefehl einmal aus.

Manuell (.mcp.json) — fortgeschritten
claude mcp add 
claude mcp add --transport http maguyva https://maguyva.tools/mcp --header 'Authorization: Bearer ${MAGUYVA_API_KEY}'
.mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "type": "http",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer ${MAGUYVA_API_KEY}"
      }
    }
  }
}

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Was Maguyva für Claude Code bringt →

Claude Code-MCP-Docs →

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

Füge es zu deiner Claude Desktop Konfigurationsdatei hinzu:

claude_desktop_config.json 
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "@maguyva/mcp"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

claude_desktop_config.json startet nur lokale Server, deshalb nutzt dieses Setup die @maguyva/mcp-Bridge (benötigt Node.js / npx). Claude Desktop kann Maguyva auch als benutzerdefinierten Connector (Customize → Connectors) mit einem authorization-Request-Header erreichen, aber Request-Header sind eine Beta für eine begrenzte Zahl von Organisationen.

Was Maguyva für Claude Desktop bringt →

Claude Desktop-MCP-Docs →

Cursor

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

Füge es zu .cursor/mcp.json im Stammverzeichnis deines Projekts hinzu:

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

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

Was Maguyva für Cursor bringt →

Cursor-MCP-Docs →

VS Code / GitHub Copilot

Füge es in .vscode/mcp.json in deinem Projekt hinzu oder in die mcp.json deines Profils (führe MCP: Open User Configuration aus):

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

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

Das ist das VS Code-Format (Schlüssel servers). VS Code löst die Referenz auf MAGUYVA_API_KEY aus der Umgebung auf, in der es startet. Der Add-Server-Ablauf bevorzugt inzwischen die portable .mcp.json (Schlüssel mcpServers), die auch GitHub Copilot CLI liest; diese Datei unterstützt keine Input-Variablen oder Umgebungsdateien von VS Code.

Was Maguyva für VS Code / GitHub Copilot bringt →

VS Code / GitHub Copilot-MCP-Docs →

Devin Desktop (Windsurf)

macOS: ~/.config/devin/mcp_config.json
Windows: %APPDATA%\devin\mcp_config.json
Linux: ~/.config/devin/mcp_config.json

Windsurf heißt jetzt Devin Desktop. Füge es in dessen MCP-Konfigurationsdatei ein:

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

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

Devin Local, der Standard-Agent, liest diese Datei ab Version 3.6; ältere Versionen speicherten Server in der Hauptkonfigurationsdatei und verschieben sie beim Start hierher. Der alte Cascade-Agent, mit dem neue Unterhaltungen nicht starten, liest dieselbe Datei. Devin Desktop löst die Referenz auf MAGUYVA_API_KEY aus der Umgebung auf, in der es startet.

Was Maguyva für Devin Desktop (Windsurf) bringt →

Devin Desktop (Windsurf)-MCP-Docs →

Codex

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

Füge es zu deiner Codex CLI Konfiguration hinzu (~/.codex/config.toml):

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

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

Was Maguyva für Codex bringt →

Codex-MCP-Docs →

GitHub Copilot CLI

Füge es zu ~/.copilot/mcp-config.json hinzu:

~/.copilot/mcp-config.json 
{
  "mcpServers": {
    "maguyva": {
      "type": "http",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      }
    }
  }
}
copilot mcp add 
copilot mcp add --transport http --header "Authorization: Bearer mgv_xxxx" maguyva https://maguyva.tools/mcp

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Was Maguyva für GitHub Copilot CLI bringt →

GitHub Copilot CLI-MCP-Docs →

Gemini CLI

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

Füge es zu deinen Gemini CLI Einstellungen hinzu (~/.gemini/settings.json):

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

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

Was Maguyva für Gemini CLI bringt →

Gemini CLI-MCP-Docs →

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

Füge es zu deinen Cline-MCP-Einstellungen hinzu:

cline_mcp_settings.json 
{
  "mcpServers": {
    "maguyva": {
      "type": "streamableHttp",
      "url": "https://maguyva.tools/mcp",
      "headers": {
        "Authorization": "Bearer mgv_xxxx"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Was Maguyva für Cline bringt →

Cline-MCP-Docs →

Goose

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

Füge es zu deiner Goose-Konfiguration hinzu:

config.yaml 
extensions:
  maguyva:
    name: maguyva
    type: streamable_http
    uri: https://maguyva.tools/mcp
    enabled: true
    headers:
      Authorization: Bearer mgv_xxxx
    timeout: 300

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Was Maguyva für Goose bringt →

Goose-MCP-Docs →

LM Studio

Öffne in LM Studio den Tab Program in der rechten Seitenleiste, wähle Install → Edit mcp.json und füge hinzu:

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

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

LM Studio-MCP-Docs →

Continue

Speichere es als .continue/mcpServers/maguyva.yaml in deinem Workspace (oder füge den mcpServers-Eintrag in ~/.continue/config.yaml ein) und setze dann MAGUYVA_API_KEY in ~/.continue/.env:

.continue/mcpServers/maguyva.yaml 
name: Maguyva
version: 0.0.1
schema: v1
mcpServers:
  - name: maguyva
    type: streamable-http
    url: https://maguyva.tools/mcp
    requestOptions:
      headers:
        Authorization: Bearer ${{ secrets.MAGUYVA_API_KEY }}

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

Continue nutzt MCP-Server nur im Agent-Modus. Das Secret sucht es in ~/.continue/.env, dann in .continue/.env und .env im Workspace, dann in der Prozessumgebung.

Was Maguyva für Continue bringt →

Continue-MCP-Docs →

Kiro CLI (Amazon Q Developer CLI)

macOS: ~/.kiro/settings/mcp.json
Windows: %USERPROFILE%\.kiro\settings\mcp.json
Linux: ~/.kiro/settings/mcp.json

Füge es in die MCP-Konfiguration von Kiro CLI ein (~/.kiro/settings/mcp.json oder .kiro/settings/mcp.json in einem Projekt):

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

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Kiro CLI hat Amazon Q Developer CLI abgelöst. Bei der Installation kopiert es deine Server einmalig aus ~/.aws/amazonq/mcp.json nach ~/.kiro/settings/mcp.json, und die .kiro/settings/mcp.json eines Projekts hat Vorrang vor der Benutzerdatei.

Kiro CLI (Amazon Q Developer CLI)-MCP-Docs →

PyCharm

Füge es unter Settings | Tools | AI Assistant | Model Context Protocol (MCP) → Add als JSON-Konfiguration ein: 

{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "@maguyva/mcp"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Diese Einrichtung verwendet die Bridge @maguyva/mcp (erfordert Node.js / npx). Eine native Remote-Konfiguration für diesen Client wurde für diese Anleitung noch nicht verifiziert; das bedeutet nicht, dass der Client keine nativen Remote-Verbindungen unterstützt. Maguyva läuft vollständig remote — nur die Bridge läuft lokal.

PyCharm-MCP-Docs →

Zed

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

Füge es zu deinen Zed-Einstellungen hinzu (~/.config/zed/settings.json):

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

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Was Maguyva für Zed bringt →

Zed-MCP-Docs →

Trae

Schalte unter Settings → MCP die Option Enable Project MCP ein und füge es dann in .trae/mcp.json im Projektstamm ein:

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

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Trae-MCP-Docs →

OpenCode

Füge es zu opencode.json im Stammverzeichnis deines Projekts hinzu:

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

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

Was Maguyva für OpenCode bringt →

OpenCode-MCP-Docs →

BoltAI

macOS: ~/.boltai/mcp.json

Füge es zu deiner BoltAI-MCP-Konfiguration hinzu:

mcp.json 
{
  "mcpServers": {
    "maguyva": {
      "command": "npx",
      "args": [
        "-y",
        "@maguyva/mcp"
      ],
      "env": {
        "MAGUYVA_API_KEY": "mgv_xxxx"
      }
    }
  }
}

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Diese Einrichtung verwendet die Bridge @maguyva/mcp (erfordert Node.js / npx). Eine native Remote-Konfiguration für diesen Client wurde für diese Anleitung noch nicht verifiziert; das bedeutet nicht, dass der Client keine nativen Remote-Verbindungen unterstützt. Maguyva läuft vollständig remote — nur die Bridge läuft lokal.

BoltAI-MCP-Docs →

LibreChat

Füge es in librechat.yaml ein und setze MAGUYVA_API_KEY in der Umgebung des LibreChat-Servers:

librechat.yaml 
mcpServers:
  maguyva:
    type: streamable-http
    url: https://maguyva.tools/mcp
    headers:
      Authorization: Bearer ${MAGUYVA_API_KEY}
    requiresOAuth: false

Diese Konfiguration liest deinen Key aus der Umgebungsvariable MAGUYVA_API_KEY. Setze sie auf deinen API-Key von app.maguyva.ai, und zwar in der Umgebung, aus der dein Client startet.

LibreChat-MCP-Docs →

Antigravity

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

Füge es zu deiner Antigravity-MCP-Konfiguration hinzu:

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

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Was Maguyva für Antigravity bringt →

Antigravity-MCP-Docs →

Claude Cowork

Claude Cowork lädt keine Server aus claude_desktop_config.json; es erreicht Remote-Server als benutzerdefinierte Connectors. Füge unter Customize → Connectors einen benutzerdefinierten Connector mit der URL https://maguyva.tools/mcp hinzu, wähle No sign-in und füge einen authorization-Request-Header hinzu, dessen Wert Bearer gefolgt von deinem API-Schlüssel ist. Request-Header sind eine Beta für eine begrenzte Zahl von Organisationen; hat der Dialog keinen Abschnitt Request headers, kann sich Cowork noch nicht bei Maguyva authentifizieren. Docs ansehen →

ChatGPT

ChatGPT unterstützt Remote-MCP-Server in den Plänen Business, Enterprise und Edu über Settings → Apps → Create. Ein Remote-HTTPS-Endpunkt ist erforderlich — ChatGPT unterstützt keine lokalen stdio-Server. Die Einrichtung ist im MCP-Guide von OpenAI beschrieben. Docs ansehen →

Warp

Füge es in ~/.warp/.mcp.json ein (oder in .warp/.mcp.json in einem Projekt) oder füge es unter Settings → Agents → MCP servers → + Add ein:

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

Ersetze mgv_xxxx durch deinen API-Key von app.maguyva.ai.

Was Maguyva für Warp bringt →

Warp-MCP-Docs →

Maguyva verwendet Standard-MCP. Jeder Client, der das Protokoll unterstützt, kann sich verbinden — auch wenn oben keine offizielle Anleitung existiert. 23 Clients dokumentiert, weitere kommen regelmäßig dazu.

Überprüfe dein Setup

#

Stell deinem Agent nach dem Verbinden ein paar Fragen:

  • "Welche Repositories habe ich verbunden?" — überprüft, ob die Verbindung funktioniert
  • "Wie wird die Authentifizierung in dieser Codebase gehandhabt?" — testet die semantische Suche
  • "Finde alle Funktionen, die die Datenbank aufrufen" — testet die Abhängigkeitssuche
  • "Wovon hängt die Klasse UserService ab?" — testet Symbol Lookup

Du solltest Ergebnisse mit Dateipfaden und Zeilennummern aus deinem verbundenen Repository sehen. Falls nicht, wirf einen Blick in die troubleshooting section unten.

Repository-Format

#

Beim Angeben von Repositories:

  • Mit Branch: "owner/repo:branch" (e.g., "owner/repository:develop")
  • Standard-Branch: "owner/repo"

Tipp: Prüfe mit repository_context(action="info", repository="...") die Repository-Auflösung. Eine explizite Repository-Überschreibung gilt nur für den aktuellen Aufruf.

Fehlerbehebung

#

API-Key-Probleme

#
  • Überprüfe, dass dein Key mit dem Präfix mgv_ beginnt
  • Überprüfe, dass der Key korrekt in deiner Umgebung gesetzt ist
  • Stelle sicher, dass der Key nicht abgelaufen ist

Repository nicht gefunden

#
  • Überprüfe, dass das Repository in app.maguyva.ai verbunden ist
  • Überprüfe, dass das Format owner/repo korrekt ist
  • Stelle sicher, dass du Zugriff auf das Repository hast

MCP-Verbindungsprobleme

#
  • Falls dein Client die Bridge @maguyva/mcp verwendet, prüfe, ob npx über deinen PATH verfügbar ist
  • Überprüfe, dass dein API-Token gültig und nicht abgelaufen ist
  • Teste die Verbindung zu https://maguyva.tools/mcp
  • Überprüfe die MCP-Konfigurationssyntax deines Clients

Nächste Schritte

#

Verwandt

Weiterlesen