Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Beperkingen en beste praktijken

Les 3 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Technische beperkingen van function calling
  2. Maximaal 200 tools per verzoek
  3. Het model garandeert geen geldigheid van argumenten
  4. Foutafhandeling
  5. Unieke en expliciete namen
  6. Beschrijvingen: de belangrijkste kwaliteitsfactor
  7. Het aantal tools optimaliseren
  8. Beveiliging: vertrouw het model nooit
  9. Belangrijkste punten

Technische beperkingen van function calling

Voordat u begint met implementeren, moet u de limieten van het systeem begrijpen. Function calling in Grok is krachtig, maar werkt binnen specifieke beperkingen die u moet beheersen om robuuste applicaties te bouwen.

Maximaal 200 tools per verzoek

De Grok API accepteert maximaal 200 tool-definities in één enkel verzoek. Deze limiet is ruim; de meeste applicaties gebruiken slechts 5 tot 20 tools. Maar als u een schaalbaar systeem bouwt (plugins, tool-marktplaats), moet u hier rekening mee houden.

Elke tool-definitie neemt ruimte in beslag in het contextvenster. Specifiek:

  • Een eenvoudige tool (2-3 parameters) verbruikt ongeveer 50-100 tokens
  • Een complexe tool (10+ parameters, gedetailleerde beschrijvingen) kan 300 tokens overschrijden
  • 200 complexe tools = 60.000 tokens alleen al voor definities

Daarom moet u strategisch te werk gaan: declareer alleen de tools die relevant zijn voor het huidige verzoek.

Het model garandeert geen geldigheid van argumenten

Grok doet zijn best om argumenten te genereren die overeenkomen met het schema, maar het is niet onfeilbaar. Het model kan:

  • Een onjuiste datumnotatie genereren
  • Een string doorgeven waar een integer wordt verwacht
  • In zeldzame gevallen een verplicht veld weglaten
  • Enum-waarden hallucineren die niet bestaan

Uw client-side code moet ontvangen argumenten altijd valideren voordat de functie wordt uitgevoerd.

import json

def handle_tool_call(tool_call):
    args = json.loads(tool_call.function.arguments)

    # Valideer voordat uitvoering plaatsvindt
    if "city" not in args:
        return {"error": "De parameter city is verplicht"}

    if not isinstance(args["city"], str):
        return {"error": "city moet een string zijn"}

    return get_weather(args["city"], args.get("unit", "celsius"))

Foutafhandeling

Wanneer een functie mislukt, moet u de fout terugmelden aan het model in plaats van stilzwijgend te crashen. Het model kan dan:

  • Het verzoek herformuleren met gecorrigeerde parameters
  • De gebruiker informeren over het probleem
  • Een alternatieve tool proberen
try:
    result = search_database(query=args["query"])
    return json.dumps(result)
except ConnectionError:
    return json.dumps({
        "error": "Database niet beschikbaar",
        "suggestion": "Probeer het over een paar seconden opnieuw"
    })

Retourneer altijd gestructureerde JSON, zelfs bij een fout. Het model begrijpt foutberichten en past zijn reactie daarop aan.

Unieke en expliciete namen

Functienamen moeten uniek zijn in de tools-lijst. Als twee tools dezelfde naam hebben, is het gedrag ongedefinieerd; de API kan het verzoek weigeren of een van de tools negeren.

Hanteer een consistente naamgevingsconventie:

✅ Beste praktijken:
   get_weather          → data ophalen
   search_products      → zoeken
   create_ticket        → aanmaken
   update_order_status  → bijwerken
   delete_draft         → verwijderen

❌ Vermijden:
   fn1, fn2             → onbegrijpelijk
   doStuff              → te vaag
   getWeatherData       → camelCase (geef de voorkeur aan snake_case)

Beschrijvingen: de belangrijkste kwaliteitsfactor

De kwaliteit van de beschrijving bepaalt direct de betrouwbaarheid van function calling. Hieronder vindt u een vergelijkingstabel:

Zwakke beschrijving Effectieve beschrijving
"Zoeken" "Zoek naar producten op naam, categorie of prijsklasse in de e-commercecatalogus"
"Bericht verzenden" "Verzend een e-mail naar een ontvanger. Vereist een onderwerp en berichttekst. Ondersteunt geen bijlagen."
"Berekenen" "Bereken de totaalprijs inclusief btw op basis van een prijs exclusief btw en een btw-tarief. Retourneert het bedrag in euro's met 2 decimalen."

Het aantal tools optimaliseren

In plaats van bij elk verzoek 200 tools te declareren, selecteert u dynamisch de tools die er echt toe doen. Het eerste filter is context: als de gebruiker over weer praat, voegt het laden van facturatie-tools alleen maar ruis toe; lichte upstream-routing (op trefwoorden of een eerste classificatie-call) volstaat om alleen de relevante familie te presenteren. Het tweede filter is rol: een supportmedewerker heeft geen admin-tools nodig, en het verwijderen ervan is een kwestie van precisie én beveiliging. Het derde is stap: in een workflow met meerdere stappen heeft elke fase zijn eigen tools; ze laden naarmate u vordert, houdt het model gefocust op wat het nu moet doen.

Het voordeel is tweeledig en direct: minder input-tokens per verzoek (tool-definities kosten u bij elke call), en een betere selectienauwkeurigheid; een model dat kiest uit zes goed beschreven tools maakt zelden een fout, terwijl hetzelfde model dat geconfronteerd wordt met tweehonderd definities uiteindelijk vergelijkbare varianten door elkaar haalt.

Beveiliging: vertrouw het model nooit

Function calling is een potentiële injectievector. Een kwaadwillende gebruiker zou zijn verzoek zo kunnen formuleren dat de argumenten die aan functies worden doorgegeven, worden gemanipuleerd. Beveiligingsregels:

  • Valideer alle argumenten server-side
  • Beperk rechten: een leesfunctie mag niet kunnen schrijven
  • Log calls: traceer elke functieaanroep voor auditing
  • Sanitize inputs: escape speciale tekens voordat u SQL- of shell-query’s uitvoert

Belangrijkste punten

  • Maximaal 200 tools per verzoek, maar streef naar 5-20 voor efficiëntie
  • Valideer argumenten altijd client-side voordat u ze uitvoert
  • Retourneer fouten naar het model in gestructureerde JSON
  • Namen moeten uniek zijn, in snake_case en expliciet
  • Gedetailleerde beschrijvingen verbeteren de betrouwbaarheid drastisch
  • Selecteer dynamisch de relevante tools voor elk verzoek
  • Vertrouw nooit op argumenten zonder validatie