Uw AI met de Wereld Verbinden: MCP in Actie

Deel 5 van 5: AI echt bruikbaar maken met Model Context Protocol

Welkom bij ons laatste artikel! We hebben RAG-systemen gebouwd, modellen fijngesteld en custom AI van nul af aan gemaakt. Nu komt het meest spannende gedeelte — je AI echt bruikbaar maken in de echte wereld. Introduceer Model Context Protocol (MCP), de brug tussen AI en al het andere.

Wat is MCP en waarom zou je er om geven?

Denk aan hoe frustrerend het is als je ChatGPT vraagt om "mijn agenda te checken" of "deze e-mail te versturen" en het zegt "dat kan ik niet." Dat komt omdat deze AI-modellen in isolatie leven — ze kunnen denken en schrijven, maar ze kunnen niet op een gestandaardiseerde manier interactie hebben met je tools, databases en applicaties.

Model Context Protocol (MCP), ontwikkeld door Anthropic, lost dit fundamentele probleem op. Het gaat niet alleen om je AI "handen en ogen" geven — het gaat erom een gestandaardiseerde manier te creëren waarop AI-modellen externe resources en tools kunnen ontdekken, verbinding mee kunnen maken en mee kunnen communiceren.

Hier is het belangrijkste inzicht: in plaats van dat elke ontwikkelaar zijn eigen custom tool-integraties bouwt (die allemaal anders werken), creëert MCP een universele standaard. Denk aan het als USB-poorten voor AI-tools — elk MCP-compatibel tool kan met elke MCP-compatibele AI-applicatie samenwerken.

Laat me je een echt voorbeeld laten zien dat ik heb gebouwd: CmdGenie, dat MCP-principes in actie laat zien.

Laten we een analogie gebruiken van CmdGenie: een tool die ik heb gemaakt voor terminalcommando's:

CmdGenie is een command-line tool die je natuurlijke taalverzoeken omzet in daadwerkelijke terminalcommando's. Hoewel het technisch gezien niet zelf een MCP-server is, demonstreert het de core MCP-filosofie: AI verbonden met je echte systeem via gestandaardiseerde interfaces.

In plaats van google te gebruiken met "hoe vind ik grote bestanden in Linux" en terminalcommando's te kopieëren, zeg je gewoon:

cmdgenie "find all files larger than 100MB in my home directory"

En het genereert en biedt aan uit te voeren:

find ~/ -type f -size +100M -exec ls -lh {} ;

MCP-architectuur begrijpen

Voordat we dieper ingaan op CmdGenie, laten we begrijpen wat MCP echt is:

MCP-servers — Applicaties die tools en resources leveren die AI kan gebruiken. Denk eraan als gespecialiseerde serviceproviders.

MCP-clients — AI-applicaties die met MCP-servers verbinding maken om beschikbare mogelijkheden te ontdekken en gebruiken.

Transports — De communicatielaag (meestal stdio of Server-Sent Events) die clients en servers laat communiceren.

Hier is het cruciale gedeelte: het AI-model draait aan de client-kant, maar het kan tools ontdekken en aanroepen die op verschillende MCP-servers leven. Dit creëert een gedistribueerd ecosysteem waar:

• Tools gestandaardiseerd en herbruikbaar zijn
• Beveiliging behouden blijft (servers draaien in isolatie)
• Mogelijkheden kunnen worden gedeeld tussen applicaties
• Elke server kan fijnmazig toegangscontroles implementeren

De CmdGenie-architectuur: MCP-principes toegepast

Dit gebeurt er wanneer je CmdGenie gebruikt, waarbij belangrijke MCP-concepten worden gedemonstreerd:

1. Contextontdekking en standaardisering

const systemContext = {

platform: os.platform(),  // Windows, Mac, Linux

currentDir: process.cwd(),

availableCommands: checkAvailableCommands(),

userPreferences: loadUserConfig()

};

In echte MCP-stijl ontdekt het systeem beschikbare mogelijkheden en context. De AI weet op welk systeem het draait en past zich dienovereenkomstig aan — vraag om "proceslijst" op Windows, je krijgt tasklist; vraag op Linux, je krijgt ps aux.

2. Multi-provider-standaardisering

const providers = {

'openai': { defaultModel: 'gpt-3.5-turbo' },

'anthropic': { defaultModel: 'claude-3-haiku-20240307' },

'google': { defaultModel: 'gemini-pro' },

'cohere': { defaultModel: 'command' }

};

Net zoals MCP niet aan één specifiek AI-model is gebonden, demonstreert CmdGenie provider-flexibiliteit. Je kunt schakelen tussen verschillende AI-providers op basis van je behoeften, kosten of prestatie-eisen.

3. Veilige uitvoering met Human-in-the-Loop

console.log(`n💡 Generated command: ${command}`);

rl.question('n🚀 Execute this command? (y/N): ', async (answer) => {

if (answer.toLowerCase() === 'y') {

try {

const { stdout, stderr } = await execAsync(command);

if (stdout) console.log(stdout);

if (stderr) console.error(stderr);

} catch (error) {

console.error('❌ Execution error:', error.message);

}

}

});

Dit demonstreert een cruciaal MCP-principe: AI suggereert, mensen keuren goed. De client (je terminal) behoudt de controle over wat daadwerkelijk wordt uitgevoerd.

Een echte MCP-server bouwen

Hoewel CmdGenie MCP-principes laat zien, kijken we hoe je een echte MCP-server zou bouwen. Hier is een eenvoudige rekenkundeserver:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP(name="mcp-server", host="0.0.0.0", port=8000)

@mcp.tool()

def add(a: int, b: int) -> int:

"""Add two numbers"""

return a + b

@mcp.tool()

def multiply(a: int, b: int) -> int:

"""Multiply two numbers"""

return a * b

if __name__ == "__main__":

mcp.run(transport="sse")

Het mooie van MCP is standaardisering:

• De @mcp.tool() decorator genereert automatisch juiste tool-schema's
• Elke MCP-client kan deze tools ontdekken en gebruiken
• De server draait onafhankelijk en kan meerdere clients bedienen

Voorbij CmdGenie: echte MCP-applicaties

De principes achter CmdGenie zijn van toepassing op talloze MCP-scenario's:

E-mailbeheer-server

@mcp.tool()

async def send_email(to: str, subject: str, body: str):

"""Send an email through the configured email service"""

# Implementation connects to actual email service

pass

Agendaintegratieserver

@mcp.tool()

async def find_available_slot(duration: int, participants: list):

"""Find available meeting time for given participants"""

# Implementation connects to calendar service

pass

Bestandssysteem-operatiesserver

@mcp.tool()

async def organize_directory(path: str, rules: dict, preview: bool = True):

"""Organize files in directory according to specified rules"""

# Implementation handles actual file operations

pass

De echte kracht: contextuele AI met gestandaardiseerde tools

Wat MCP krachtig maakt, is niet alleen dat AI commando's kan uitvoeren — het is dat het een gestandaardiseerde manier biedt om contextueel bewuste beslissingen te nemen. CmdGenie demonstreert deze contextuele bewustzijn:

Gebruiker zegt: "Laat me zien wat ruimte inneemt"

• Op Windows: dir /s /-c | sort /r
• Op Linux: du -h --max-depth=1 | sort -hr
• Op macOS: du -h -d 1 | sort -hr

In een MCP-ecosysteem wordt deze contextuele bewustzijn nog krachtiger omdat:

• Meerdere servers context kunnen bieden (systeeminfo, gebruikersvoorkeuren, beschikbare tools)
• AI tools van verschillende servers kan koppelen om complexe taken uit te voeren
• Alles volgt hetzelfde gestandaardiseerde protocol

Je eigen MCP-integratie bouwen

Klaar om in het MCP-ecosysteem te bouwen? Hier is het patroon:

1. Definieer je MCP-server

from mcp.server.fastmcp import FastMCP

mcp = FastMCP(name="my-custom-server")

@mcp.tool()

def my_tool(param: str) -> str:

"""Description of what this tool does"""

# Your implementation here

return result

2. Maak context-bewuste tools

@mcp.tool()

def system_aware_command(user_request: str):

"""Generate system-appropriate command for user request"""

system_info = get_system_context()

user_prefs = get_user_preferences()

3. Implementeer veiligheid en validatie

@mcp.tool()

def safe_file_operation(operation: str, path: str):

"""Perform file operation with safety checks"""

if not is_safe_path(path):

raise ValueError("Path not approved for operations")

4. Verbind met MCP-clients

Elke MCP-compatibele client kan je server ontdekken en gebruiken:

# Client code (simplified)

async def use_mcp_server():

session = await connect_to_mcp_server("http://localhost:8000/sse")

tools = await session.list_tools()

MCP-ontwerpprincipes

Door tools als CmdGenie te bouwen en MCP-architectuur te begrijpen, hier zijn de sleutelprincipes:

Standaardisering: Tools volgen consistente schema's en protocollen Human-in-the-Loop: AI suggereert, mensen keuren kritische acties goed Context-bewust: AI past zich aan aan omgeving, gebruikersvoorkeuren en huidige staat Veiligheid eerst: Valideer, geef voorbeeld en beperk potentieel gevaarlijke operaties Transparantie: Toon gebruikers precies wat de AI doet Reversibiliteit: Wanneer mogelijk, laat gebruikers AI-acties ongedaan maken Leren: Verbeter op basis van successen en mislukkingen Interoperabiliteit: Elke MCP-client kan met elke MCP-server samenwerken

Veelvoorkomende MCP-valkuilen

Over-automatisering: Automatiseer niet alles. Sommige taken moeten handmatig blijven voor veiligheid en toezicht.

Contextoverload: Teveel context kan AI verwarren. Wees selectief over welke informatie je opneemt.

Beveiligingsblindheid: MCP-servers hebben toegang tot gevoelige operaties. Implementeer beveiliging van dag één af aan.

Standaarden negeren: De kracht van MCP komt van standaardisering. Maak geen custom protocollen.

Slechte foutafhandeling: Gedistribueerde systemen falen. Plan voor netwerkproblemen, serveruitval en edge cases.

Je MCP-reis begint hier

Je hoeft niet de volgende Cursor te bouwen om van MCP te profiteren. Begin klein:

Kies één workflow: Kies iets dat je regelmatig doet Identificeer vereiste tools: Welke mogelijkheden zou een AI nodig hebben om te helpen? Bouw of vind MCP-servers: Maak eenvoudige servers of gebruik bestaande Voeg veiligheidsmaatregelen toe: Implementeer goed- en validatiewerkstromen Leer en itereer: Verbeter op basis van echte gebruik

De toekomst van AI is niet alleen slimmer modellen — het is AI die daadwerkelijk dingen in de wereld kan doen via gestandaardiseerde, veilige en herbruikbare protocollen. MCP is dat protocol, en het ecosysteem begint net te bloeien.

Wil je de code verkennen? Bekijk CmdGenie hier en probeer het met npm van hier. Afsluiting van onze reis

We hebben veel terrein bestreken in deze serie:

• Artikel 1: Het AI-landschap begrijpen
• Artikel 2: RAG-systemen bouwen voor betere informatieontsluiting
• Artikel 3: Modellen fijnstellen voor je specifieke behoeften
• Artikel 4: Custom modellen van nul af aan creëren
• Artikel 5: AI met de echte wereld verbinden met MCP

De rode draad? AI is het krachtigst wanneer het verbonden is met je specifieke context, data en workflows. Of het nu via RAG, fijnstelling, custom modellen of MCP-integraties is, het doel is hetzelfde: AI creëren dat je echt helpt dingen gedaan te krijgen.

De tools bestaan. De modellen zijn beschikbaar. De enige vraag is: wat zul je bouwen?

De toekomst van AI gaat niet over mensen vervangen — het gaat erom menselijke mogelijkheden aanvullen met intelligente, contextuele, verbonden systemen. En nu weet je hoe je deze bouwt.

Bedankt dat je door deze artikelserie bent gegaan. Ik ben altijd bereid om over tech of films te praten. Je kunt me bereiken op LinkedIn.