Für jeden MCP-fähigen Client

Wenn es MCP spricht,
spricht es Maguyva.

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

Kostenlos starten MCP-Setup lesen

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

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

Was jede Schicht macht

Vier Bausteine. Jeder hat eine Aufgabe.

// dein Client

Jeder MCP-Client

24 dokumentierte Clients, darunter Claude Code, Codex CLI, Gemini CLI, Cursor, Windsurf, Antigravity, oder dein eigener Agent.

// protokoll

MCP

Der offene Standard, den jeder von ihnen bereits spricht.

// codebase

Maguyva

Ein MCP-Server. Fundierte Repo-Fakten, zurückgegeben mit Datei:Zeile.

// wer zahlt

Workspaces, keine Seats

Agenten zahlen keine Seats. Preise ansehen

MCP ist die Integration. Standardisiere darauf.

Das offene Protokoll ist die richtige Entscheidung, kein Workaround. Auf MCP 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 Agenten 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 Agenten beheben kann.

// jedes tool onboardet wieder bei null

Wähl einen neuen Agenten, 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 Agenten 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 Abhängigkeitsgraphen 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, Windsurf, 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 Agenten, 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 verankerte Antwort nicht.

// workflow 01

Den Auth-Flow paketübergreifend finden, von jedem Agenten aus

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 Graph.

// workflow 02

Die echte Implementierung finden, nicht den Test-Stub

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.

// workflow 03

Auswirkungsradius prüfen, bevor ein Refactoring beginnt

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 Agenten, 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 Karte.

// step 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.

// step 02

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

// 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

// step 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 verankerte Ergebnis.