MCP Registry & AI Gateway: Architektur und Anwendungsfälle für Unternehmen

Zwischen 2020 und 2023 entwickelten Stiftungsmodelle wie GPT-3 und GPT-4 bewies, dass große Sprachmodelle menschenähnlichen Text generieren, Code schreiben, Dokumente zusammenfassen und komplexe Fragen beantworten können, aber diese Modelle waren staatenlos und in einer Sandbox, sie konnten nicht auf interne Systeme, Datenbanken oder Apps zugreifen — und hatten keine Möglichkeit, tatsächlich Maßnahmen in der realen Welt zu ergreifen.

Du könntest ein Model fragen:

“Schreiben Sie eine MongoDB-Abfrage, um alle Sammlungen in der Compliance-Datenbank aufzulisten.“

Es würde eine Ausgabe erzeugen, die sah wie eine gültige MongoDB-Abfrage — aber:

• Es hatte keine Ahnung, ob die Datenbank existierte
• Es wusste nicht was Kollektionen waren in der DB anwesend
• Es konnte nicht sagen, ob die Abfrage würde sogar laufen
• Es gab keine Möglichkeit Schemas untersuchen, Ergebnisse verifizieren, oder Folgemaßnahmen auslösen wie das Zusammenfassen oder Informieren eines anderen Systems

Es war alles Rätselraten — mit keine Rückkopplungsschleife.

Um dies zu beheben, begannen die Entwickler, Ebenen um LLMs herum zu erstellen:

• Prompte Verkettung
  
• Benutzerdefinierte Wrapper in Python
  
• Injektion von REST-API-Aufrufen über Zeichenkettenvorlagen
  
• Manuelles Context-Stuffing
  („Schreiben Sie die Abfrage mit dem folgenden Schema“)

Das waren clevere Lösungen, aber schwieriger zu pflegen.

Frameworks wie Lang-Kette, Llamaindex, und Semantischer Kernel entstanden, um diese Arbeitsabläufe zu organisieren. Diese Tools halfen dabei, die Dinge zu organisieren, aber die Probleme verschwanden nicht. Die Modelle halluzinierten immer noch Felder, fielen auf eine schnelle Injektion herein, übersprungen die Validierung und es war keine Standardmethode für die Ausführung der eigentlichen Funktionen definiert. Jeder neue Anwendungsfall fühlte sich immer noch so an, als würde man das Rad neu erfinden.

Der eigentliche Wendepunkt kam, als die Entwickler erkannten:

“Wir brauchen keine Modelle, um Befehle zu erraten. Wir brauchen sie, um echte Funktionen aufzurufen — genauso wie Frontend-Apps Backend-APIs aufrufen.“

Etwa Mitte 2023 wurde OpenAI eingeführt Funktionsaufruf, wodurch Modelle strukturiert zurückkehren können JSON Ausgabe, die direkt echten Funktionsaufrufen zugeordnet ist.

Es hat neu definiert, was mit der Modellintegration möglich war

• LLMs könnten nun mithilfe klar definierter Ein- und Ausgaben mit Tools verbunden werden
  
• Models verhielten sich wie API-Kunden, anstatt auf Vermutungen beruhende Generatoren
  
• Aufgaben könnten jetzt sein automatisiert mit mehreren Schritten und Systeminteraktionen

Mit dem Funktionsaufruf kam der Aufstieg von Werkzeuge und Agenten — Modelle, die Aktionen verketten, Arbeitsabläufe verfolgen und mit realen Systemen interagieren könnten

Aber...
1. Jede Implementierung war herstellerspezifisch.
2. Es wurde nichts geteilt Standardformat dafür, wie Tools beschrieben oder aufgerufen wurden.

Das ist wo MCP (Model Context Protocol) tritt ein — vorgeschlagen als allgemeines, offenes Protokoll für die strukturierte Kommunikation zwischen Modellen und externen Tools. Anstatt Tool-APIs fest in jede LLM-App einzuprogrammieren, bietet MCP eine Universalladegerät für AI-Tool-Anschlüsse — wie API öffnen, Anthropisch usw., aber für LLMs, die Tools aufrufen. Es basiert auf JSON-RPC 2.0, eine weit verbreitete Spezifikation, die Remote Procedure Calls (RPCs) mithilfe von JSON unterstützt.

Was MCP definiert

• Wie ein Modell eine Werkzeugmethode aufrufen kann (z. B. runAggregation)
  
• Wie man Parameter übergibt und strukturierte Antworten erhält
  
• Wie Tools ihre verfügbaren Methoden beschreiben (über Schemas oder Manifeste)
  
• Ein schlanker Standard für die Werkzeugintegration in irgendein Backend (DB, CLI, Cloud-API)

Stellen Sie sich MCP als den API-Vertrag zwischen einem Modell und einem Tool vor. Ohne ein Standardprotokoll ist jede Integration erforderlich kundenspezifisches Engineering — kostspielig, fehleranfällig und repetitiv. MCP hat dieses Problem gelöst, indem es eine universelle Sprache, was die Toolintegrationen ein für alle Mal vereinfacht. Aber was genau ist MCP und wie funktioniert es praktisch? Lass uns tiefer tauchen.

Modellkontext-Protokoll

‍MCP (Model Context Protocol) ist ein leichtes Protokoll speziell entwickelt für die strukturierte Kommunikation zwischen KI-Modelle und externe Tools.

Im Kern verwendet MCP JSON-RPC 2.0, ein erprobtes Protokoll zum Aufrufen von Remote-Prozeduren mit strukturierten Ein- und Ausgängen — perfekt, um LLM-Ausgaben in reale Tool-Aufrufe umzuwandeln.

Also warum ein anderes Protokoll erfinden?

Bestehende Optionen wie RUHE oder GraphQL sind entweder zu allgemein, zu ausführlich oder einfach zu spröde für KI-First-Workflows. MCP schließt diese Lücke, indem es eine klare Struktur, minimalen Aufwand und einen ausdrücklichen Fokus auf KI-orientierte Workflows bietet. Es ist nicht dazu gedacht, Ihre APIs zu ersetzen — es soll es Modellen ermöglichen, sie sicher, wiederholbar und vorhersehbar zu verwenden.

• Host-Anwendung: Orchestriert Tool-Aufrufe, verarbeitet LLM-Ausgaben, verkettet Antworten — z. B. ein GRC-Agent, der Mongo abfragt, Ergebnisse zusammenfasst und Warnmeldungen sendet.
• MCP-Server: Implementiert domänenspezifische Logik wie ListCollections, RunAggregation oder SendMessageToSlack.
• MCP-Kunde: Eine Minimalbibliothek, die Anforderungsformatierung, Authentifizierung und Wiederholungsversuche verarbeitet und den Host mit dem entsprechenden MCP-Server verbindet.

Server bieten in der Regel Folgendes an:

• Werkzeuge: Ausführbare Befehle wie ListCollections, RunAggregation oder SendSlackMessage.
• Ressourcen: Beschreibende Daten wie Schemadefinitionen, Sammlungsmetadaten oder Datenbankstruktur.

Optional können Server auch Folgendes verfügbar machen:

• Aufforderungen: Standardisierte Agentenanforderungen/Vorlagen
• Clientseitige Primitive: Hinweise zum Zwischenspeichern oder Stapeln
• Benachrichtigungen: Event-Streams in Echtzeit (über SSE)

Transportoptionen: STDIO im Vergleich zu HTTP/SSE

MCP ist transportagnostisch und unterstützt zwei Modi:

Beide Transporte folgen demselben JSON-RPC-Format, sodass Sie Transporte wechseln können, ohne die Logik neu schreiben zu müssen.

Das ist also die große Idee hinter MCP — eine minimalistische, saubere Möglichkeit für Models, Werkzeuge ohne zerbrechlichen Promptkleber aufzurufen. Keine halluzinierten Befehle. Keine manuelle Kontextausfüllung. Einfach Eingaben und Ausgaben löschen. Aber wie funktioniert das eigentlich in einer echten App? Lassen Sie uns ein Beispiel mit einem von MongoDB betriebenen Compliance-Assistenten durchgehen.

Automatisierung eines GRC-Workflows mit Mongo-MCP

Stellen Sie sich vor, Sie bauen einen GRC-Assistenten (Governance, Risk, and Compliance) auf.

Dieser Assistent muss:

• Abrufen von Sammlungen und Audit-Logs aus einer MongoDB-Datenbank
• Fassen Sie die Ergebnisse für einen Compliance-Beauftragten zusammen
• Informiere relevante Teams auf Slack
• Reichen Sie optional ein Folgeproblem auf GitHub ein

In einem herkömmlichen Setup würden Sie diese Logik mithilfe von REST-Aufrufen oder Python-Skripten fest verdrahten und Schemas und Anmeldeinformationen in Prompt-Vorlagen stopfen. Jede Integration wäre benutzerdefiniert — und fragil.

Mit MCP wird jedes dieser Tools — MongoDB, Slack, GitHub — zu einem erstklassigen Funktionsanbieter, der klar definierte Methoden bereitstellt wie:

• Sammlungen auflisten
• Aggregation ausführen
• Nachricht senden
• Ausgabe erstellen

Der GRC-Agent (unsere Host-App) ruft diese Tools einfach mithilfe des JSON-RPC-Schemas von MCP auf

Szenario: Richtlinienverstöße erkennen und melden Benutzeranleitung:“Überprüfe noch heute die Compliance-Datenbank auf etwaige Richtlinienverstöße und informiere das Team auf Slack.“

1. Benutzereingabe → Host-App → LLM Der GRC-Agent (Host-App) sendet die Benutzernachricht an das Modell. Das Modell ist werkzeugfähig und reagiert mit:

{
  "tool_calls": [
    {
      "name": "listCollections",
      "arguments": {
        "database": "compliance"
      }
    }
  ]
}

2. Die Host-App ruft Mongo-MCP über den MCP-Client auf. Dieser Toolaufruf wird in eine JSON-RPC-Anfrage konvertiert:

{
  "jsonrpc": "2.0",
  "method": "listCollections",
  "params": {
    "database": "compliance"
  },
  "id": "req-001"
}

3. Mongo-MCP Führt die Funktion aus. Mongo-MCP ordnet diesen Aufruf zu:

def listCollections(database: str) -> List[str]:
    return mongo_client[database].list_collection_names()

Es führt die Funktion aus, ruft das Ergebnis ab und reagiert:

{
  "jsonrpc": "2.0",
  "result": [
    "audit_logs",
    "policy_violations",
    "user_sessions"
  ],
  "id": "req-001"
}

4. Agent verknüpft den nächsten Anruf: RunAggregation Das Modell generiert jetzt einen Folgeanruf auf der Grundlage der verfügbaren Sammlungen:

{
  "tool_calls": [
    {
      "name": "runAggregation",
      "arguments": {
        "database": "compliance",
        "collection": "policy_violations",
        "pipeline": [
          { "$match": { "timestamp": { "$gte": "2025-08-05" } } },
          { "$group": { "_id": "$severity", "count": { "$sum": 1 } } }
        ]
      }
    }
  ]
}

Dies führt zu einem weiteren JSON-RPC-Aufruf an Mongo-MCP, und der Server gibt zurück:

{
  "jsonrpc": "2.0",
  "result": [
    { "_id": "high", "count": 5 },
    { "_id": "medium", "count": 12 }
  ],
  "id": "req-002"
}

Der Agent gibt dieses Ergebnis mit einer Eingabeaufforderung wie der folgenden an das Modell zurück:

“Fassen Sie die Daten zu diesen Richtlinienverstößen in einfachem Englisch zusammen.“

Das Modell antwortet:

„THeute gab es in der Compliance-Datenbank 5 Richtlinienverstöße mit hohem Schweregrad und 12 mittelschwerem Schweregrad.“

5. Das Model ruft Slack-MCP an, um das Team zu benachrichtigen Jetzt gibt der Agent einen letzten strukturierten Tool-Call heraus:

{
  "tool_calls": [
    {
      "name": "sendMessage",
      "arguments": {
        "channel": "#compliance-alerts",
        "message": "5 high and 12 medium policy violations detected today. Please review."
      }
    }
  ]
}

Der Slack-MCP-Server sendet die Nachricht und der Workflow ist abgeschlossen. All dies geschah durch strukturierte JSON-Aufrufe, nicht durch Manipulation von Zeichenketten oder durch Prompt-Engineering.

Governing Enterprise AI at Scale: The MCP Gateway Blueprint

$2 Million

The

Wake-Up Call

Your integration architecture determines whether AI becomes a competitive advantage or unmanageable risk.

A Fortune 500 Spent $2M Fixing Ungoverned AI

Don't let this be you, get the complete Al governance blueprint.

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

Warum benötigen Sie eine MCP-Serverregistrierung in MCP Gateway?

Die Mongo-MCP-Demo sieht sauber aus. Das Modell führte strukturierte Tool-Aufrufe durch. Jede Funktion funktionierte wie erwartet. Keine Halluzinationen. Keine spröden Schnurschablonen. Aber das ist ein glücklicher Weg — und bei echten Systemen geht es nicht nur darum, zu funktionieren... es geht darum, sicher, zuverlässig und in großem Maßstab beobachtbar zu arbeiten.

In der Produktion ist Roh-MCP in einigen wichtigen Bereichen unzureichend:

1. No Access Control (RBAC) Raw MCP hat keine integrierte Methode, um einzuschränken, wer was aufrufen kann.

• Was ist, wenn Sie die Ausführung von Aggregation zulassen, aber deleteCollection blockieren möchten?
• Was ist, wenn ein Modell nur bestimmte Datensätze abfragen sollte (z. B. kann die Finanzabteilung nicht auf die Personalabteilung zugreifen)?

In echten Organisationen ist RBAC (rollenbasierte Zugriffskontrolle) nicht verhandelbar — insbesondere, wenn Modelle mit empfindlichen Tools verbunden sind.

2. Keine Authentifizierung oder API-Schlüssel, die Raw MCP nicht verarbeitet

• Überprüfen, welcher Agent oder welches Modell den Anruf tätigt
• Umfang der Anmeldeinformationen pro Team, Umgebung oder Projekt
• Ablauf oder Widerruf des Tokens

Das bedeutet, dass jeder, der Zugriff auf den mcp Server hat, jedes Tool aufrufen kann — und es gibt keinen Audit-Trail.

3. Keine Beobachtbarkeit Du kannst nicht reparieren, was du nicht siehst.

• Wie hoch ist die Latenz bei jedem Toolaufruf?
• Wie hoch ist die Ausfallrate oder die Anzahl der Wiederholungsversuche?
• Welche Tools werden überbeansprucht oder haben ein Timeout?

Mit Raw MCP haben Sie keine Dashboards, Logs oder Traces. Du fliegst blind.

4. No Guardrails LLMs sind kreativ — manchmal zu kreativ.

Raw MCP hat:

• Keine Token-Limits (z. B. massive Aggregationen verhindern)
• Keine Grenzen für die Ergebnisgröße (z. B. Rückgabe von 5 MB von Mongo)
• Keine Schutzschalter oder Pausenaufforderungen (z. B. „Bist du sicher, dass du diese Slack-Warnung senden möchtest?“)

Ohne Leitplanken kann ein einziger Prompt-Bug zu Tausenden von Slack-Nachrichten oder versehentlichen Datenlöschungen führen.

5. Keine Wiederholungsversuche, Drosselung oder Kontingente in der Produktion

In der Produktion verhalten sich Werkzeuge nicht immer perfekt — sie können ausfallen, ein Timeout haben oder langsam reagieren. Ohne Sicherheitsvorkehrungen können selbst Modelle, die sich gut benehmen,:

• Grenzen der Trefferquote
  
• Hammer-Dienste mit Wiederholungen
  
• Setzen Sie sensible Tools dem Missbrauch aus
  

Das rohe MCP-Protokoll geht davon aus, dass einfach alles funktioniert — eine „Happy Path“ -Welt. Aber die Infrastruktur in der realen Welt ist chaotisch. Sie benötigen intelligente Wiederholungslogik, Caching, Ratenbegrenzung und Zugriffskontrolle, um im großen Maßstab vernünftig zu bleiben.

• Authentifizierung + Token-basierter Zugriff
• RBAC pro Modell, Benutzer, Organisation und Tool
• Beobachtbarkeit und Rückverfolgung
• Kontingente, Grenzwerte und Wiederholungsstrategien
• Genehmigungsworkflows für sensible Aktionen

Genau das bietet das TrueFoundry Gateway.

Von Einzelserver-Demos bis hin zu Agenten-Workflows auf Unternehmensebene

In der erste Hälfte In diesem Artikel haben wir gelernt, was das Model-Context-Protocol ist und verwendeten ein Mongo-MCP-Server um eine ältere GRC-Plattform zu automatisieren. Dieses Spielzeug-Beispiel eignet sich hervorragend für einen Hack-Tag, aber in der realen Welt stößt es schnell auf Probleme:

True Foundry's KI-Gateway packt die fehlenden Sanitäranlagen — eine MCP-Registrierung, zentrale Authentifizierung, RBAC, Guard-Rails und umfangreiche Observability — so können Teams von „Hallo-World Agent“ zu Produktion sicher und wiederholt.

Was das Gateway zusätzlich zu Raw MCP hinzufügt

TrueFoundry positioniert das Gateway als Steuerungsebene das befindet sich zwischen Ihren Agenten (oder der Chat-Benutzeroberfläche) und jedem registrierten MCP-Server und LLM-Anbieter.

Zu den wichtigsten Funktionen gehören:

1. Zentrales MCP-Register — füge öffentliche oder selbst gehostete Server einmal hinzu; entdecke sie überall
2. Vereinheitlichte Anmeldeinformationen — generieren Sie eine Einzel Personal-Access-Token (PAT) oder computerbezogenes Virtual-Account-Token (VAT), das hinter den Kulissen automatisch gegen serverspezifische OAuth-/ Header-Token ausgetauscht wird
3. Feinkörniges RBAC — einschränken welche Benutzer, Apps oder Umgebungen können sie sehen oder ausführen welche Werkzeuge
4. Agent Playground und integrierter MCP-Client — schnelles Prototyping ohne eine Codezeile zu schreiben
5. Beobachtbarkeit und Leitplanken — Latenz, Kosten, Traces, Genehmigungsabläufe, Ratenbegrenzungen und Caching integriert

Betrachte es als API-Gateway + Servicemesh + geheimer Laden für das neu entstehende MCP-Umfeld. „Wie in der Leitfaden zur MCP-Serverauthentifizierung, das Gateway verarbeitet die Speicherung der Anmeldeinformationen und den Token-Lebenszyklus automatisch.“

Praktisch: Registrierung Ihres ersten MCP-Servers

Der allererste Schritt in der Benutzeroberfläche besteht darin, eine zu erstellen Gruppe—z. B. dev-mcps oder prod-mcps. Mithilfe von Gruppen können Sie verschiedene RBAC-Regeln und Genehmigungsabläufe an verschiedene Umgebungen anhängen.

„Du kannst dem folgen TrueFoundry MCP Server — Handbuch „Erste Schritte“ für detaillierte Schritte.“

AI Gateway ➜ MCP Servers ➜ „Neue MCP-Servergruppe hinzufügen

name: prod-mcps
   access control:
       - Manage: SRE-Admins
       - User  : Prod-Runtime-Service-Accounts

Wählen Sie innerhalb der Gruppe MCP-Server hinzufügen/bearbeiten und fülle drei Dinge aus:

Sie können genauso einfach hinzufügen:

• Keine Authentifizierung Demoserver (z. B. Calculator)
• Header-Auth Server, die einen statischen API-Schlüssel akzeptieren (z. B. Hugging Face)
• Beliebige Anzahl zukünftiger Server (Atlassian, Datadog, interne Microservices)

Hinter den Kulissen speichert das Gateway Anmeldeinformationen in seinem geheimen Speicher und kümmert sich um die Token-Aktualisierung.

Authentifizierung und RBAC

TrueFoundry unterstützt drei Authentifizierungsschemata pro MCP-Server:

„Diese Modi werden ausführlicher beschrieben in der Dokumentation zur MCP-Serverauthentifizierung.“

Sobald ein Server registriert ist, bist du nicht händigen Sie jedem Entwickler rohe Tokens aus. Stattdessen authentifizieren sie sich einmal zum Gateway und erhalte:

• PAT — benutzerfreundlich, gut für CLI/Experimente
• MWST. — Servicekonto mit eingeschränktem Geltungsbereich, an ausgewählte Server gebunden, perfekt für Produktionsanwendungen

Das Gateway prüft das aufrufende Token gegen:

1. Gruppenebene Berechtigungen (kann dieser Benutzer jeden Server in prod-mcps erreichen?)
2. Serverebene Berechtigungen (ist Slack-MCP auf der Whitelist?)
3. Werkzeugebene Berechtigungen (können sie sendMessageToChannel aufrufen?)

Schlägt eine Prüfung fehl, wird die Anfrage abgelehnt vor es trifft deinen Slack-Workspace.

Vom Spielplatz zum Code: Die Agenten-API

Nachdem Sie in der Benutzeroberfläche experimentiert haben, können Sie auf „API-Codeausschnitt“ um funktionierende Python-, JS- oder cURL-Beispiele zu generieren. Unten ist ein getrimmt JSON-Body, der drei Server miteinander verbindet (GitHub, Slack, Calculator):

Post/API/LLM/Agent/Antworten

{
  "model": "gpt-4o",
  "stream": true,
  "iteration_limit": 5,
  "messages": [
    {
      "role": "user",
      "content": "Summarize open PRs on repo X and DM me the top blockers."
    }
  ],
  "mcp_servers": [
    {
      "integration_fqn": "truefoundry:prod-mcps:github-mcp",
      "tools": [ {"name": "listPullRequests"}, {"name": "createComment"} ]
    },
    {
      "integration_fqn": "truefoundry:prod-mcps:slack-mcp",
      "tools": [ {"name": "sendMessageToUser"} ]
    },
    {
      "integration_fqn": "truefoundry:common:calculator-mcp",
      "tools": [ {"name": "add"} ]
    }
  ]
}

„Ein ähnliches Beispiel finden Sie in der Verwenden Sie den MCP Server im Code Agent-Handbuch, das auch komplette Python- und JS-Schnipsel enthält.“

Das Streaming Antwortschachtelungen:

1. Assistent Tokens (LLM-Argumentation)
2. Tool-Call Chunks (Funktionsname + inkrementelle Argumente)
3. Werkzeugergebnis Ereignisse (JSON-Ausgabe)

Damit kannst du bauen reaktiv Benutzeroberflächen, die jeden Schritt der Agentenschleife in Echtzeit anzeigen.

Beobachtbarkeit, Leitplanken und Richtlinien

Selbst ein „Hello World“ -Agent kann echtes Geld kosten und echten Schaden anrichten. TrueFoundry bietet erstklassige Beobachtbarkeit:

• Latenz-/Fehler-Dashboards — TTFT, Aufgabenlatenz, HTTP-Fehler, Tool-Wiederholungen
• Token- und Kostenverfolgung — Attributausgaben pro Modell, pro Team, pro Feature-Flag
• OpenTelemetrie-Spuren — Hop-by-Hop erstreckt sich über alle Agenten, MCP-Proxy, und LLM
• Ratenbegrenzungen und Caching — verhindern Sie Ausreißerschleifen und verwenden Sie identische Web-Suchergebnisse wieder
• Geländerhaken — Erzwingen Sie PII-Scrubbing, NSFW-Filter oder eine „Human-in-the-Loop-Genehmigung“ für jedes zerstörerische Tool

Alle Kennzahlen sind sofort einsatzbereit; es sind keine Beiwagenagenten oder Zollexporteure erforderlich.

Unterstützend Alle MCP-Transporte (HTTP & STDIO)

Viele Open-Source-Server sprechen immer noch Studio (stdin/stdout) statt HTTP. TrueFoundry empfiehlt, sie mit zu verpacken MCP-Proxy und als regulärer Dienst bereitzustellen

# wrap a Python stdio server
mcp-proxy --port 8000 --host 0.0.0.0 --server stream python my_server.py

Es gibt vorgefertigte Vorlagen für Notion- und Perplexity-Server sowie K8s-Manifeste für Node- oder Python-Images. Nach dem Proxy ist die Registrierung mit jedem anderen HTTP-MCP-Endpunkt identisch.

„True Foundry's MCP Server STDIO-Handbuch deckt diesen Proxyansatz ab und stellt Bereitstellungsvorlagen zur Verfügung.“

Exemplarische Anleitung: Enterprise Compliance Bot

Kehren wir zurück zu unserem Legacy-GRC Szenario, aber erhöhe den Ehrgeiz:

„Halten Sie unsere Compliance-Nachweise auf dem neuesten Stand. Wenn sich eine Richtliniendatei in GitHub ändert, speichere den Unterschied in MongoDB, erstelle ein Jira-Ticket und poste eine Zusammenfassung in Slack.“

Beteiligte Server

Fluss

1. GitHub-Webhook trifft auf eine Cloud-Funktion.
2. Die Funktion ruft den Agenten-API (Umsatzsteuer-Token) mit den vier aktivierten Servern.
3. LLM-Gründe → ruft GitHub.getFileDiff → Mongo.InsertDocument → jira.createIssue → slack.sendMessage auf.
4. Jeder Toolaufruf und jedes Ergebnis werden zurückgestreamt; Observability erfasst die Latenz jedes Hop.
5. Wenn der Unterschied > x ist (bestimmte Anzahl von Codezeilen, als Schwellenwert), ein Leitplanke Einsätze „erfordert eine manuelle Genehmigung“ und unterbricht die Ausführung; ein Sicherheitsleiter kann dies über die Gateway-Benutzeroberfläche genehmigen.

Unternehmensführung

• Die mit der Funktion verbundene Mehrwertsteuer bezieht sich nur auf die vier aufgeführten Server —geringstes Privileg.
• Trennen Dev und stupsen Mit Gruppen kannst du gegen eine Sandbox, Jira und Staging Slack testen.
• Auditoren können jeden Vorfall wiederholen: Traces und vollständige JSON-Payloads werden standardmäßig 30 Tage aufbewahrt.

Erweiterung des Ökosystems: Aufbau Ihres eigenen MCP-Servers

Weil MCP nur JSON-RPC über HTTP oder stdio ist, irgendein Der interne Dienst kann Tools verfügbar machen, hier ist ein kleines Beispiel:

• Legen Sie diesen Container in Ihren Kubernetes-Cluster ab.
• Registriere es in der Dev Gruppe mit Keine Authentifizierung während der Entwicklung.
• Wechseln zu Header-Auth oder OAuth 2 bevor Sie es nach prod-mcps verschieben.

Von diesem Moment an jeden Ein Agent in deinem Unternehmen kann mit genau der gleichen Ergonomie wie Slack oder GitHub über Compliance-Kontrollen urteilen.

Spickzettel mit den besten Methoden

„Dieses Blatt wurde adaptiert von TrueFoundry MCP im Überblick, tragen diese Richtlinien dazu bei, sichere und zuverlässige Bereitstellungen zu gewährleisten.“

Fazit

MCP ermöglicht es großen Sprachmodellen (LLMs), dieselbe Sprache wie Tools zu sprechen — aber es kümmert sich nicht um Dinge wie Sicherheit, Erkennung oder Governance auf Unternehmensebene. An dieser Stelle kommt das AI Gateway von TrueFoundry ins Spiel: Es fügt sofort alles hinzu, was Teams benötigen — quasi ein vollständiges MCP-Registrierung, integrierte Authentifizierung, rollenbasierte Zugriffskontrolle (RBAC), umfassende Observability und eine leistungsstarke Agenten-API, um alles miteinander zu verbinden.

Häufig gestellte Fragen

Was ist eine MCP-Registrierung in KI-Systemen?

Eine MCP-Registry ist ein zentralisierter Katalog, der verfügbare Model Context Protocol (MCP) -Server und ihre spezifischen Funktionen speichert und verwaltet. Sie dient als durchsuchbares Verzeichnis für KI-Agenten und ermöglicht es ihnen, Tools und Ressourcen dynamisch zu finden. Diese Registrierung stellt sicher, dass Modelle die richtigen Dienste identifizieren können, die für die Ausführung komplexer, mehrstufiger Aufgaben erforderlich sind.

Was ist der Unterschied zwischen einer MCP-Registry und einem AI-Gateway?

Eine MCP-Registry ist ein passives Verzeichnis von Tools, während ein KI-Gateway die aktive Durchsetzungsebene ist, die den Verkehr verwaltet. Die Registry teilt dem System mit, welche Ressourcen vorhanden sind, während das Gateway den Zugriff kontrolliert, die Authentifizierung übernimmt und Sicherheitsrichtlinien wie PII-Maskierung oder Ratenbegrenzung während der eigentlichen Ausführung von Modellanforderungen anwendet.

Kann ein KI-Gateway ohne MCP-Registry funktionieren?

Ja, ein AI-Gateway kann ohne MCP-Registry mit statischen Konfigurationen funktionieren, aber es verliert die Flexibilität der dynamischen Tool-Erkennung. Ohne eine Registrierung müssen Entwickler jede Serververbindung manuell fest codieren, was die Skalierung und Wartung des Systems erschwert. Durch die Integration einer Registrierung kann sich das Gateway automatisch anpassen, wenn dem Ökosystem neue Tools hinzugefügt werden.

Wie setzt ein KI-Gateway Richtlinien aus einer MCP-Registry durch?

Das AI-Gateway ruft Metadaten und Governance-Regeln aus der MCP-Registry ab, um eingehende Anfragen in Echtzeit zu validieren. Es vergleicht die in der Registrierung definierten Benutzerberechtigungen und Sicherheitsanforderungen, bevor der Datenverkehr an den entsprechenden Server weitergeleitet wird. Dadurch wird sichergestellt, dass jede Interaktion den Unternehmensstandards und Protokollen zur Datenspeicherung entspricht.