Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Tools, Resources en Prompts in MCP

Les 3 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Drie mogelijkheden, drie intenties
  2. Tools: uitvoerbare functies
  3. Resources: leesbare data
  4. Prompts: herbruikbare sjablonen
  5. Onderhandeling over mogelijkheden
  6. Hoeveel tools per server?
  7. Belangrijkste punten

Bijgewerkt op 2 november 2026 — MCP Python SDK v2. Deze cursus volgt nu versie 2 van de mcp SDK (2.3.0 per 2 oktober 2026): MCPServer vervangt FastMCP, transportinstellingen verhuizen naar run() of streamable_http_app(), en een applicatie die onder een echte hostnaam wordt blootgesteld, moet die hostnaam declareren (transport_security). Dit is ook de versie die vereist is door de Mistral SDK: de mistralai[agents] extra vereist mcp>=2.2.0,<3.0. Bronnen: What’s new in v2 · Migration Guide · Deploy & scale.

Drie mogelijkheden, drie intenties

Een MCP-server kan drie soorten mogelijkheden aan zijn clients blootstellen. Ze zijn niet uitwisselbaar: elk adresseert een specifieke behoefte, en verwarring tussen de drie leidt tot servers die moeilijk te gebruiken zijn voor het model. Deze les behandelt ze één voor één, voordat we ingaan op de vraag die de kwaliteit van een server bepaalt: hoeveel tools, en op welk granulariteitsniveau?

Tools: uitvoerbare functies

Tools zijn de meest gebruikte mogelijkheid van het protocol. Een tool is een functie die het model kan besluiten aan te roepen om een actie uit te voeren of informatie op te halen. De definitie rust op vier elementen: een unieke, beschrijvende naam (create_issue, get_weather), een tekstuele beschrijving die het model vertelt wanneer het de tool moet aanroepen, een JSON-schema voor invoerparameters met hun typen en beperkingen, en een retourformaat—meestal tekst of JSON.

from mcp.server.mcpserver import MCPServer

app = MCPServer("My Server")

@app.tool()
def get_weather(latitude: float, longitude: float) -> str:
    """Retrieves current weather for the given coordinates.

    Args:
        latitude: Latitude in decimal degrees (-90 to 90)
        longitude: Longitude in decimal degrees (-180 to 180)

    Returns:
        Text description of current weather
    """
    # Weather API call logic
    return f"Sunny, 22°C at ({latitude}, {longitude})"

Onderschat de beschrijving en de typering niet: het model ziet niets anders. Het heeft geen toegang tot uw code, kan uw intenties niet raden en kan geen proefoproep uitvoeren om te zien wat er gebeurt. Vage beschrijvingen of slecht getypeerde parameters leiden mechanisch tot onjuiste oproepen.

Enkele gewoonten maken uw tools aanzienlijk betrouwbaarder. Noem ze naar wat ze doen—book_restaurant zegt alles, process_request zegt niets—en beschrijf zowel de actie als de retourinhoud, aangezien het model moet anticiperen op wat het zal ontvangen. Annoteer parameters altijd in Python en schrijf gestructureerde docstrings met Args en Returns: deze voeden het schema dat het model ziet. Retourneer tot slot leesbare waarden in plaats van ondoorzichtige identifiers; een tool die "John Smith" retourneert, stelt het model in staat een zin te vormen, terwijl een tool die een UUID retourneert, het model dwingt te raden.

Resources: leesbare data

Resources stellen data bloot die de client kan lezen zonder neveneffecten. Het nuanceverschil met tools komt neer op één werkwoord: een tool doet iets, een resource bevat iets. De inhoud van een configuratiebestand, een kennisbank, API-documentatie of de huidige status van een systeem zijn allemaal natuurlijke resources.

@app.resource("config://database")
def get_db_config() -> str:
    """Current database configuration."""
    return json.dumps({
        "host": "localhost",
        "port": 5432,
        "database": "production"
    })

Elke resource wordt geïdentificeerd door een URI—config://database, file:///path/to/doc—die de client kan opsommen en vervolgens op aanvraag kan lezen. In de praktijk worden ze minder vaak gebruikt dan tools, aangezien een simpele tool die data retourneert de meeste behoeften dekt. Ze blijven nuttig wanneer u statische of semi-statische data wilt publiceren zonder uitvoeringslogica erachter.

Prompts: herbruikbare sjablonen

MCP Prompts zijn parametreerbare sjablonen die de server beschikbaar stelt. Ze dienen om bewezen instructies voor een bepaalde taak te delen, in plaats van iedereen zijn eigen formulering te laten uitvinden.

@app.prompt()
def code_review(language: str, code: str) -> str:
    """Generates a code review prompt for the given language."""
    return f"""You are an expert in {language}.
Analyze the following code and identify:
1. Potential bugs
2. Performance issues
3. Readability improvements

Code to analyze:
```{language}
{code}
```"""

Dit gebruik is het meest zinvol in een teamomgeving. Een senior ontwikkelaar codeert zijn prompts voor code-review, debugging of architectuuranalyse in een MCP-server, en het hele team heeft er toegang toe vanuit hun eigen client met dezelfde instructiekwaliteit.

Onderhandeling over mogelijkheden

Wanneer een client verbinding maakt met een server, gaat een onderhandelingsfase vooraf aan elk gebruik:

  1. De client vraagt de mogelijkheden van de server op
  2. De server antwoordt met zijn lijst van tools, resources en prompts
  3. De client presenteert deze mogelijkheden aan het taalmodel
  4. Het model gebruikt de beschrijvingen om te beslissen wat het moet aanroepen

Deze onderhandeling is dynamisch, en dat is een eigenschap die u kunt benutten: dezelfde server kan verschillende mogelijkheden aankondigen afhankelijk van de verbonden gebruiker of de oproepcontext—een administrator-account ziet tools die een read-only account nooit zal zien.

Hoeveel tools per server?

De vraag lijkt triviaal, maar bepaalt toch het foutenpercentage van uw agent. Houd uw servers gefocust: drie tot tien goed gedefinieerde tools werken beter dan vijftig generieke. Voorbij een bepaald volume verspreidt het model zijn keuzes en eindigt het met het aanroepen van de verkeerde tool, of het stapelen van onnodige oproepen.

Als uw functionele reikwijdte breed is, splits deze dan op in meerdere gespecialiseerde servers—één voor Git-bewerkingen, één voor projectmanagement, één voor monitoring. De client weet hoe hij gelijktijdig verbinding moet maken met meerdere servers en alleen die te activeren die vereist zijn voor de huidige taak, wat neerkomt op het laden van de nuttige context in plaats van de volledige catalogus.

Eén laatste afweging verdient uw aandacht: granulariteit. Het blootstellen van drie tools om restaurants op te sommen, beschikbaarheid te controleren en vervolgens te boeken, dwingt het model een sequentie te orkestreren, met bij elke stap een risico op fouten. Een enkele workflow-tool—book_restaurant—kapselt de volledige sequentie in, vermindert het aantal round trips en verplaatst de bedrijfslogica naar waar deze testbaar is: in uw code.

Belangrijkste punten

  • Tools = uitvoerbare acties (90% van de use cases), vereisen precieze beschrijving en typering
  • Resources = leesbare data via URI, geen neveneffecten
  • Prompts = herbruikbare sjablonen, nuttig voor teams
  • Houd uw servers gefocusseerd (maximaal 3–10 tools)
  • Geef de voorkeur aan workflow-tools boven te granulaire tools
  • De kwaliteit van de beschrijving bepaalt de efficiëntie van het model