Tools en functieaanroepen in spraak
Op deze pagina
Een agent die handelt, niet alleen praat
Een spraakassistent die alleen kan chatten, loopt al snel tegen een muur op: hij beantwoordt “Waar is mijn bestelling?” beleefd, zonder ook maar iets te weten. De echte waarde van de Voice Agent ligt in het vermogen om actie te ondernemen midden in een gesprek (een database bevragen, een webzoekopdracht uitvoeren, een zakelijke API aanroepen, een MCP-server bereiken) en het resultaat voor te lezen alsof er niets aan de hand is.
De vijf soorten tools
Webzoekopdrachten nemen in hun eenvoudigste vorm geen parameters aan:
{ "type": "web_search" }
De agent zoekt vervolgens live op het web, wat feitelijke vragen, nieuws en alle gegevens dekt die te vaak veranderen om in een prompt te staan.
X-zoekopdrachten werken op dezelfde manier, met de optie om deze te beperken tot bepaalde accounts:
{
"type": "x_search",
"allowed_x_handles": ["corsen_ai"]
}
De parameter allowed_x_handles is optioneel, maar verandert wel wat de tool doet. Zonder deze parameter doorzoekt de agent het hele platform; met deze parameter wordt de agent een woordvoerder die alleen uw officiële berichten citeert.
Bestandszoekopdrachten doorzoeken verzamelingen van gevectoriseerde documenten, zoals uw handleidingen, procedures en productdocumentatie:
{
"type": "file_search",
"vector_store_ids": ["vs_abc123"],
"max_num_results": 10
}
Aangepaste functies openen de deur naar uw eigen systemen. Dit is het soort tool dat u het meest zult gebruiken, en het loont de moeite om deze zorgvuldig te definiëren:
{
"type": "function",
"name": "check_order",
"description": "Checks the status of a customer order",
"parameters": {
"type": "object",
"properties": {
"order_number": {
"type": "string",
"description": "The order number, in the format CMD-XXXX"
}
},
"required": ["order_number"]
}
}
U kunt op dezelfde manier een CRM, een ERP, een agenda of een interne database koppelen. Tot slot geven MCP-servers toegang tot gestandaardiseerde tools via het Model Context Protocol, zodat u niet voor elke service een integratie opnieuw hoeft te schrijven:
{
"type": "mcp",
"server_url": "https://mcp.example.com/sse",
"server_label": "My MCP server"
}
De volledige cyclus van een functieaanroep
Wanneer de agent besluit een functie aan te roepen, voert hij deze niet zelf uit: hij vraagt u dit te doen, en uw applicatie doet het werk. De argumenten worden eerst gestreamd via response.function_call_arguments.delta. Vervolgens markeert de gebeurtenis response.function_call_arguments.done het einde van het verzoek en geeft u de call_id samen met de volledige argumenten. Het is aan u om de functie uit te voeren en het resultaat vervolgens terug te sturen als een conversation.item.create van het type function_call_output:
{
"type": "conversation.item.create",
"item": {
"type": "function_call_output",
"call_id": "call_abc123",
"output": "{\"status\": \"shipped\", \"delivery_date\": \"2026-04-05\"}"
}
}
Een laatste stap is essentieel, en dit is de stap die mensen vaak vergeten: stuur response.create zodat de agent het resultaat kan verwerken in zijn gesproken antwoord. Zonder dit stapje bereikt het resultaat weliswaar het gesprek, maar gebeurt er niets. De gebruiker hoort stilte en u gaat op zoek naar de bug op de verkeerde plek.
Wanneer meerdere functies tegelijk worden geactiveerd
Het model kan besluiten om twee of drie functies tegelijk aan te roepen, bijvoorbeeld om een bestelling te controleren en het leveringsschema op te zoeken. U ontvangt dan meerdere function_call_arguments.done-gebeurtenissen, elk met een eigen call_id. Voer ze allemaal uit, bij voorkeur parallel zodat de latentie niet optelt, dien elk resultaat in via een eigen conversation.item.create en stuur pas helemaal op het einde één enkele response.create. Als u per functie een response.create zou sturen, zouden er evenveel concurrerende spraakreacties worden geactiveerd en zou de agent door zichzelf heen beginnen te praten.
// Ontvang en voer alle functies uit
const results = await Promise.all(
pendingCalls.map(call => executeFunction(call))
);
// Dien alle resultaten in
for (const result of results) {
ws.send(JSON.stringify({
type: "conversation.item.create",
item: {
type: "function_call_output",
call_id: result.callId,
output: JSON.stringify(result.data)
}
}));
}
// Activeer de respons
ws.send(JSON.stringify({ type: "response.create" }));
Specifieke beperkingen voor spraak
Wat in een tekstinterface onopgemerkt blijft, valt in spraak direct op, te beginnen met tijd. Niemand wacht meer dan drie tot vijf seconden midden in een gesprek. Daarboven denken gebruikers dat de verbinding is verbroken en beginnen ze zelf te praten. Als uw functie een traag systeem bevraagt, laat de agent dan een wachtfrazes uitspreken tijdens de oproep in plaats van doodse stilte te laten vallen.
De grootte van de resultaten is net zo belangrijk. De agent moet hardop samenvatten wat u hem geeft, en een lijst van veertig bestellingen leidt tot ofwel een eindeloze opsomming, ofwel een ruwe samenvatting. Retourneer gestructureerde gegevens, maar beperk deze tot wat echt relevant is. Besteed ook aandacht aan de beschrijving van elke functie, aangezien dit het enige is waarop het model vertrouwt om een keuze te maken: een vage beschrijving zoals “behandelt bestellingen” zorgt voor aarzeling of de keuze van het verkeerde instrument. En houd rekening met fouten. Wanneer een functie crasht, retourneer dan een expliciete foutmelding in output in plaats van niets, anders verzint de agent een antwoord zonder te weten dat de oproep is mislukt.
Belangrijkste punten
- De Voice Agent ondersteunt vijf soorten tools: webzoekopdracht, X-zoekopdracht, bestandszoekopdracht, functies en MCP
- Een functieaanroep doorloopt vier stappen: argumenten ontvangen, functie uitvoeren, resultaat retourneren en respons activeren
- Parallelle aanroepen zijn mogelijk: voer alles uit, dien alles in en stuur vervolgens één enkele
response.create - Bij spraak is de responstijd van functies cruciaal: streef naar minder dan 3 seconden