Agentic RAG MCP: Wissensarchitektur, Code Execution und Enterprise-Sicherheit

Agentic RAG MCP steht für die Weiterentwicklung klassischer Retrieval-Augmented-Generation-Systeme durch das offene Model Context Protocol. Agentic RAG mit MCP ist ein Retrieval-Ansatz, bei dem ein KI-Agent über das Model Context Protocol selbst entscheidet, welche Datenquellen er in welcher Reihenfolge abfragt. Während klassische RAG-Pipelines eine Anfrage einmal in einen Vektor umwandeln und die obersten Treffer an das Sprachmodell übergeben, entscheidet der Agent hier, welche Quellen er nutzt, wie er Zwischenergebnisse verknüpft und welche Filter er anwendet.

In vielen Unternehmen zeigt der einfache Ansatz deutliche Schwächen: Vektorsuchen liefern bei ungenauen Fragen unpassende Textstellen, strukturierte SQL-Tabellen bleiben außen vor, und das Kontextfenster läuft mit ungefilterten Rohdaten voll. Agentische Abfragestrategien und ein standardisiertes Schnittstellenprotokoll ergeben zusammen einen belastbaren Rahmen für Unternehmenswissen, der Skalierbarkeit, Sicherheit und Kosteneffizienz verbindet. Stand: MCP-Spezifikation 2026-07-28.

Warum klassisches RAG für komplexe Unternehmensdaten an Grenzen stößt

Klassisches Retrieval Augmented Generation folgt einem festen Einwegpfad. Ein Dokument wird in Chunks zerlegt, durch ein Embedding-Modell geschickt und in einer Vektordatenbank indexiert. Stellt ein Nutzer eine Frage, sucht das System nach inhaltlich ähnlichen Abschnitten und hängt sie an den Prompt. Dieser Ablauf scheitert in der Praxis regelmäßig an drei Punkten:

1. Antworten, die mehrere Abfragen nacheinander brauchen: Muss eine Antwort aus verschiedenen Systemen kombiniert werden, etwa Kundendaten aus einem CRM und Verträge aus einer Dokumentenablage, kann ein einzelner Vektorvergleich diese Beziehung nicht herstellen.
2. Überfülltes Kontextfenster: Werden zu viele Rohdaten unkritisch in den Prompt geladen, steigt der Token-Verbrauch stark an. Modelle nutzen Informationen in der Mitte langer Kontexte zudem schlechter („Lost in the Middle“).
3. Mangelnde Aktualität und fehlender Kontext: Reine Text-Embeddings erfassen keine tabellarischen Kennzahlen oder zeitabhängigen Änderungen in SQL-Datenbanken.

Agentische Architekturen behandeln die Suche deshalb als schrittweisen Lösungsprozess. Statt einer einmaligen Vektorsuche fragt der Agent Daten schrittweise ab und filtert sie: Er formuliert Zwischenfragen, bewertet die Qualität der gelieferten Dokumente und fordert bei Bedarf gezielt weitere Details an.

Wie MCP Agentic RAG standardisiert: Host, Client, Server und Grundbausteine

Das Model Context Protocol wurde 2024 von Anthropic vorgestellt und im Dezember 2025 an die Agentic AI Foundation (Linux Foundation) übergeben. Es schafft eine herstellerunabhängige Schicht zwischen Sprachmodellen und internen Datenquellen. Bislang mussten Entwickler für jedes System eigene Schnittstellen programmieren: Eine Abfrage an Postgres brauchte eigene LangChain- oder LlamaIndex-Bausteine, eine Suche in Confluence ein weiteres Plugin. Bei N Modellen und M Datenquellen braucht man ohne Standard N×M Einzelanbindungen. MCP löst das mit einer einheitlichen Client-Server-Architektur auf Basis von JSON-RPC 2.0, übertragen per stdio (lokal) oder Streamable HTTP (remote).

Die Rollen sind klar verteilt: Die LLM-Anwendung (Host, z. B. Claude Desktop) baut über je einen MCP-Client die Verbindung zu einem oder mehreren MCP-Servern auf. Der Server stellt die Daten und Funktionen bereit. Das Protokoll definiert drei Grundbausteine auf Serverseite:

• Ressourcen (Resources): Datenquellen mit eigener URI wie Dokumente, Logdateien oder Datenbank-Snapshots, die der Host auslesen kann.
• Werkzeuge (Tools): Ausführbare Funktionen, mit denen der Agent Aktionen auslöst, etwa eine parametrisierte Suche oder einen Schreibvorgang.
• Prompts: Vom Nutzer auswählbare Vorlagen für wiederkehrende Abläufe, die der Server bereitstellt.

Durch diese Struktur weiß der Agent genau, welche Operationen ihm zur Verfügung stehen. Ein praktisches Beispiel ist das Projekt RAG-Wissensbasis mit MCP-Server, in dem eine zentrale Wissensbasis von externen Agenten als Werkzeug angesprochen wird.

Architektur-Blueprint: Vektordatenbanken und SQL als MCP-System anbinden

Ein unternehmenstaugliches Agentic-RAG-System trennt Speicherebenen, Vermittlungslogik und Anwendungen strikt voneinander. Der MCP-Server bündelt unterschiedliche Datenspeicher und macht sie für den Agenten verständlich. Generierter Code läuft dabei nicht auf dem Server, sondern in einer Sandbox auf Seite des Agenten bzw. Clients, die von dort die MCP-Server aufruft.

+-------------------------------------------------------------+
|            LLM-Anwendung / Agent (Host)                     |
|           (Claude Desktop, eigene App, Chatbot)             |
|  +----------------------+  +-----------------------------+  |
|  | MCP-Client(s)        |  | Code-Execution-Sandbox (TS) |  |
|  +----------------------+  +-----------------------------+  |
+-------------------------------------------------------------+
                               | JSON-RPC 2.0 (stdio / Streamable HTTP)
                               v
+-------------------------------------------------------------+
|                      MCP-Server (Gateway)                   |
|        Autorisierung (OAuth 2.1, Resource Server)           |
|        Rechtefilter pro Abfrage                             |
+-------------------------------------------------------------+
          |                                        |
          v Tool / Resource                        v Tool / Resource
+--------------------+                   +--------------------+
| Vektordatenbank    |                   | SQL / relational   |
| (Qdrant, pgvector) |                   | (PostgreSQL, ERP)  |
+--------------------+                   +--------------------+

In dieser Architektur stellt der MCP-Server spezialisierte Tools bereit. Statt dem Agenten vollen Schreibzugriff auf Datenbanken zu geben, stellt der Server eng begrenzte Werkzeuge bereit, etwa search_knowledge_base(query, category) oder query_customer_metrics(customer_id). Beim Aufbau eines MCP-Servers mit n8n lassen sich bestehende Low-Code-Workflows als MCP-Werkzeuge bereitstellen, sodass vorhandene Geschäftslogik erhalten bleibt.

Auch mobile Geräte und Sprachagenten profitieren von dieser Entkopplung: Im Projekt Hermes Pocket AI Agent nutzt ein Hardware-Agent dieselben MCP-Mechanismen, um unterwegs auf interne Daten zuzugreifen, ohne dass die Anwendungslogik auf dem Gerät liegen muss.

Überfülltes Kontextfenster vermeiden: Warum Code Execution mit MCP Tokens spart

Ein großes Problem klassischer Tool-Aufrufe sind ungefilterte Tool-Ergebnisse im Prompt. Liefert eine Suche 50 Chunks oder 5.000 Tabellenzeilen, landen all diese Rohdaten im Kontextfenster. Das treibt die Token-Kosten und verlangsamt die Antwort.

Anthropic (November 2025) und zuvor Cloudflare („Code Mode“) beschreiben dafür einen anderen Ansatz: Statt jedes Werkzeug einzeln aufzurufen und die JSON-Rückgabe in den Kontext zu laden, generiert das Modell Code (bei Anthropic: TypeScript), der MCP-Tools wie normale Funktionen aufruft. Der Code läuft in einer Sandbox auf Seite des Agenten bzw. Clients und ruft von dort die MCP-Server auf. Filterungen, Aggregationen und Berechnungen passieren in dieser Umgebung; an das Modell geht nur das verdichtete Ergebnis zurück.

In einem Beispiel von Anthropic sinkt der Verbrauch von 150.000 auf 2.000 Tokens (−98,7 %). Ein kleiner Benchmark von AIMultiple mit zwei Aufgaben maß 78,5 % weniger Input-Tokens. Für Agentic-RAG-Systeme heißt das: Ein Agent kann hunderte Textstellen durchsuchen, reguläre Ausdrücke anwenden oder Tabellenspalten summieren, ohne dass überflüssige Rohdaten das Kontextfenster füllen.

Enterprise-Sicherheit: Authentifizierung mit OAuth 2.1 und Berechtigungsgrenzen

In produktiven Umgebungen dürfen Wissensbasen nicht als ungesicherte Datensilos laufen. Die Personalabteilung braucht Zugriff auf Gehaltsstrukturen, Entwickler durchsuchen Code-Repositories, Projektmanager lesen Statusberichte. In herkömmlichen RAG-Implementierungen war diese feingliedrige Zugriffskontrolle oft eine Fehlerquelle.

Für lokale Verbindungen nutzt MCP stdio: Der Server läuft als Subprozess im Sicherheitskontext des lokalen Benutzers. Für verteilte Szenarien sieht die Spezifikation Streamable HTTP vor. Autorisierung ist optional. Wird sie über HTTP umgesetzt, folgt sie OAuth 2.1, und der MCP-Server agiert als Resource Server:

• Token-basierte Autorisierung: Jeder Aufruf wird durch ein Access Token (oft ein JWT) legitimiert. Rollenbasierte Filter muss der Server selbst umsetzen; die Spezifikation regelt sie nicht.
• Automatische Rechtefilter: Der Server ergänzt jede Abfrage um die Rechte des Nutzers, bevor er eine Vektorsuche oder ein SQL-Select ausführt (z. B. tenant_id = user.tenant_id AND group IN (user.groups)).
• Auditierbarkeit: Jeder Aufruf eines MCP-Tools lässt sich mit Benutzer-ID, Zeitstempel und Parametern lückenlos protokollieren. So lassen sich Prüfpflichten erfüllen und Missbrauch, etwa durch Prompt Injection, im Nachhinein aufdecken.

Schritt-für-Schritt: Einen RAG-MCP-Server aufsetzen und in Claude integrieren

Das folgende Beispiel zeigt einen schlanken RAG-MCP-Server mit dem offiziellen TypeScript SDK (@modelcontextprotocol/sdk, Version 1.x, getestet mit 1.32.1) und der aktuellen Klasse McpServer. Der Server stellt ein Tool bereit, das eine semantische Suche auf einer Vektordatenbank kapselt.

1. Initialisierung und Abhängigkeiten

Erstelle ein neues Node.js-Projekt und installiere das MCP SDK sowie die Hilfspakete:

mkdir mcp-rag-server
cd mcp-rag-server
npm init -y
npm pkg set type=module
npm install @modelcontextprotocol/sdk@1 zod@3
npm install -D typescript @types/node
npx tsc --init --rootDir src --outDir build --module node16 --moduleResolution node16 --target es2022

"type": "module" in der package.json sorgt dafür, dass Node die kompilierten ES-Module lädt. rootDir und outDir legen fest, dass der Quellcode in src/ liegt und das Ergebnis in build/ landet.

2. Implementierung des MCP-Servers

Erstelle die Datei src/index.ts. Der Server registriert ein Tool namens search_knowledge_base, führt die Abfrage gegen einen Vektorspeicher aus und liefert die relevantesten Abschnitte zurück:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({
  name: "enterprise-rag-server",
  version: "1.0.0",
});

server.registerTool(
  "search_knowledge_base",
  {
    title: "Wissensbasis durchsuchen",
    description: "Sucht in der internen Wissensbasis nach relevanten Dokumenten.",
    inputSchema: {
      query: z.string().describe("Die semantische Suchanfrage"),
      top_k: z
        .number()
        .int()
        .min(1)
        .max(20)
        .default(3)
        .describe("Anzahl der zurückzugebenden Abschnitte"),
    },
  },
  async ({ query, top_k }) => {
    // Platzhalter: Hier erfolgt der Aufruf an Qdrant, Pinecone oder pgvector
    const searchResults = [
      {
        id: "doc_101",
        score: 0.92,
        content: `Auszug für "${query}": Interne Richtlinie zu Remote-MCP-Servern erfordert OAuth 2.1.`,
      },
    ].slice(0, top_k);

    return {
      content: [{ type: "text", text: JSON.stringify(searchResults, null, 2) }],
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Anschließend den Code kompilieren:

npx tsc

3. Konfiguration in Claude Desktop

Um den Server in Claude Desktop einzubinden, wird der Build-Pfad in der Konfigurationsdatei (claude_desktop_config.json) hinterlegt:

{
  "mcpServers": {
    "wissensbasis": {
      "command": "node",
      "args": ["/pfad/zu/mcp-rag-server/build/index.js"],
      "env": {
        "DB_HOST": "https://example.com/vector-db",
        "DB_KEY": "<SCHLÜSSEL>"
      }
    }
  }
}

Nach dem Neustart erkennt Claude das Werkzeug und schlägt es vor, sobald eine passende Frage kommt. Den Aufruf bestätigt der Nutzer.

Best Practices für skalierbare KI-Wissenssysteme in der Praxis

Der Betrieb von Agentic RAG mit MCP in Produktivumgebungen verlangt Disziplin bei Architektur und Monitoring:

• Hybride Suche nutzen: Verlasse dich nicht nur auf Vektoren. Eine Kombination aus Bedeutungssuche und klassischer Stichwortsuche (BM25) findet Fachbegriffe und Teilenummern zuverlässiger. Warum das wirkt, beschreibt der Beitrag Company Brain aufbauen.
• Reranking integrieren: Schalte vor die Rückgabe an das Sprachmodell einen schnellen Reranker (z. B. Cohere Rerank oder BGE-Reranker), damit die inhaltlich treffendsten Abschnitte oben stehen.
• Feste Timeouts und wiederholbare Aufrufe: Abfragen an externe Datenbanken brauchen klare Timeouts. Agenten dürfen bei Abbrüchen keine inkonsistenten Zustände hinterlassen.
• Sandboxing für Code Execution: Wird generierter Code ausgeführt, muss das in isolierten Umgebungen wie Firecracker-MicroVMs oder abgesicherten Containern ohne Zugriff auf das Host-System geschehen.

Agentic RAG über das Model Context Protocol macht die Anbindung von Unternehmenswissen flexibler, sparsamer und besser kontrollierbar. Entwickler erhalten damit eine Blaupause, um KI-Systeme strukturiert und mit klaren Sicherheitsgrenzen an das Wissen ihrer Organisation anzubinden.