MCP Registry & AI Gateway: Architectuur en Enterprise Use Cases

Tussen 2020 en 2023 bewezen fundamentmodellen zoals GPT-3 en GPT-4 dat Large Language Models mensachtige tekst kunnen genereren, code kunnen schrijven, documenten kunnen samenvatten en complexe vragen kunnen beantwoorden. Maar deze modellen waren stateless en gesandboxt; ze hadden geen toegang tot interne systemen, databases of apps — en hadden geen mogelijkheid om daadwerkelijk acties in de echte wereld uit te voeren.

Je kon een model vragen:

“Schrijf een MongoDB-query om alle collecties in de compliance-database op te sommen.”

Het genereerde dan uitvoer die er uitzag als een geldige MongoDB-query — maar:

• Het had geen idee of de database bestond
• Het wist niet welke collecties aanwezig waren in de DB
• Het kon niet zeggen of de query überhaupt zou uitvoeren
• Er was geen manier om schema's te inspecteren, resultaten te verifiëren of vervolgacties te triggeren zoals het samenvatten of informeren van een ander systeem

Het was allemaal gokwerk — zonder feedbackloop.

Om dit op te lossen, begonnen ontwikkelaars lagen rond LLM's te bouwen:

• Prompt chaining
  
• Aangepaste wrappers in Python
  
• REST API-callinjectie via stringtemplates
  
• Handmatige context-stuffing
  (“gebruik het volgende schema en schrijf de query”)

Dit waren slimme oplossingen, maar moeilijker te onderhouden.

Frameworks zoals LangChain, LlamaIndex en Semantic Kernel ontstonden om deze workflows te organiseren. Deze tools hielpen bij het structureren, maar de problemen verdwenen niet. Modellen hallucineerden nog steeds velden, trapten in prompt-injecties, sloegen validatie over en hadden geen standaardmanier om daadwerkelijk gedefinieerde functies uit te voeren. Elke nieuwe use case voelde nog steeds als het opnieuw uitvinden van het wiel.

Het echte omslagpunt kwam toen ontwikkelaars zich realiseerden:

“We hebben geen modellen nodig die commando's gokken. We hebben ze nodig om echte functies aan te roepen — op dezelfde manier waarop frontend-apps backend-API's aanroepen.”

Rond halverwege 2023 introduceerde OpenAI function calling, waardoor modellen gestructureerde JSON-uitvoer konden retourneren die rechtstreeks werd gekoppeld aan echte functie-aanroepen.

Het herdefinieerde wat mogelijk was met modelintegratie

• LLM's konden nu communiceren met tools via duidelijk gedefinieerde in- en uitvoer
  
• Modellen gedroegen zich als API-clients, in plaats van op gokken gebaseerde generatoren
  
• Taken konden nu worden geautomatiseerd met meerdere stappen en systeeminteracties

Met function calling kwamen tools en agents op — modellen die acties konden ketenen, workflows konden volgen en konden communiceren met echte systemen

Maar…
1. Elke implementatie was vendorspecifiek.
2. Er was geen gedeeld standaardformaat voor hoe tools werden beschreven of aangeroepen.

Dit is waar MCP (Model Context Protocol) in beeld komt — voorgesteld als een algemeen, open protocol voor gestructureerde communicatie tussen modellen en externe tools. In plaats van tool-API's hard te coderen in elke LLM-app, biedt MCP een universele lader voor AI-toolverbindingen — zoals OpenAPI, Anthropic enz., maar dan voor LLM's die tools aanroepen. Het is gebaseerd op JSON-RPC 2.0, een veelgebruikte specificatie die remote procedure calls (RPC's) ondersteunt met behulp van JSON.

Wat MCP definieert

• Hoe een model een tool-methode kan aanroepen (bijv. runAggregation)
  
• Hoe parameters moeten worden doorgegeven en gestructureerde responsen worden verkregen
  
• Hoe tools hun beschikbare methoden beschrijven (via schema's of manifests)
  
• Een lichtgewicht standaard voor toolintegratie via elke backend (DB, CLI, cloud-API)

Zie MCP als het API-contract tussen een model en een tool. Zonder een standaardprotocol vereiste elke integratie maatwerk engineering — kostbaar, foutgevoelig en repetitief. MCP loste dit op door één universele taal te creëren, wat toolintegraties voor eens en altijd vereenvoudigde. Maar wat is MCP precies, en hoe werkt het in de praktijk? Laten we er dieper in duiken.

Model Context Protocol

‍MCP (Model Context Protocol) is een lichtgewicht protocol dat speciaal is gebouwd voor gestructureerde communicatie tussen AI-modellen en externe tools.

In de kern gebruikt MCP JSON-RPC 2.0, een in de praktijk beproefd protocol voor het aanroepen van remote procedures met gestructureerde in- en uitvoer — perfect om LLM-uitvoer om te zetten in echte tool-aanroepen.

Dus waarom nog een protocol uitvinden?

Bestaande opties zoals REST of GraphQL zijn ofwel te generiek, te gedetailleerd, of gewoon te kwetsbaar voor AI-first workflows. MCP overbrugt deze kloof door een duidelijke structuur, minimale overhead en een expliciete focus op AI-gerichte workflows te bieden. Het is niet bedoeld om je API's te vervangen — het is bedoeld om modellen ze veilig, herhaalbaar en voorspelbaar te laten gebruiken.

• Host App: Orkestreert tool-calls, verwerkt LLM-uitvoer, ketent responsen — bijv. een GRC Agent die Mongo bevraagt, resultaten samenvat en meldingen verstuurt.
• MCP Server: Implementeert domeinspecifieke logica zoals listCollections, runAggregation of sendMessageToSlack.
• MCP Client: Een minimale bibliotheek die het formatteren van verzoeken, authenticatie en retries afhandelt, en de Host verbindt met de juiste MCP Server.

Servers bieden doorgaans het volgende:

• Tools: Uitvoerbare commando's zoals listCollections, runAggregation of sendSlackMessage.
• Resources: Beschrijvende gegevens zoals schemadefinities, collectiemetadata of databasestructuur.

Optioneel kunnen servers ook het volgende bieden:

• Prompts: Gestandaardiseerde agent-prompts/templates
• Client-side primitives: Caching- of batching-hints
• Notifications: Realtime event streams (via SSE)

Transportopties: STDIO vs HTTP/SSE

MCP is transport-agnostisch en ondersteunt twee modi:

Beide transporten volgen hetzelfde JSON-RPC-formaat, dus je kunt van transport wisselen zonder logica te herschrijven.

Dat is dus het grote idee achter MCP — een minimale, schone manier voor modellen om tools aan te roepen zonder breekbare prompt-lijm. Geen gehallucineerde commando's. Geen handmatige context-stuffing. Gewoon duidelijke in- en uitvoer. Maar hoe werkt dat daadwerkelijk in een echte app? Laten we een voorbeeld doorlopen met een door MongoDB aangedreven compliance-assistent.

Een GRC-workflow automatiseren met Mongo-MCP

Stel je voor dat je een GRC (Governance, Risk, and Compliance) assistent bouwt.

Deze assistent moet:

• Collecties en auditlogs ophalen uit een MongoDB-database
• Bevindingen samenvatten voor een compliance officer
• Relevante teams informeren via Slack
• Optioneel een vervolg-issue aanmaken op GitHub

In een traditionele setup zou je deze logica vastzetten met REST-calls of Python-scripts, waarbij je schema's en credentials in prompt-templates propt. Elke integratie zou maatwerk zijn — en kwetsbaar.

Met MCP wordt elk van deze tools — MongoDB, Slack, GitHub — een first-class functie-provider, die duidelijk gedefinieerde methoden beschikbaar stelt zoals:

• listCollections
• runAggregation
• sendMessage
• createIssue

De GRC Agent (onze Host App) roept deze tools eenvoudig aan met behulp van het JSON-RPC-schema van MCP

Scenario: Detecteer en rapporteer beleidsovertredingen Gebruikersinstructie:  “Controleer de compliance-database vandaag op beleidsovertredingen en meld dit aan het team op Slack.”

1. Gebruikersinvoer → Host App → LLM De GRC Agent (Host App) stuurt het bericht van de gebruiker naar het model. Het model is tool-bewust en reageert met:

2. Host App roept Mongo-MCP aan via MCP Client Deze tool-call wordt omgezet in een JSON-RPC-verzoek:

3. Mongo-MCP voert de functie uit Mongo-MCP koppelt deze call aan:

Het voert de functie uit, krijgt het resultaat en reageert:

4.  Agent ketent de volgende call: runAggregation Het model genereert nu een vervolg-call op basis van de beschikbare collecties:

Dit resulteert in nog een JSON-RPC-call naar Mongo-MCP, en de server retourneert:

De agent geeft dit resultaat terug aan het model met een prompt zoals:

“Vat deze gegevens over beleidsovertredingen samen in begrijpelijk Nederlands.”

Het model antwoordt:

“Vandaag waren er 5 beleidsovertredingen met een hoge ernst en 12 met een gemiddelde ernst in de compliance-database.”

5. Model roept Slack-MCP aan om het team te informeren Nu doet de agent een laatste gestructureerde tool-call:

De Slack-MCP-server verstuurt het bericht en de workflow is voltooid. Dit alles gebeurde via gestructureerde JSON-calls, niet via stringmanipulatie of prompt-engineering.

Enterprise AI op schaal beheren: De MCP Gateway Blueprint

$2 miljoen

De

Wake-upcall

Je integratie-architectuur bepaalt of AI een concurrentievoordeel wordt of een onbeheersbaar risico.

Een Fortune 500 gaf $2M uit aan het herstellen van niet-beheerde AI

Laat dit jou niet overkomen, download de volledige AI-governance blueprint.

Bedankt! Je inzending is ontvangen!

Oeps! Er is iets misgegaan bij het verzenden van het formulier.

Waarom heb je een MCP Server Registry nodig in MCP Gateway?

De Mongo-MCP-demo ziet er strak uit. Het model voerde gestructureerde tool calls uit. Elke functie werkte zoals verwacht. Geen hallucinaties. Geen broze string-templates. Maar dat is een happy path — en echte systemen draaien niet alleen om werken... ze draaien om veilig, betrouwbaar en observeerbaar werken op schaal.

In productie schiet pure MCP op een paar cruciale punten tekort:

1. Geen toegangsbeheer (RBAC) Pure MCP heeft geen ingebouwde manier om te beperken wie wat mag aanroepen.

• Wat als u het uitvoeren van Aggregation wilt toestaan, maar deleteCollection wilt blokkeren?
• Wat als een model alleen bepaalde datasets mag bevragen (bijv. Finance heeft geen toegang tot HR)?

In echte organisaties is RBAC (role-based access control) onmisbaar — vooral wanneer modellen zijn gekoppeld aan gevoelige tools.

2. Geen authenticatie of API keys Pure MCP biedt geen ondersteuning voor

• Valideren welke agent of welk model de aanroep doet
• Aanpassen van de reikwijdte van credentials per team, omgeving of project
• Verlooptijd of intrekking van tokens

Dit betekent dat iedereen met toegang tot de mcp server elke tool kan aanroepen — en er is geen audit trail.

3. Geen observabiliteit U kunt niet repareren wat u niet kunt zien.

• Wat is de latency van elke tool call?
• Wat is het foutpercentage of het aantal pogingen (retries)?
• Welke tools worden overmatig gebruikt of lopen tegen een timeout aan?

Met pure MCP heeft u geen dashboards, logs of traces. U vliegt blind.

4. Geen guardrails LLM's zijn creatief — soms te creatief.

Pure MCP heeft:

• Geen tokenlimieten (bijv. om reusachtige aggregaties te voorkomen)
• Geen grenzen aan resultaatgrootte (bijv. 5MB terugsturen uit Mongo)
• Geen circuit breakers of pauzeprompts (bijv. "Weet u zeker dat u deze Slack-melding wilt versturen?")

Zonder guardrails kan één fout in een prompt leiden tot duizenden Slack-berichten of het per ongeluk wissen van gegevens.

5. Geen retry, throttling of quota's In productie

In productie gedragen tools zich niet altijd perfect — ze kunnen uitvallen, een timeout geven of traag reageren. Zonder waarborgen kunnen zelfs goed werkende modellen:

• Ratelimieten bereiken
  
• Services overbelasten met retries
  
• Gevoelige tools blootstellen aan misbruik
  

Het pure MCP-protocol gaat ervan uit dat alles gewoon werkt — een "happy path"-wereld. Maar de infrastructuur in de praktijk is weerbarstig. U heeft slimme retry-logica, caching, rate limiting en toegangsbeheer nodig om op schaal overeind te blijven.

• Authenticatie + op tokens gebaseerde toegang
• RBAC per model, gebruiker, org en tool
• Observabiliteit en tracing
• Quota's, limieten en retry-strategieën
• Goedkeuringsworkflows voor gevoelige acties

Dit is precies wat de TrueFoundry Gateway biedt.

Van Single-Server Demos naar Enterprise-Grade Agent Workflows

In de eerste helft van dit artikel hebben we geleerd wat het Model-Context-Protocol is en hebben we een Mongo mcp server gebruikt om een verouderde GRC-platform te automatiseren. Dat eenvoudige voorbeeld is geweldig voor een hackathon, maar stuit in de praktijk snel op problemen:

TrueFoundry's AI Gateway bundelt de ontbrekende infrastructuur—een MCP-register, centrale auth, RBAC, guardrails en rijke observabiliteit—zodat teams veilig en herhaalbaar van een "hello-world agent" naar productie kunnen gaan.

Wat de Gateway toevoegt aan pure MCP

TrueFoundry positioneert een van de beste MCP gateways als een control-plane die zich bevindt tussen uw agents (of Chat UI) en elke geregistreerde MCP server en LLM-provider.

Belangrijkste functionaliteiten zijn onder meer:

1. Centraal MCP Register – voeg openbare of self-hosted servers eenmalig toe; ontdek ze overal 
2. Gecentraliseerde credentials – genereer een enkel Personal-Access-Token (PAT) of een machine-scoped Virtual-Account-Token (VAT) dat achter de schermen automatisch wordt omgezet in OAuth- / header-tokens per server 
3. Fijnmazige RBAC – beperk welke gebruikers, apps of omgevingen welke tools kunnen zien of uitvoeren 
4. Agent Playground & ingebouwde MCP-client – snelle prototyping zonder een regel code te schrijven 
5. Observabiliteit & guardrails – latency, kosten, traces, goedkeuringsflows, ratelimieten en caching standaard ingebouwd 

Zie het als de API gateway + service mesh + secret store voor de opkomende MCP-omgeving. "Zoals opgemerkt in de MCP Server Authentication handleiding, verwerkt de Gateway het opslaan van credentials en de levenscyclus van tokens automatisch."

Aan de slag: Uw eerste MCP Server registreren

De allereerste stap in de UI is het aanmaken van een groep—bijv. dev-mcps of prod-mcps. Met groepen kunt u verschillende RBAC-regels en goedkeuringsflows aan verschillende omgevingen koppelen.

"U kunt de TrueFoundry MCP Server Aan de slag-handleiding volgen voor gedetailleerde stappen."

AI Gateway ➜ MCP Servers ➜ “Add New MCP Server Group

Kies binnen de groep Add/Edit MCP Server en vul drie dingen in: 

U kunt net zo eenvoudig het volgende toevoegen:

• No-Auth demo-servers (bijv. Calculator)
• Header-Auth servers die een statische API key accepteren (bijv. Hugging Face) 
• Elk willekeurig aantal toekomstige servers (Atlassian, Datadog, interne microservices)

Achter de schermen slaat de Gateway credentials op in zijn secret store en verzorgt hij het verversen van tokens.

Authenticatie & RBAC

TrueFoundry ondersteunt drie auth-schema's per MCP server:

"Deze modi worden gedetailleerder beschreven in de MCP Server Authentication documentatie."

Zodra een server is geregistreerd, geeft u geen ruwe tokens aan elke ontwikkelaar. In plaats daarvan authenticeert men zich één keer bij de Gateway en ontvangt men:

• PAT – op gebruikersniveau, mensvriendelijk, geschikt voor CLI / experimenten
• VAT – op service-accountniveau, afgeschermd voor geselecteerde servers, perfect voor productie-apps 

De Gateway controleert het aanroepende token tegen:

1. Rechten op groepsniveau (heeft deze gebruiker toegang tot een server in prod-mcps?)
2. Rechten op serverniveau (staat slack-mcp op de whitelist?)
3. Rechten op toolniveau (mogen ze sendMessageToChannel aanroepen?)

Als een controle mislukt, wordt het verzoek geweigerd voordat het uw Slack-workspace bereikt.

Van Playground naar code: De Agent API

Na het experimenteren in de UI kunt u op "API Code Snippet" klikken om werkende Python-, JS- of cURL-voorbeelden te genereren. Hieronder staat een verkorte JSON-body die drie servers aan elkaar koppelt (GitHub, Slack, Calculator):

POST/api/llm/agent/responses

"U kunt een vergelijkbaar voorbeeld vinden in de Use MCP Server in Code Agent handleiding, waarin ook volledige Python- en JS-snippets staan."

De streaming-respons wisselt het volgende af:

1. assistant-tokens (LLM-redenering)
2. tool-call-chunks (functienaam + incrementele argumenten)
3. tool-result-events (JSON-output) 

Hiermee kunt u reactieve UI's bouwen die elke stap van de agentic loop in realtime tonen.

Observabiliteit, Guardrails & Beleid

Zelfs een "hello world"-agent kan echt geld kosten en echte schade aanrichten. TrueFoundry levert eersteklas observabiliteit:

• Latency- / foutendashboards – TTFT, taaklatency, HTTP-fouten, tool-retries 
• Token- & kostentracking – wijs uitgaven toe per model, per team, per feature flag 
• OpenTelemetry traces – hop-by-hop spans over agent, MCP proxy en LLM 
• Ratelimieten & caching – voorkom oneindige loops en hergebruik identieke webzoekresultaten
• Guardrail-hooks – dwing PII-scrubbing, NSFW-filters of "human-in-the-loop goedkeuring" af op elke destructieve tool 

Alle metrieken worden standaard meegeleverd; er zijn geen sidecar-agents of aangepaste exporters nodig.

Ondersteuning voor alle MCP-transports (HTTP & STDIO)

Veel open-source servers spreken nog steeds stdio (stdin/stdout) in plaats van HTTP. TrueFoundry raadt aan deze te wrappen met mcp-proxy en ze te deployen als een reguliere service 

Er zijn kant-en-klare templates voor Notion- en Perplexity-servers, plus K8s-manifesten voor Node- of Python-images. Zodra ze via een proxy lopen, is de registratie identiek aan elk ander HTTP MCP-endpoint.

"TrueFoundry's MCP Server STDIO handleiding behandelt deze proxy-aanpak en biedt deployment-templates."

Voorbeeldstappenplan: Enterprise Compliance Bot

Laten we terugkeren naar ons verouderde GRC-scenario, maar de ambitie opschroeven:

"Houd ons compliance-bewijsmateriaal up-to-date. Als een beleidsbestand verandert in GitHub, sla de diff dan op in MongoDB, maak een Jira-ticket aan en plaats een samenvatting in Slack."

Betrokken servers

Stroom

1. GitHub webhook raakt een cloud-functie.
2. De functie roept de Agent API aan (VAT-token) met de vier ingeschakelde servers.
3. LLM redeneert → roept github.getFileDiff aan → mongo.insertDocument → jira.createIssue → slack.sendMessage.
4. Elke tool call en het resultaat daarvan worden teruggestreamd; observability legt de latency van elke hop vast.
5. Als de diff > x is (een bepaald aantal regels code, als drempelwaarde), voegt een guard-rail “requires manual approval” in en pauzeert de uitvoering; een security lead kan dit goedkeuren via de Gateway UI.

Governance

• De VAT die aan de functie is gekoppeld ziet alleen de vier vermelde servers—least privilege.
• Gescheiden dev- en prod-groepen stellen u in staat te testen tegen een sandbox Jira en staging Slack.
• Auditors kunnen elk incident opnieuw afspelen: traces + volledige JSON-payloads worden standaard 30 dagen bewaard.

Het ecosysteem uitbreiden: Uw eigen MCP Server bouwen

Omdat MCP simpelweg JSON-RPC over HTTP of stdio is, kan elke interne dienst tools beschikbaar stellen. Hier is een klein voorbeeld: 

• Plaats deze container in uw Kubernetes-cluster.
• Registreer deze in de dev-groep met No-Auth tijdens het ontwikkelen.
• Schakel over naar Header-Auth of OAuth2 voordat u deze naar prod-mcps verplaatst.

Vanaf dat moment kan elke agent in uw bedrijf redeneren over compliance-controls met exact dezelfde ergonomie als Slack of GitHub.

Best Practices Cheat-Sheet

“Dit overzicht is overgenomen uit het TrueFoundry MCP Overview. Deze richtlijnen helpen veilige en betrouwbare deployments te garanderen.”

Conclusie 

MCP stelt large language models (LLMs) in staat om dezelfde taal te spreken als tools — maar het regelt geen zaken zoals beveiliging, discovery of governance op enterprise-niveau. Dat is waar de AI Gateway van TrueFoundry inspringt: het voegt direct alles toe wat teams nodig hebben — zoals een volledige MCP-registry, ingebouwde authenticatie, role-based access control (RBAC), diepgaande observability en een krachtige Agent API om alles samen te brengen.

Veelgestelde vragen

Wat is een MCP-registry in AI-systemen?

Een MCP-registry is een gecentraliseerde catalogus die beschikbare Model Context Protocol (MCP) servers en hun specifieke mogelijkheden opslaat en beheert. Het fungeert als een doorzoekbare gids voor AI-agents, waardoor ze dynamisch tools en bronnen kunnen ontdekken. Deze registry zorgt ervoor dat modellen de juiste diensten kunnen identificeren die nodig zijn om complexe, uit meerdere stappen bestaande taken uit te voeren.

Wat is het verschil tussen een MCP-registry en een AI gateway?

Een MCP-registry is een passieve gids van tools, terwijl een AI gateway de actieve handhavingslaag is die het verkeer beheert. De registry vertelt het systeem welke bronnen er bestaan, terwijl de gateway de toegang controleert, authenticatie afhandelt en beveiligingsbeleid zoals PII-maskering of rate limiting toepast tijdens de daadwerkelijke uitvoering van modelverzoeken.

Kan een AI gateway werken zonder een MCP-registry?

Ja, een AI gateway kan werken zonder een MCP-registry met behulp van statische configuraties, maar het verliest de flexibiliteit van dynamische tool discovery. Zonder registry moeten ontwikkelaars elke serververbinding handmatig hardcoden, waardoor het systeem moeilijk te schalen en te onderhouden is. Integratie van een registry zorgt ervoor dat de gateway zich automatisch aanpast wanneer nieuwe tools aan het ecosysteem worden toegevoegd.

Hoe handhaaft een AI gateway beleid uit een MCP-registry?

De AI gateway haalt metadata en governance-regels op uit de MCP-registry om inkomende verzoeken in real-time te valideren. Het controleert gebruikersmachtigingen en beveiligingsvereisten die in de registry zijn gedefinieerd voordat verkeer naar de juiste server wordt geleid. Dit zorgt ervoor dat elke interactie voldoet aan de organisatiestandaarden en protocollen voor dataresidentie.