Function Calling en Tool Use via de API: Laat een LLM Acties Uitvoeren

Traditionele taalmodellen genereren uitsluitend tekst als antwoord. Met function calling (ook wel tool use genoemd) doorbreken we deze grens. Een Large Language Model retourneert niet langer een vrije tekst, maar een gestructureerd JSON-object waarmee jouw softwareapplicatie externe functies, databases of APIs kan aanroepen.

Via de centrale aggregatie-API van LLMNet stuur je tool-definities mee in je request payload. Het model analyseert de gebruikersvraag, bepaalt of er externe data of actie vereist is, en formuleert een gerichte functie-aanroep.

Hoe Function Calling Werkt (Conceptueel)

De interactie tussen jouw applicatie, de LLMNet API en het taalmodel verloopt in vier logische stappen:

1. Definitie: Je stuurt de user prompt mee én een array met beschikbare tools (inclusief JSON-schemas voor de parameters).
2. Analyse: Het LLM beoordeelt of de tool nodig is. Zo ja, dan onderbreekt het de tekstgeneratie en retourneert een signaal met de gekozen functienaam en argumenten.
3. Uitvoering: Jouw applicatie ontvangt de JSON, voert de daadwerkelijke actie uit (bijv. een databasequery of externe API-call).
4. Synthese: Je stuurt het resultaat van de tool terug naar het model, dat vervolgens een definitief, mensleesbaar antwoord formuleert voor de eindgebruiker.

JSON-schema voor Tool-definities

Om het model te instrueren welke argumenten verplicht of optioneel zijn, definieer je tools middels strikte JSON-schemas. Hieronder staat een representatieve definitie voor een tool die het actuele weer opvraagt:

{
"type": "function",
"function": {
"name": "get_current_weather",
"description": "Haalt de actuele weersverwachting op voor een opgegeven locatie.",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "De stad en provincie, bijv. 'Amsterdam, Noord-Holland'"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"]
}
},
"required": ["location"]
}
}
}

Pseudocode-voorbeeld: De Request-Response Loop

In de praktijk implementeer je function calling met een robuuste handelingslus in je backend. Dit vereenvoudigd pseudocode-voorbeeld toont hoe je de API aanspreekt en reageert op tool-calls:

import requests

api_url = "https://api.llmnet.nl/v1/chat/completions"
headers = {"Authorization": "Bearer DUMMY_API_KEY"}

payload = {
"model": "deepseek-chat",
"messages": [{"role": "user", "content": "Wat is het weer in Utrecht?"}],
"tools": [weather_tool_definition]
}

response = requests.post(api_url, json=payload, headers=headers).json()
message = response["choices"][0]["message"]

if "tool_calls" in message:
tool_call = message["tool_calls"][0]
func_name = tool_call["function"]["name"]
arguments = parse_json(tool_call["function"]["arguments"])

# Voer de lokale functie uit
result = execute_local_function(func_name, arguments)

# Stuur het resultaat terug naar het LLM voor eindconclusie
print(f"Tool resultaat: {result}")

Meer achtergrondinformatie over het opzetten van robuuste architecturen en het ontwerpen van leertrajecten rondom AI-integratie vind je in onze uitgebreide handleiding op llmnet.nl/leren/.