MCP Registry & AI Gateway: Architektur und Enterprise-Anwendungsfälle

Auf Geschwindigkeit ausgelegt: ~ 10 ms Latenz, auch unter Last
Unglaublich schnelle Methode zum Erstellen, Verfolgen und Bereitstellen Ihrer Modelle!
- Verarbeitet mehr als 350 RPS auf nur 1 vCPU — kein Tuning erforderlich
- Produktionsbereit mit vollem Unternehmenssupport
Zwischen 2020 und 2023 haben Foundation-Modelle wie GPT-3 und GPT-4 bewiesen, dass Large Language Models menschenähnlichen Text generieren, Code schreiben, Dokumente zusammenfassen und komplexe Fragen beantworten können. Allerdings waren diese Modelle zustandslos und liefen in einer Sandbox; sie hatten keinen Zugriff auf interne Systeme, Datenbanken oder Apps — und besaßen keine Möglichkeit, tatsächlich Handlungen in der realen Welt auszuführen.
Sie konnten ein Modell beispielsweise fragen:
„Schreibe eine MongoDB-Abfrage, um alle Collections in der Compliance-Datenbank aufzulisten.“
Es generierte eine Ausgabe, die wie eine gültige MongoDB-Abfrage aussah — aber:
- Es hatte keine Ahnung, ob die Datenbank überhaupt existierte
- Es wusste nicht, welche Collections in der DB vorhanden waren
- Es konnte nicht sagen, ob die Abfrage überhaupt auszuführen war
- Es gab keine Möglichkeit, Schemas zu prüfen, Ergebnisse zu verifizieren oder Folgeaktionen auszulösen wie etwa das Zusammenfassen von Daten oder das Benachrichtigen eines anderen Systems
Es war reines Ratenn — ohne jede Feedbackschleife.
Um dies zu beheben, begannen Entwickler, Schichten um LLMs herum zu bauen:
- Prompt Chaining
- Eigene Wrapper in Python
- REST-API-Aufrufinjektion über String-Templates
- Manuelles Context Stuffing
(„Verwende das folgende Schema und schreibe die Abfrage“)
Dies waren zwar clevere Behelfslösungen, aber schwer zu warten.
Frameworks wie LangChain, LlamaIndex und Semantic Kernel entstanden, um diese Workflows zu strukturieren. Diese Tools halfen zwar bei der Organisation, aber die grundlegenden Probleme blieben bestehen. Modelle halluzinierten weiterhin Felder, fielen auf Prompt-Injections herein, übersprangen Validierungen und verfügten über keinen Standardweg, um tatsächlich definierte Funktionen auszuführen. Jeder neue Anwendungsfall fühlte sich immer noch so an, als müsste das Rad neu erfunden werden.
Der echte Wendepunkt kam, als Entwickler erkannten:
„Wir brauchen keine Modelle, die Befehle erraten. Wir brauchen Modelle, die reale Funktionen aufrufen — genau so, wie Frontend-Apps Backend-APIs aufrufen.“
Mitte 2023 führte OpenAI das Function Calling ein, was es Modellen ermöglichte, strukturierte JSON-Ausgaben zurückzugeben, die direkt auf reale Funktionsaufrufe abgebildet werden konnten.
Dies definierte neu, was mit Modellintegration möglich war:
- LLMs konnten nun über klar definierte Ein- und Ausgaben mit Tools interagieren
- Modelle verhielten sich wie API-Clients und nicht wie auf Vermutungen basierende Generatoren
- Aufgaben konnten nun über mehrere Schritte und Systeminteraktionen hinweg automatisiert werden
Mit Function Calling stieg der Einsatz von Tools und Agenten — Modellen, die Aktionen verketten, Workflows befolgen und mit realen Systemen interagieren konnten.
Aber…
1. Jede Implementierung war anbieterspezifisch.
2. Es gab keinen gemeinsamen Standardformat-Standard dafür, wie Tools beschrieben oder aufgerufen wurden.
Hier kommt MCP (Model Context Protocol) ins Spiel — vorgeschlagen als generelles, offenes Protokoll für die strukturierte Kommunikation zwischen Modellen und externen Tools. Anstatt Tool-APIs fest in jede LLM-App zu verdrahten, bietet MCP ein universelles Ladegerät für KI-Tool-Verbindungen — ähnlich wie OpenAPI, Anthropic etc., aber speziell für LLMs, die Tools aufrufen. Es basiert auf JSON-RPC 2.0, einer weit verbreiteten Spezifikation, die Remote Procedure Calls (RPCs) mittels JSON unterstützt.
Was MCP definiert
- Wie ein Modell eine Tool-Methode aufrufen kann (z. B. runAggregation)
- Wie Parameter übergeben und strukturierte Antworten empfangen werden
- Wie Tools ihre verfügbaren Methoden beschreiben (über Schemas oder Manifeste)
- Einen leichtgewichtigen Standard für die Tool-Integration über jedes beliebige Backend hinweg (DB, CLI, Cloud-API)
Stellen Sie sich MCP als den API-Vertrag zwischen einem Modell und einem Tool vor. Ohne ein Standardprotokoll erforderte jede Integration individuelles Engineering — teuer, fehleranfällig und repetitiv. MCP löste dies durch die Schaffung einer universellen Sprache und vereinfachte Tool-Integrationen ein für alle Mal. Aber was genau ist MCP und wie funktioniert es in der Praxis? Tauchen wir tiefer ein.
Model Context Protocol
MCP (Model Context Protocol) ist ein leichtgewichtiges Protokoll, das speziell für die strukturierte Kommunikation zwischen KI-Modellen und externen Tools entwickelt wurde.
Im Kern verwendet MCP JSON-RPC 2.0, ein bewährtes Protokoll zum Aufrufen von Remote Procedures mit strukturierten Ein- und Ausgaben — perfekt geeignet, um LLM-Ausgaben in reale Tool-Aufrufe zu verwandeln.
Warum also noch ein Protokoll erfinden?
Bestehende Optionen wie REST oder GraphQL sind für KI-zentrierte Workflows entweder zu generisch, zu ausführlich oder schlicht zu unflexibel. MCP schließt diese Lücke, indem es eine klare Struktur, minimalen Overhead und einen expliziten Fokus auf KI-Workflows bietet. Es soll Ihre APIs nicht ersetzen — es soll Modellen ermöglichen, diese sicher, wiederholbar und vorhersehbar zu nutzen.
- Host-App: Orchestriert Tool-Aufrufe, verarbeitet LLM-Ausgaben, verkettet Antworten — z. B. ein GRC-Agent, der Mongo abfragt, Ergebnisse zusammenfasst und Benachrichtigungen sendet.
- MCP-Server: Implementiert domänenspezifische Logik wie listCollections, runAggregation oder sendMessageToSlack.
- MCP-Client: Eine minimale Bibliothek, die die Formatierung von Anfragen, Authentifizierung und Retries übernimmt und den Host mit dem passenden MCP-Server verbindet.
Server stellen typischerweise Folgendes bereit:
- Tools: Ausführbare Befehle wie listCollections, runAggregation oder sendSlackMessage.
- Resources: Beschreibende Daten wie Schemadefinitionen, Collection-Metadaten oder Datenbankstrukturen.
Optional können Server auch Folgendes bereitstellen:
- Prompts: Standardisierte Agenten-Prompts/Templates
- Client-seitige Primitiven: Caching- oder Batching-Hinweise
- Notifications: Echtzeit-Event-Streams (über SSE)
Transportoptionen: STDIO vs. HTTP/SSE
MCP ist transportagnostisch und unterstützt zwei Modi:

Beide Transporte folgen demselben JSON-RPC-Format, sodass Sie den Transport wechseln können, ohne Ihre Logik umzuschreiben.
Das ist also die Grundidee hinter MCP — eine minimale, saubere Möglichkeit für Modelle, Tools ohne anfällige Prompt-Basteleien aufzurufen. Keine halluzinierten Befehle. Kein manuelles Context Stuffing. Nur klare Eingaben und Ausgaben. Aber wie funktioniert das in einer realen Anwendung? Gehen wir ein Beispiel mit einem MongoDB-gestützten Compliance-Assistenten durch.
Automatisierung eines GRC-Workflows mit Mongo-MCP
Stellen Sie sich vor, Sie bauen einen GRC-Assistenten (Governance, Risk, and Compliance).
Dieser Assistent muss:
- Collections und Audit-Logs aus einer MongoDB-Datenbank abrufen
- Ergebnisse für einen Compliance-Officer zusammenfassen
- Relevante Teams auf Slack benachrichtigen
- Optional ein Follow-up-Issue auf GitHub erstellen
In einem traditionellen Setup würden Sie diese Logik über REST-Aufrufe oder Python-Skripte fest verdrahten und Schemas sowie Anmeldedaten in Prompt-Templates einfügen. Jede Integration wäre individuell — und anfällig.
Mit MCP wird jedes dieser Tools — MongoDB, Slack, GitHub — zu einem erstklassigen Funktionsanbieter, der klar definierte Methoden bereitstellt wie:
- listCollections
- runAggregation
- sendMessage
- createIssue

Der GRC-Agent (unsere Host-App) ruft diese Tools einfach unter Verwendung des JSON-RPC-Schemas von MCP auf.
Szenario: Erkennen und Melden von Richtlinienverstößen. Anweisung des Benutzers: „Überprüfe die Compliance-Datenbank auf heutige Richtlinienverstöße und benachrichtige das Team auf Slack.“
1. Benutzereingabe → Host-App → LLM. Die GRC-Agent (Host-App) sendet die Nachricht des Benutzers an das Modell. Das Modell ist tool-aware und antwortet mit:
2. Host-App ruft Mongo-MCP über den MCP-Client auf. Dieser Tool-Aufruf wird in eine JSON-RPC-Anfrage umgewandelt:
3. Mongo-MCP führt die Funktion aus. Mongo-MCP mappt diesen Aufruf auf:
Es führt die Funktion aus, erhält das Ergebnis und antwortet:
4. Agent verkettet den nächsten Aufruf: runAggregation. Das Modell generiert nun basierend auf den verfügbaren Collections einen Folgeaufruf:
Dies führt zu einem weiteren JSON-RPC-Aufruf an Mongo-MCP, und der Server gibt zurück:
Der Agent übergibt dieses Ergebnis mit einem Prompt wie dem folgenden an das Modell zurück:
„Fasse diese Daten zu Richtlinienverstößen in einfühlsamer, klarer Sprache zusammen.“
Das Modell antwortet:
„Heute gab es 5 Richtlinienverstöße mit hoher Schwere und 12 mit mittlerer Schwere in der Compliance-Datenbank.“
5. Modell ruft Slack-MCP auf, um das Team zu benachrichtigen. Nun setzt der Agent einen finalen strukturierten Tool-Aufruf ab:
Der Slack-MCP-Server sendet die Nachricht, und der Workflow ist abgeschlossen. All dies geschah durch strukturierte JSON-Aufrufe, nicht durch String-Manipulation oder Prompt Engineering.
Warum benötigen Sie eine MCP Server Registry im MCP Gateway?
Die Mongo-MCP-Demo sieht sauber aus. Das Modell hat strukturierte Tool-Aufrufe getätigt. Jede Funktion funktionierte wie erwartet. Keine Halluzinationen. Keine anfälligen String-Templates. Aber das ist ein Idealszenario („Happy Path“) — und reale Systeme müssen nicht nur funktionieren… sie müssen im großen Maßstab sicher, zuverlässig und nachvollziehbar funktionieren.
In der Produktion stößt reines MCP in einigen Schlüsselbereichen an seine Grenzen:
1. Keine Zugriffskontrolle (RBAC). Reines MCP hat keine integrierte Möglichkeit zu beschränken, wer was aufrufen darf.
- Was ist, wenn Sie runAggregation erlauben, aber deleteCollection blockieren möchten?
- Was ist, wenn ein Modell nur bestimmte Datensätze abfragen darf (z. B. Finanzen darf nicht auf HR zugreifen)?
In realen Unternehmen ist RBAC (rollenbasierte Zugriffskontrolle) unverzichtbar — insbesondere wenn Modelle mit sensiblen Tools verbunden sind.
2. Keine Authentifizierung oder API-Schlüssel. Reines MCP verarbeitet Folgendes nicht:
- Validierung, welcher Agent oder welches Modell den Aufruf tätigt
- Einschränkung von Anmeldedaten pro Team, Umgebung oder Projekt
- Ablauf oder Widerruf von Tokens
Das bedeutet, dass jeder mit Zugriff auf den MCP-Server jedes Tool aufrufen kann — und es gibt keinen Audit-Trail.
3. Keine Observability. Man kann nicht reparieren, was man nicht sieht.
- Wie hoch ist die Latenz jedes Tool-Aufrufs?
- Wie hoch ist die Fehlerrate oder Anzahl der Retries?
- Welche Tools werden zu oft genutzt oder laufen in Timeout-Fehler?
Mit reinem MCP haben Sie keine Dashboards, Logs oder Traces. Sie fliegen im Blindflug.
4. Keine Guardrails. LLMs sind kreativ — manchmal zu kreativ.
Reines MCP bietet:
- Keine Token-Limits (z. B. Verhindern riesiger Aggregationen)
- Keine Begrenzung der Ergebnisgröße (z. B. Rückgabe von 5 MB aus Mongo)
- Keine Circuit Breaker oder Bestätigungsaufforderungen (z. B. „Sind Sie sicher, dass Sie diesen Slack-Alert senden möchten?“)
Ohne Guardrails kann ein einziger Prompt-Fehler zu Tausenden von Slack-Nachrichten oder versehentlichem Datenlöschen führen.
5. Keine Retries, Throttling oder Quotas in der Produktion
In der Produktion verhalten sich Tools nicht immer perfekt — sie können fehlschlagen, in Zeitüberschreitungen laufen oder langsam antworten. Ohne Schutzmaßnahmen können selbst gut konfigurierte Modelle:
- Rate-Limits überschreiten
- Dienste mit Retries überlasten
- Sensible Tools für Missbrauch anfällig machen
Das reine MCP-Protokoll geht davon aus, dass einfach alles funktioniert — eine Traumwelt. Aber reale Infrastruktur ist komplex. Sie benötigen intelligente Retry-Logik, Caching, Rate-Limiting und Zugriffskontrolle, um im großen Maßstab den Überblick zu behalten.
- Authentifizierung + tokenbasierter Zugriff
- RBAC pro Modell, Benutzer, Organisation und Tool
- Observability und Tracing
- Quotas, Limits und Retry-Strategien
- Genehmigungsworkflows für sensible Aktionen
Genau das bietet das TrueFoundry Gateway.
Von Einzel-Server-Demos zu Enterprise-fähigen Agenten-Workflows
Im ersten Teil dieses Artikels haben wir gelernt, was das Model Context Protocol ist, und einen Mongo-MCP-Server genutzt, um eine veraltete GRC-Plattform zu automatisieren. Dieses kleine Beispiel ist großartig für einen Hackathon, stösst in der Realität jedoch schnell auf Hindernisse:
Das AI Gateway von TrueFoundry bündelt die fehlende Infrastruktur — eine MCP Registry, zentrale Auth, RBAC, Guardrails und umfassende Observability —, sodass Teams sicher und wiederholbar vom „Hello-World-Agenten“ in die Produktion übergehen können.
Was das Gateway zusätzlich zu reinem MCP bietet
TrueFoundry positioniert eines der besten MCP Gateways als Control-Plane, die zwischen Ihren Agenten (oder der Chat-UI) und jedem registrierten MCP-Server sowie LLM-Anbieter sitzt.
Zu den wichtigsten Funktionen gehören:
- Zentrale MCP Registry – Öffentliche oder selbst gehostete Server einmal hinzufügen; überall entdecken
- Einheitliche Anmeldedaten – Generieren Sie ein einziges Personal-Access-Token (PAT) oder ein maschinenbezogenes Virtual-Account-Token (VAT), das im Hintergrund automatisch gegen serverbezogene OAuth- / Header-Tokens ausgetauscht wird
- Feingranulares RBAC – Beschränken Sie, welche Benutzer, Apps oder Umgebungen welche Tools sehen oder ausführen dürfen
- Agent Playground & integrierter MCP-Client – Schnelles Prototyping, ohne eine Zeile Code zu schreiben
- Observability & Guardrails – Latenz, Kosten, Traces, Genehmigungsabläufe, Rate-Limits und Caching direkt integriert
Stellen Sie es sich als das API-Gateway + Service Mesh + Secret Store für die entstehende MCP-Umgebung vor. „Wie im MCP Server Authentication Guide beschrieben, übernimmt das Gateway die Speicherung von Anmeldedaten und den Token-Lebenszyklus automatisch.“
Praxis: Registrieren Ihres ersten MCP-Servers
Der allererste Schritt in der Benutzeroberfläche besteht darin, eine Gruppe zu erstellen — z. B. dev-mcps oder prod-mcps. Gruppen ermöglichen es Ihnen, unterschiedliche RBAC-Regeln und Genehmigungsabläufe an verschiedene Umgebungen anzuhängen.
„Sie können der TrueFoundry MCP Server Getting Started Anleitung für detaillierte Schritte folgen.“
AI Gateway ➜ MCP Servers ➜ „Add New MCP Server Group“
Wählen Sie innerhalb der Gruppe Add/Edit MCP Server und füllen Sie drei Dinge aus:
Ebenso einfach können Sie hinzufügen:
- No-Auth Demo-Server (z. B. Calculator)
- Header-Auth Server, die einen statischen API-Schlüssel akzeptieren (z. B. Hugging Face)
- Jede beliebige Anzahl zukünftiger Server (Atlassian, Datadog, interne Microservices)
Hinter den Kulissen speichert das Gateway Anmeldedaten in seinem Secret Store und verwaltet Token-Refreshes.

Authentifizierung & RBAC
TrueFoundry unterstützt drei Auth-Schemata pro MCP-Server:
„Diese Modi werden in der MCP Server Authentication Dokumentation detaillierter beschrieben.“
Sobald ein Server registriert ist, händigen Sie nicht jedem Entwickler Roh-Tokens aus. Stattdessen authentifizieren sie sich einmalig beim Gateway und erhalten:
- PAT – benutzerspezifisch, benutzerfreundlich, ideal für CLI / Experimente
- VAT – service-account-spezifisch, auf ausgewählte Server beschränkt, perfekt für Produktionsanwendungen
Das Gateway prüft das aufrufende Token gegen:
- Berechtigungen auf Gruppenebene (Darf dieser Benutzer jeden Server in prod-mcps erreichen?)
- Berechtigungen auf Serverebene (Ist slack-mcp auf der Whitelist?)
- Berechtigungen auf Tool-Ebene (Darf sendMessageToChannel aufgerufen werden?)
Schlägt eine Prüfung fehl, wird die Anfrage abgelehnt, bevor sie Ihren Slack-Workspace erreicht.

Vom Playground zum Code: Die Agent API
Nach dem Experimentieren in der UI können Sie auf „API Code Snippet“ klicken, um funktionierenden Python-, JS- oder cURL-Code zu generieren. Nachfolgend sehen Sie einen gekürzten JSON-Body, der drei Server verbindet (GitHub, Slack, Calculator):
POST/api/llm/agent/responses
„Ein ähnliches Beispiel finden Sie in der Anleitung Use MCP Server in Code Agent, die auch vollständige Python- und JS-Snippets enthält.“
Die Streaming-Antwort verschachtelt:
- assistant-Tokens (LLM-Argumentation)
- tool-call-Chunks (Funktionsname + inkrementelle Argumente)
- tool-result-Events (JSON-Ausgabe)
Dies ermöglicht den Bau reaktiver UIs, die jeden Schritt der Agentenschleife in Echtzeit anzeigen.
Observability, Guardrails & Policy
Selbst ein „Hello-World-Agent“ kann reale Kosten verursachen und Schaden anrichten. TrueFoundry bietet erstklassige Observability out-of-the-box:
- Latenz- / Fehler-Dashboards – TTFT, Aufgabenlatenz, HTTP-Fehler, Tool-Retries
- Token- & Kosten-Tracking – Zuordnung der Ausgaben pro Modell, pro Team, pro Feature-Flag
- OpenTelemetry Traces – Hop-by-Hop-Spans über Agent, MCP Proxy und LLM hinweg
- Rate-Limits & Caching – Verhindern von unendlichen Schleifen und Wiederverwendung identischer Websuchergebnisse
- Guardrail-Hooks – Erzwingen von PII-Scrubbing, NSFW-Filtern oder manuellen Genehmigungsverfahren („Human-in-the-loop Approval“) für destruktive Tools
Alle Metriken stehen direkt zur Verfügung; es sind keine Sidecar-Agenten oder benutzerdefinierten Exporter erforderlich.

Unterstützung aller MCP-Transporte (HTTP & STDIO)
Viele Open-Source-Server nutzen weiterhin stdio (stdin/stdout) anstelle von HTTP. TrueFoundry empfiehlt, diese mit mcp-proxy zu wrappen und als regulären Dienst bereitzustellen.
Fertige Templates existieren für Notion- und Perplexity-Server, ebenso wie K8s-Manifeste für Node- oder Python-Images. Sobald sie gehostet werden, unterscheidet sich die Registrierung nicht von jedem anderen HTTP-MCP-Endpunkt.
„Die MCP Server STDIO Anleitung von TrueFoundry behandelt diesen Proxy-Ansatz und bietet Deployment-Templates.“
Beispiel-Durchlauf: Enterprise Compliance Bot
Kehren wir zu unserem Legacy-GRC-Szenario zurück, erhöhen jedoch den Anspruch:
„Halte unsere Compliance-Nachweise auf dem neuesten Stand. Wenn sich eine Richtliniendatei in GitHub ändert, speichere den Diff in MongoDB, erstelle ein Jira-Ticket und poste eine Zusammenfassung in Slack.“
Beteiligte Server
Ablauf
- Ein GitHub-Webhook trifft auf eine Cloud-Funktion.
- Die Funktion ruft die Agent API (VAT-Token) auf, wobei die vier Server aktiviert sind.
- Das LLM zieht Rückschlüsse → ruft github.getFileDiff auf → mongo.insertDocument → jira.createIssue → slack.sendMessage.
- Jeder Tool-Aufruf und jedes Ergebnis werden im Stream zurückgesendet; Observability erfasst die Latenz jedes Hops.
- Wenn der Diff > x ist (eine bestimmte Anzahl von Codezeilen als Schwellenwert), fügt ein Guardrail „requires manual approval“ ein und pausiert die Ausführung; ein Security-Lead kann dies über die Gateway-UI genehmigen.
Governance
- Das der Funktion angehängte VAT sieht nur die vier aufgeführten Server – Least Privilege.
- Separate dev- und prod-Gruppen ermöglichen das Testen gegen ein Sandbox-Jira und ein Staging-Slack.
- Auditorinnen und Auditoren können jeden Vorfall nachvollziehen: Traces + vollständige JSON-Payloads werden standardmäßig 30 Tage lang aufbewahrt.
Erweiterung des Ökosystems: Erstellen eines eigenen MCP-Servers
Da MCP lediglich JSON-RPC über HTTP oder stdio ist, kann jeder interne Dienst Tools bereitstellen. Hier ist ein kleines Beispiel:
- Bringen Sie diesen Container in Ihren Kubernetes-Cluster ein.
- Registrieren Sie ihn in der dev-Gruppe mit No-Auth während der Entwicklung.
- Wechseln Sie zu Header-Auth oder OAuth2, bevor Sie ihn in prod-mcps verschieben.
Von diesem Moment an kann jeder Agent in Ihrem Unternehmen mit genau derselben Ergonomie wie bei Slack oder GitHub Rückschlüsse über Compliance-Controls ziehen.
Best Practices Cheat-Sheet
„Dieses Blatt wurde aus der TrueFoundry MCP Übersicht adaptiert; diese Richtlinien helfen dabei, sichere und zuverlässige Deployments zu gewährleisten.“
Fazit
MCP ermöglicht es Large Language Models (LLMs), dieselbe Sprache wie Tools zu sprechen – kümmert sich jedoch nicht um Themen wie Sicherheit, Discovery oder Governance auf Enterprise-Ebene. Hier setzt das AI Gateway von TrueFoundry an: Es bietet alles, was Teams out-of-the-box benötigen – wie ein vollständiges MCP-Registry, integrierte Authentifizierung, rollenbasierte Zugriffskontrolle (RBAC), tiefe Observability und eine leistungsstarke Agent API, um alles miteinander zu verbinden.
Häufig gestellte Fragen (FAQ)
Was ist ein MCP-Registry in AI-Systemen?
Ein MCP-Registry ist ein zentralisierter Katalog, der verfügbare Model Context Protocol (MCP) Server und deren spezifische Funktionen speichert und verwaltet. Er fungiert als durchsuchbares Verzeichnis für AI-Agenten und ermöglicht ihnen die dynamische Erkennung von Tools und Ressourcen. Dieses Registry stellt sicher, dass Modelle die richtigen Dienste identifizieren können, die zur Ausführung komplexer, mehrstufiger Aufgaben erforderlich sind.
Was ist der Unterschied zwischen einem MCP-Registry und einem AI Gateway?
Ein MCP-Registry ist ein passives Verzeichnis von Tools, während ein AI Gateway die aktive Durchsetzungsschicht ist, die den Datenverkehr verwaltet. Das Registry teilt dem System mit, welche Ressourcen existieren, während das Gateway den Zugriff steuert, die Authentifizierung verarbeitet und Sicherheitsrichtlinien wie PII-Maskierung oder Rate Limiting während der tatsächlichen Ausführung von Modellanfragen anwendet.
Kann ein AI Gateway ohne ein MCP-Registry funktionieren?
Ja, ein AI Gateway kann mithilfe statischer Konfigurationen ohne ein MCP-Registry funktionieren, verliert dabei jedoch die Flexibilität der dynamischen Tool-Erkennung. Ohne ein Registry müssen Entwickler jede Serververbindung manuell im Code verankern, was die Skalierung und Wartung des Systems erschwert. Die Integration eines Registrys ermöglicht es dem Gateway, sich automatisch anzupassen, wenn neue Tools zum Ökosystem hinzugefügt werden.
Wie setzt ein AI Gateway Richtlinien aus einem MCP-Registry durch?
Das AI Gateway ruft Metadaten und Governance-Regeln aus dem MCP-Registry ab, um eingehende Anfragen in Echtzeit zu validieren. Es gleicht die im Registry definierten Benutzerberechtigungen und Sicherheitsanforderungen ab, bevor der Datenverkehr an den entsprechenden Server weitergeleitet wird. Dies stellt sicher, dass jede Interaktion den Unternehmensstandards und Datenschutzbestimmungen entspricht.
TrueFoundry AI Gateway bietet eine Latenz von ~3—4 ms, verarbeitet mehr als 350 RPS auf einer vCPU, skaliert problemlos horizontal und ist produktionsbereit, während LiteLM unter einer hohen Latenz leidet, mit moderaten RPS zu kämpfen hat, keine integrierte Skalierung hat und sich am besten für leichte Workloads oder Prototyp-Workloads eignet.















%20(28).webp)



.webp)
.webp)
.png)

.png)
.png)
.png)
.png)
.png)
.webp)
.webp)






