# Wenn es MCP spricht, spricht es Maguyva.

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

Die Integration ist nicht pro Tool — sie ist das Protokoll. Maguyva ist ein Standard-MCP-Server unter einer URL, damit jeder Client, in dem dein Agent läuft (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity, Zed, Cline oder etwas Selbstgebautes), dieselbe abfragbare Karte deines Repos bekommt. Einmal indexieren, und jeder verbundene Client stellt dieselben fundierten Fragen.

> Ein MCP-Server. Jeder Client. Kein Plugin pro Tool, kein Lock-in.

## Was jede Schicht macht

Vier Bausteine. Jeder hat eine Aufgabe.

### Jeder MCP-Client

23 dokumentierte Clients, darunter Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, oder dein eigener Agent.

### MCP

Der offene Standard, den jeder von ihnen bereits spricht.

### Maguyva

Ein MCP-Server. Fundierte Repo-Fakten, zurückgegeben mit file:line.

### Workspaces, keine Seats

Agents zahlen keine Seats. [Preise ansehen](https://maguyva.ai/de/pricing)

## MCP ist die Integration. Standardisiere darauf.

Das offene Protokoll ist die richtige Entscheidung, kein Workaround. Auf [MCP](https://modelcontextprotocol.io/docs/getting-started/intro) zu bauen statt auf ein Plugin pro Tool ist genau der Weg, um nicht jedes Mal neu zu integrieren, wenn ein besserer Agent erscheint. Das ist der richtige Ort für:

- Einen Server-Konfigurationsblock, der in jeden konformen Client passt.
- Tools und Ressourcen, die über Editoren, CLIs und Agents hinweg portabel sind.
- Eine Grenze, die dein Security-Team einmal prüfen kann, nicht pro Anbieter.
- Die Freiheit, Clients zu wechseln, ohne deinen Kontext-Stack neu aufzubauen.

Mach weiter so. Auf MCP zu standardisieren ist der richtige Zug.

Aber ein Protokoll ist eine Leitung. Es transportiert die Frage und die Antwort — es *kennt* deine Codebase nicht. Am anderen Ende muss etwas stehen, das deine Symbole, Aufrufstellen und Abhängigkeiten tatsächlich kartiert.

## Wo Kontext pro Tool aufhört zu skalieren

Vier Fehlermodi, die keine Rules-Datei eines einzelnen Agents beheben kann.

### // jedes tool onboardet wieder bei null

Wähl einen neuen Agent, und er startet wieder blind auf deinem Repo. Du fügst dieselben Dateien wieder ein, pinnst denselben Kontext wieder an, schreibst dieselben Regeln neu. Die Arbeit überträgt sich nicht, weil sie nie eine gemeinsame Schicht war.

### // rules-dateien reisen nicht mit

`CLAUDE.md`, `.cursor/rules`, `AGENTS.md` — jede ist pro Tool, und keine ist ein abfragbarer Index deines Codes. Wechsle den Client, und die Karte, die du von Hand gebaut hast, bleibt zurück.

### // integrations-lock-in ist eine steuer

Tiefen Codebase-Kontext in das Plugin eines Anbieters zu verdrahten bedeutet: Am Tag, an dem du einen anderen Agent ausprobierst, baust du es neu. Je besser dein Kontext, desto teurer wird der Wechsel.

### // das protokoll ist eine leitung, keine karte

MCP transportiert Tools und Kontext zwischen Client und Server. Es kennt deine Symbole, Aufrufstellen oder den Dependency-Graphen nicht. Am anderen Ende muss etwas stehen, das die Frage tatsächlich beantwortet.

## Maguyva ist die Schicht am anderen Ende des Protokolls

Kein weiterer Agent. Der Repo-Kontext-Server, den jeder MCP-Client aufrufen kann:

- **Ein Endpunkt, jeder Client**: derselbe `https://maguyva.tools/mcp` bedient Claude Code, Codex CLI, Gemini CLI, Cursor, Devin Desktop, Antigravity, oder ein Script, das du heute Morgen geschrieben hast.
- **Semantisch + AST + Graph + Text**: suche nach Bedeutung, Struktur, Abhängigkeit oder wörtlich. Jeder Treffer liefert einen Dateipfad und eine Zeilennummer, egal welcher Client gefragt hat.
- **Branch-bewusst, paketübergreifend**: Maguyva sieht die Version des Codes, die der Agent gerade bearbeitet, über jedes Paket im Monorepo hinweg.
- **Kein Lock-in**: wechsle Agents, wann immer du willst; die Kontextebene bleibt bestehen. Workspace-Preise, nicht pro Seat — indexiere 1 Repo oder 50.

> Dein Client spricht MCP.
> Maguyva antwortet, *wenn er nach deinem Code fragt.*

## Drei Workflows, identisch von jedem Client aus

Paket- und sprachübergreifend. Der Client wechselt; die quellenbelegte Antwort nicht.

### 01. Den Auth-Flow paketübergreifend finden, von jedem Agent aus

```text
agent> wo passiert Authentifizierung in diesem 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 Einstiegspunkte über 4 Packages, sortiert nach Aufrufstellen-Dichte.
[exit 0]
```

Claude Code, Cursor oder dein eigenes Skript — es spielt keine Rolle, welcher Client die Anfrage geschickt hat. Dieselben vier Dateien kommen in derselben Reihenfolge zurück, verankert im echten Graphen.

### 02. Die echte Implementierung finden, nicht den Test-Stub

```text
agent> wie behandelt normalizePhoneNumber E.164?

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

Namen lügen. Mocks überschatten echten Code. Maguyva reiht die echte Implementierung über dem Test-Mock ein — auf dieselbe Art für jeden Client, der fragt.

### 03. Auswirkungsradius prüfen, bevor ein Refactoring beginnt

```text
agent> was ruft QueueDispatcher.publish im gesamten Monorepo auf?

graph::callers(QueueDispatcher.publish)
  3 in packages/billing/*
  1 in packages/audit/*
  1 in packages/notifications/*
  1 in services/python-worker/*  ← sprachübergreifend über gRPC-Stub
[exit 0]
```

Paketübergreifend, und bei einem polyglotten Repo auch sprachübergreifend, tauchen Aufrufstellen inline auf. Wechsle morgen den Agent, und der Auswirkungsradius ist immer noch da, weil er im Server lebt, nicht im Client.

## Setup mit jedem MCP-Client

Drei Schritte. Free-Stufe: 3 Repositories, Bis zu 50K indexierte Repo-Zeilen, keine Kreditkarte.

### 01. Ein Repo auf maguyva.ai indexieren

Wähl eines, das du gut kennst, damit du die Antworten überprüfen kannst. Free-Stufe deckt 3 Repositories, Bis zu 50K indexierte Repo-Zeilen ab.

### 02. Maguyva als MCP-Server in dem Client hinzufügen, den du verwendest

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

### 03. Eine Frage stellen, deren Antwort du schon kennst

Fang mit einem Repo und einer überprüfbaren Frage an, etwa „was ruft `formatInvoice` paketübergreifend auf?“ Wenn die Antwort mit dem übereinstimmt, was du sagen würdest, bekommt jeder andere Client, den du darauf ansetzt, dasselbe quellenbelegte Ergebnis.

Client-spezifische Anleitungen (Claude Code, Codex, Cursor, Gemini, Devin Desktop, Antigravity und mehr) findest du in [den Kompatibilitäts-Docs von Maguyva](https://maguyva.ai/de/docs/compatibility).

## Indexiere ein Repo, das du schon kennst.

Verbinde einen beliebigen MCP-Client. Stell eine Frage, deren Antwort du überprüfen kannst.

## Quellen

- [MCP: offizielle Einführung](https://modelcontextprotocol.io/docs/getting-started/intro)
- [MCP: Beispiel-Clients](https://modelcontextprotocol.io/clients)
- [Maguyva: Kompatibilität & Clients](https://maguyva.ai/de/docs/compatibility)
- [Maguyva: Stack & Sicherheit](https://maguyva.ai/de/stack)
- [Maguyva: Preise (Workspace, nicht pro Seat)](https://maguyva.ai/de/pricing)