Choose your path
MCP Blog
MCP vs functieaanroepen: hoe koppel je tools aan AI-agenten
Vergelijking: MCP versus function calling - Function calling (tool calling) via het model: - Sterke punten: Lage latency, geen extra processen, eenvoudig om direct Python-functies of HTTP-clients aan te roepen vanuit je host-app. Ideaal voor één app, één toolset. - Zwakke punten: Strakke koppeling aan je runtime; hergebruik tussen apps/agents is lastiger; sandboxing en permissies moet je zelf regelen; discoverability van tools is beperkt tot wat je in code bundelt. - MCP (Model Context Protocol): - Sterke punten: Gestandaardiseerde interface voor tools; decoupling tussen agent en tools; tools zijn discoverable (list_tools), self-describing (schema’s), en kunnen door meerdere agents/clients hergebruikt worden; betere isolatie en governance (aparte processen/containers). - Zwakke punten: Extra laag en procescommunicatie (JSON-RPC) introduceert overhead en complexiteit; je hebt een server en client nodig; minimale leercurve. Onderstaande Python-templates laten dezelfde order lookup zien: 1) direct (rechtstreeks naar CometAPI), 2) via function calling met het model, 3) via MCP (server die CometAPI publiceert; client die de tool aanroept), 4) en een bridge waarbij het model een tool call triggert en de host die via MCP uitvoert. Benodigdheden - Python 3.10+ - pip install requests anyio openai mcp - Omgevingsvariabelen: - COMET_BASE_URL: basis-URL van CometAPI, bijv. https://api.example.com - COMET_API_KEY: API key indien vereist - OPENAI_API_KEY: voor function calling voorbeelden Bestand: comet_api.py import os import typing as t import requests class CometAPI: def __init__( self, base_url: t.Optional[str] = None, api_key: t.Optional[str] = None, timeout: int = 10, ) -> None: self.base_url = (base_url or os.environ.get("COMET_BASE_URL") or "").rstrip("/") if not self.base_url: raise ValueError("COMET_BASE_URL is niet gezet") self.api_key = api_key or os.environ.get("COMET_API_KEY") self.timeout = timeout def _headers(self) -> dict: headers = {"Accept": "application/json"} if self.api_key: headers["Authorization"] = f"Bearer {self.api_key}" return headers def get_order(self, order_id: str) -> dict: if not order_id: raise ValueError("order_id is verplicht") url = f"{self.base_url}/orders/{order_id}" resp = requests.get(url, headers=self._headers(), timeout=self.timeout) resp.raise_for_status() data = resp.json() if not isinstance(data, dict): raise ValueError("Onverwacht antwoordformaat; verwacht JSON object") return data def find_orders(self, email: t.Optional[str] = None, status: t.Optional[str] = None) -> dict: params = {} if email: params["email"] = email if status: params["status"] = status url = f"{self.base_url}/orders" resp = requests.get(url, headers=self._headers(), params=params, timeout=self.timeout) resp.raise_for_status() return resp.json() Bestand: direct_lookup.py import sys from pprint import pprint from comet_api import CometAPI def main(): if len(sys.argv) > 1: order_id = sys.argv[1] else: order_id = "ORD-1001" api = CometAPI() data = api.get_order(order_id) print(f"Order {order_id}:") pprint(data) if __name__ == "__main__": main() Bestand: llm_function_calling.py import json from pprint import pprint from openai import OpenAI from comet_api import CometAPI def build_tools_schema(): return [ { "type": "function", "function": { "name": "get_order", "description": "Haalt ordergegevens op aan de hand van order_id.", "parameters": { "type": "object", "properties": { "order_id": { "type": "string", "description": "Het ordernummer, bijv. ORD-1001" } }, "required": ["order_id"] }, }, } ] def execute_tool_call(name: str, arguments_json: str): if name == "get_order": args = json.loads(arguments_json or "{}") order_id = args.get("order_id") api = CometAPI() result = api.get_order(order_id) return {"ok": True, "data": result} raise ValueError(f"Onbekende tool: {name}") def main(): client = OpenAI() model = "gpt-4o-mini" messages = [ {"role": "system", "content": "Je bent een behulpzame assistant."}, { "role": "user", "content": "Zoek de orderstatus voor ORD-1001 en geef een korte samenvatting." }, ] # Eerste call: model kan beslissen om de tool te gebruiken resp = client.chat.completions.create( model=model, messages=messages, tools=build_tools_schema(), tool_choice="auto", temperature=0 ) msg = resp.choices[0].message tool_calls = msg.tool_calls or [] if not tool_calls: print("Model gaf antwoord zonder tool; antwoord:") print(msg.content) return # Voer elke tool call uit en verzamel resultaten tool_results = [] for tc in tool_calls: name = tc.function.name args = tc.function.arguments result = execute_tool_call(name, args) tool_results.append( { "role": "tool", "tool_call_id": tc.id, "name": name, "content": json.dumps(result), } ) # Tweede call: geef tool-resultaten terug aan het model voor eindantwoord messages2 = messages + [msg] + tool_results resp2 = client.chat.completions.create( model=model, messages=messages2, temperature=0 ) final_answer = resp2.choices[0].message.content print("Antwoord van het model:") print(final_answer) if __name__ == "__main__": main() Bestand: mcp_server.py # Opmerking: Dit gebruikt de MCP Python SDK (https://pypi.org/project/mcp). # Afhankelijk van de SDK-versie kunnen namen licht afwijken. Zie de officiële docs # voor eventuele kleine aanpassingen. import os import json import anyio from comet_api import CometAPI # MCP server primitives from mcp.server import Server from mcp.server.stdio import stdio_server server = Server("comet-tools") @server.tool() async def get_order(order_id: str) -> str: """ MCP tool: get_order Argumenten: - order_id: string Retourneert: - JSON string met ordergegevens """ api = CometAPI() # Run sync HTTP call in thread om de eventloop niet te blokkeren data = await anyio.to_thread.run_sync(api.get_order, order_id) # MCP tools retourneren content; strings zijn veilig en self-describing return json.dumps({"ok": True, "data": data}) async def main(): # stdio server maakt het mogelijk om via stdin/stdout te praten met clients async with stdio_server() as (reader, writer): await server.run(reader, writer) if __name__ == "__main__": anyio.run(main) Bestand: mcp_client_demo.py # Eenvoudige MCP client die mcp_server.py start en de tool aanroept. # Draai in een terminal: # python mcp_server.py # En in een andere: # python mcp_client_demo.py ORD-1001 import sys import json import anyio from mcp.client import Client from mcp.client.stdio import stdio_client async def run(order_id: str): # Verbind met een reeds draaiende server via stdio_client en een command # Optie 1: start server als subproces: # async with stdio_client(command=[sys.executable, "mcp_server.py"]) as (reader, writer): # Optie 2: verbind naar bestaande server (stdin/stdout; sommige SDK’s ondersteunen sockets) async with stdio_client(command=[sys.executable, "mcp_server.py"]) as (reader, writer): client = Client() await client.initialize(reader, writer) # Optioneel: ontdek beschikbare tools tools = await client.list_tools() tool_names = [t.name for t in tools] if "get_order" not in tool_names: raise RuntimeError("Tool 'get_order' niet gevonden") # Roep de tool aan result = await client.call_tool("get_order", {"order_id": order_id}) # Result kan content-blokken bevatten; ga uit van één string-blok content = result.content[0].text if result.content else "" obj = json.loads(content) if content else {} print(json.dumps(obj, indent=2)) def main(): order_id = sys.argv[1] if len(sys.argv) > 1 else "ORD-1001" anyio.run(run, order_id) if __name__ == "__main__": main() Bestand: llm_mcp_bridge.py # Dit laat zien hoe je het model laat beslissen 'get_order' te gebruiken, maar de daadwerkelijke # uitvoering via MCP laat lopen in plaats van direct CometAPI te bellen. # De tool signature in het model blijft hetzelfde; de host code routeert naar MCP. import json from pprint import pprint from openai import OpenAI import anyio from mcp.client import Client from mcp.client.stdio import stdio_client def build_tools_schema(): return [ { "type": "function", "function": { "name": "get_order", "description": "Haalt ordergegevens op aan de hand van order_id.", "parameters": { "type": "object", "properties": { "order_id": { "type": "string", "description": "Het ordernummer, bijv. ORD-1001" } }, "required": ["order_id"] }, }, } ] async def call_mcp_get_order(order_id: str) -> dict: async with stdio_client(command=["python", "mcp_server.py"]) as (reader, writer): client = Client() await client.initialize(reader, writer) result = await client.call_tool("get_order", {"order_id": order_id}) content = result.content[0].text if result.content else "" return json.loads(content) if content else {} def main(): client = OpenAI() model = "gpt-4o-mini" messages = [ {"role": "system", "content": "Je bent een behulpzame assistant."}, {"role": "user", "content": "Wat is de status van ORD-1001?"}, ] resp = client.chat.completions.create( model=model, messages=messages, tools=build_tools_schema(), tool_choice="auto", temperature=0 ) msg = resp.choices[0].message tool_calls = msg.tool_calls or [] if not tool_calls: print("Model gaf antwoord zonder tool; antwoord:") print(msg.content) return # Voer tool via MCP tc = tool_calls[0] args = json.loads(tc.function.arguments or "{}") order_id = args.get("order_id") mcp_result = anyio.run(call_mcp_get_order, order_id) tool_result_message = { "role": "tool", "tool_call_id": tc.id, "name": "get_order", "content": json.dumps(mcp_result), } # Tweede call voor eindantwoord messages2 = messages + [msg, tool_result_message] resp2 = client.chat.completions.create( model=model, messages=messages2, temperature=0 ) final_answer = resp2.choices[0].message.content print("Antwoord van het model:") print(final_answer) if __name__ == "__main__": main() Uitvoerinstructies - Installeer dependencies: - pip install requests anyio openai mcp - Stel omgevingsvariabelen: - export COMET_BASE_URL="https://api.example.com" - export COMET_API_KEY="..." (indien nodig) - export OPENAI_API_KEY="..." - Directe lookup: - python direct_lookup.py ORD-1001 - Function calling (rechtstreeks): - python llm_function_calling.py - MCP: start server en client: - Terminal 1: python mcp_server.py - Terminal 2: python mcp_client_demo.py ORD-1001 - LLM via MCP-bridge: - python llm_mcp_bridge.py Opmerkingen - De MCP SDK kan kleine API-verschillen hebben per versie; als een import of methode niet bestaat, raadpleeg de Model Context Protocol Python SDK documentatie en pas de server/client imports of methoden licht aan. - CometAPI in deze templates is generiek; vervang COMET_BASE_URL door de echte service en pas de endpoints/velden aan.
Claude Skills vs MCP: De 2026-gids voor agentische architectuur
Anthropic’s Claude Skills zijn taakspecifieke, gebundelde kennis + scripts die Claude leren gespecialiseerd werk uit te voeren; het Model Context Protocol (MCP) is een open protocol dat agenten vertelt welke externe tools en databronnen bestaan en hoe ze die kunnen aanroepen. Skills verankeren procedurele/organisatorische kennis; MCP biedt gestandaardiseerde connectiviteit. Ze vullen elkaar aan — gebruik MCP om toegang te krijgen tot data en diensten, gebruik Skills om die data op domein-correcte wijze te interpreteren, te valideren en erop te handelen.
Maak een MCP-server voor Claude Code — een praktische stapsgewijze handleiding
Het Model Context Protocol (MCP) is een open standaard die modellen zoals Anthropic’s Claude en ontwikkelaarstools zoals Claude Code in staat stelt externe tools aan te roepen,
Hoe je een MCP-server bouwt in Claude Desktop - een praktische gids
MCP wordt al ondersteund in clients zoals Claude voor Desktop en tools van derden. Het protocol is geëvolueerd (de specificatie en servervoorbeelden zijn bijgewerkt tot en met 2025) en leveranciers en engineers publiceren patronen voor veiligere, tokenefficiënte integraties. Dit artikel begeleidt u bij het bouwen van een MCP-server, het verbinden ervan met Claude Desktop en praktische/beveiligings-/geheugentips die u nodig hebt in productie.
Mem0 brengt OpenMemory MCP uit: geheugen voor AI-agenten
OpenMemory MCP heeft zich snel ontwikkeld tot een onmisbaar hulpmiddel voor AI-ontwikkelaars die op zoek zijn naar naadloos, privé geheugenbeheer over meerdere assistentclients.
Hoe n8n te gebruiken met MCP-servers
De recente toename van AI-gestuurde automatisering heeft de behoefte aan meer dynamische en contextbewuste workflows ingeluid. n8n, een open-source tool voor workflowautomatisering,
Google A2A versus antropisch MCP: concurrerend of complementair?
Twee belangrijke ontwikkelingen op dit gebied zijn het Agent-to-Agent (A2A)-protocol van Google en het Model Context Protocol (MCP) van Anthropic. Hoewel beide gericht zijn op het verbeteren van de AI-interoperabiliteit, richten ze zich op verschillende aspecten van AI-integratie.
Wat is Google's A2A?
Op 9 april 2025 introduceerde Google het Agent2Agent (A2A)-protocol, wat een aanzienlijke vooruitgang betekende in de interoperabiliteit van kunstmatige intelligentie. Ontworpen om