Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Geen aangepaste functieaanroepen: de beperking begrijpen

Les 10 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Een structurele beperking
  2. De exacte grens
  3. Waar deze beperking vandaan komt
  4. Stel uw API’s bloot via een MCP-server
  5. Scheid onderzoek van actie
  6. Verrijk vooraf, verwerk achteraf
  7. Belangrijkste punten

Een structurele beperking

Als u gewend bent uw eigen functies te declareren en het model zelf te laten beslissen wanneer deze worden aangeroepen, moet u uw aanpak herzien: het multi-agent-systeem van Grok ondersteunt geen aangepaste functieaanroepen. Dit is geen configuratiedetail, maar een architecturale beperking die invloed heeft op de structuur van uw applicatie. Ontdek dit liever nu dan nadat u driehonderd regels functieschema’s hebt geschreven.

De exacte grens

Wat wel werkt, zijn de vijf ingebouwde tools uit de vorige les: web_search voor realtime webzoekopdrachten, x_search voor het X-platform, code_execution om Python uit te voeren, collections_search voor uw geïndexeerde collecties, en Remote MCP voor externe tools via het MCP-protocol. Niets anders werkt. Functies die in uw code zijn gedefinieerd, aangepaste schema’s en aanroepen naar uw eigen API’s via het mechanisme voor functieaanroepen worden allemaal geweigerd.

Specifiek heeft de onderstaande declaratie, die perfect geldig is bij een standaardmodel, geen effect in multi-agent.

# DOES NOT WORK with multi-agent
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the weather",
            "parameters": {"type": "object", "properties": {"city": {"type": "string"}}}
        }
    }
]

Waar deze beperking vandaan komt

De reden draait om coördinatie. Bij één enkel model is de lus voor functieaanroepen duidelijk: het model vraagt om een aanroep, uw code voert deze uit, u retourneert het resultaat en het model gaat verder. Introduceer nu vier of zestien agenten die parallel werken en de vragen stapelen zich op. Wie beslist om de functie aan te roepen? Wat als twee agenten tegelijkertijd dezelfde functie aanroepen met verschillende argumenten? Hoe synthetiseert de leider de resultaten verkregen door sub-agenten wiens redenering hij niet heeft gevolgd?

Ingebouwde tools zijn ontworpen voor deze context en weten hoe ze zich correct moeten gedragen wanneer meerdere agenten ze tegelijkertijd aanvragen. Uw functies zijn echter geschreven met de veronderstelling van één enkele aanroeper. Deze beperking weerspiegelt dat ontwerpverschil en is geen tijdelijk tekortkoming.

Stel uw API’s bloot via een MCP-server

De schoonste oplossing is het niet proberen te omzeilen, maar de bedoelde deur te gebruiken. Als u uw eigen services moet aanroepen, stel ze dan bloot via een MCP-server: agenten behandelen ze vervolgens als native tools, met het noodzakelijke concurrentiebeheer. Het vergt iets meer werk vooraf dan een functiedeclaratie, maar het blijft de enige manier om uw informatiesysteem in de zoeklus te brengen.

Scheid onderzoek van actie

Een tweede strategie, vaak de juiste wanneer uw functies neveneffecten triggeren: splits het proces in tweeën. De multi-agent doet wat hij kan: zoeken en analyseren; een standaardmodel neemt het over voor het deel dat uw API’s aanroept.

# Step 1: multi-agent research
chat = client.chat.create(
    model="grok-4.20-multi-agent-0309",
    agent_count=4,
    tools=[web_search()],
)
chat.append(user("Find the best Italian restaurants in Paris"))
research_result = ""
for response, chunk in chat.stream():
    if chunk.content:
        research_result += chunk.content

# Step 2: action with standard model + function calling
# Use grok-4.5 or another model that supports function calling

Deze scheiding heeft een onderschat voordeel: u kunt het zoekresultaat inspecteren en valideren voordat een onomkeerbare actie wordt geactiveerd. Een agent die een tafel reserveert op basis van ongecontroleerd onderzoek is zelden een goed idee.

Verrijk vooraf, verwerk achteraf

Een derde aanpak, de lichtste: roep uw API’s buiten het gesprek om, stroomopwaarts om de prompt te verrijken of stroomafwaarts om het antwoord te benutten. Veel behoeften waarvan men denkt dat ze functieaanroepen vereisen, komen eigenlijk neer op het injecteren van de juiste data op het juiste moment.

# Pre-processing: enrich context
user_data = my_api.get_user_profile(user_id)
context = f"User profile: {user_data}"

# Multi-agent with enriched context
chat.append(user(f"{context}\n\nAnalyze options matching this profile"))

Het klantprofiel, de bestelgeschiedenis of budgetbeperkingen hoeven niet door het model te worden opgehaald: u kent ze al, geef ze gewoon door. Houd tot slot in gedachten dat de API zich in bètafase bevindt en deze beperking in de toekomst kan evolueren. Des te meer reden om het multi-agent-gedeelte van uw code te isoleren achter een interface die u kunt evolueren zonder alles opnieuw te hoeven schrijven.

Belangrijkste punten

  • Aangepaste functieaanroepen worden niet ondersteund bij multi-agent
  • Alleen ingebouwde tools (web_search, x_search, code_execution, collections_search, Remote MCP) werken
  • Gebruik Remote MCP om uw eigen API’s bloot te stellen aan agenten
  • Adopteer een tweestapsarchitectuur als u functieaanroepen nodig hebt
  • Deze beperking kan evolueren in toekomstige versies (API bèta)