Beperkingen en beste praktijken
Op deze pagina
- Technische beperkingen van function calling
- Maximaal 200 tools per verzoek
- Het model garandeert geen geldigheid van argumenten
- Foutafhandeling
- Unieke en expliciete namen
- Beschrijvingen: de belangrijkste kwaliteitsfactor
- Het aantal tools optimaliseren
- Beveiliging: vertrouw het model nooit
- 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
stringdoorgeven waar eenintegerwordt 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