LLM API voor Agents: Gids voor Tool Calling
Een agent is een lus: het model kiest een tool, jouw code voert deze uit, het resultaat gaat terug en het model beslist wat er als volgende gebeurt. Hier is een werkende versie van die lus, plus de limieten en kosten waar je rekening mee moet houden.

Belangrijkste punten
- De endpoint ondersteunt tools, tool_choice, gestreamde tool_calls en role tool results.
- Beperk je lus, valideer tool-argumenten en herhaal 429-antwoorden met een korte wachttijd.
- Houd parallelle workers op of onder de 8 bij een volledige sleutel; streams houden hun slot vast tot ze eindigen.
- Een agentrun van zes stappen met een groeiend contextvenster kost ongeveer een halve cent.
Wat een agent nodig heeft van de API
Als je een LLM API voor agents kiest, is de checklist korter dan de marketing suggereert. Je hebt betrouwbare function calling nodig, een contextvenster groot genoeg voor de lopende transcriptie, voorspelbare rate limits en een prijs die een loop met veel calls niet straft.
Deze API behandelt deze punten via de standaard OpenAI-interface. Het ondersteunt tools en tool_choice, retourneert tool_calls in zowel normale als gestreamde antwoorden, en accepteert toolresultaten als berichten met role: "tool". JSON-modus is beschikbaar via response_format. Het contextvenster is 100.000 tokens voor prompt plus antwoord, en de model-ID is uncensored.
Omdat de framework-kant gewoon de OpenAI-client is, werken de meeste agent libraries die je een basis-URL laten instellen. Je wijst ze naar https://api.llmmodelsapi.com/v1, levert je sleutel aan en noemt het model. Setup-details staan in de documentatie, en je kunt een sleutel krijgen op de sleutelpagina.
Twee limieten bepalen het ontwerp. Ten eerste is het model alleen tekst, dus elke afbeeldings-, audio- of bestandsafhandeling moet in je tools gebeuren en als tekst terugkomen. Ten tweede zijn er geen embeddings op deze endpoint, dus als je agent retrieval doet, moet de vector search een andere bron hebben.
Een system prompt die de lus gezond houdt
De meeste agent-fouten komen door vage instructies, niet door de API. Een goede system prompt vertelt het model wie het is, welke tools er zijn, wanneer het moet stoppen en welke indeling het eindantwoord heeft. Hier is er een voor een research-assistent.
Je bent een onderzoeksassistent. Je kunt de tools search_notes en read_note aanroepen. Roep een tool alleen aan wanneer je informatie nodig hebt die je nog niet hebt. Gebruik maximaal vijf toolaanroepen. Als je genoeg hebt, antwoord dan met een kort antwoord en vermeld de notitie-ID's die je hebt gebruikt. Als de notities het antwoord niet bevatten, zeg dat dan gewoon.
Let op wat het doet. Het noemt de tools, stelt een aanroepbudget in, definieert de stopvoorwaarde en geeft het model toestemming om te zeggen dat het het niet weet. Dat laatste deel is belangrijk, omdat een agent die gedwongen wordt te antwoorden, iets zal verzinnen.
Stel een lage temperatuur in voor toolgebruik. Waarden rond 0,2 tot 0,4 houden toolnamen en argumentformaten stabiel. Als je agent ook creatieve tekst aan het einde schrijft, kun je de temperatuur voor die laatste aanroep alleen verhogen. De parameter seed wordt doorgegeven, wat helpt wanneer je een uitvoering wilt reproduceren tijdens het debuggen.
Voor volwassen fictie en roleplay-agents werkt hetzelfde patroon: zet de persona, de scenarionormen en de tools in het systeembericht. Het model is afgestemd op antwoorden zonder inhoudelijke weigeringen voor wettelijk volwassen gebruik. Seksuele inhoud met minderjarigen blijft buiten bereik.
Een minimale agent-loop in Python
De onderstaande lus heeft één tool, een opzoeking in een woordenboek dat als vervanging dient voor je echte gegevens. Het stopt wanneer het model antwoordt zonder een toolaanroep, of na een vast aantal stappen.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
NOTES = {
"n1": "Invoice 114 was paid on March 3.",
"n2": "Invoice 115 is overdue by 12 days.",
}
def search_notes(query):
return [{"id": k, "text": v} for k, v in NOTES.items() if query.lower() in v.lower()]
TOOLS = [{
"type": "function",
"function": {
"name": "search_notes",
"description": "Search internal notes by keyword",
"parameters": {
"type": "object",
"properties": {"query": {"type": "string"}},
"required": ["query"],
},
},
}]
SYSTEM = "You are a research assistant. Use search_notes when needed, at most five calls. Then answer briefly."
def run(question, max_steps=6):
messages = [
{"role": "system", "content": SYSTEM},
{"role": "user", "content": question},
]
for step in range(max_steps):
resp = client.chat.completions.create(
model="uncensored",
messages=messages,
tools=TOOLS,
temperature=0.3,
max_tokens=500,
)
msg = resp.choices[0].message
messages.append(msg)
if not msg.tool_calls:
return msg.content
for call in msg.tool_calls:
try:
args = json.loads(call.function.arguments)
result = search_notes(args["query"])
except Exception as exc:
result = {"error": str(exc)}
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
return "Stopped: step limit reached."
print(run("Which invoice is overdue?"))
Drie details verdienen aandacht. De staplimiet stopt een verwarde model in een lus voordat je budget op is. De try-blok zet een foutieve argument string om in een error message die het model kan lezen en corrigeren. En elk tool result wordt teruggestuurd met de bijpassende tool_call_id, waardoor het model weet bij welke call elk antwoord hoort.
Afhandeling van 429-antwoorden en gelijktijdigheid
Agents zijn piekachtig. Een planner kan vijf subtaken tegelijk uitsturen, en elk van hen voert zijn eigen lus uit. Daar komen rate limits om de hoek kijken.
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefaccount staat 2 en 60 toe. Voorbij de limiet antwoordt de API met HTTP 429. De error code vertelt je welke limiet je raakt: rate_limited voor verzoeken per minuut, concurrency voor te veel tegelijk. Bij tijdelijke overbelasting krijg je ook een 429, met een Retry-After: 5 header.
Behandel allemaal deze als opnieuw te proberen. Wacht het aantal seconden in de header, of een paar seconden als het afwezig is, en stuur het verzoek opnieuw. Mislukte verzoeken worden niet in rekening gebracht, dus opnieuw proberen kost niets. Een kleine wrapper doet de klus.
import time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY", max_retries=0)
def chat_with_retry(**kwargs):
for attempt in range(5):
try:
return client.chat.completions.create(model="uncensored", **kwargs)
except RateLimitError as err:
wait = 5
if err.response is not None:
wait = int(err.response.headers.get("retry-after", 5))
time.sleep(wait)
raise RuntimeError("Still rate limited after 5 attempts")
Om de 429 te voorkomen, beperk je je worker pool. Een semaphore van 8 komt overeen met de volledige sleutel. Als je responses streamt naar een user interface, onthoud dan dat een stream zijn concurrency slot vasthoudt tot het laatste token aankomt, dus een langzame client die een lang antwoord leest, bezet een slot de hele tijd. Het lezen van de X-RateLimit-Limit-Requests en X-RateLimit-Limit-Concurrency headers laat je code aanpassen aan welke sleutel het ook gebruikt.
Context, geheugen en wat een uitvoering kost
Elke stap van de loop stuurt de volledige transcriptie opnieuw. Zo werken chat APIs, en dat betekent dat input tokens groeien met elke tool call. Neem een zes-staps run waarbij de prompt begint bij 2.000 tokens en met 1.000 per stap groeit, met 300 output tokens per stap.
- Input tokens: 2.000 + 3.000 + 4.000 + 5.000 + 6.000 + 7.000 = 27.000
- Output tokens: 6 x 300 = 1.800
- Input kosten: 27.000 x 0,15 / 1.000.000 = $0,00405
- Outputkosten: 1.800 x 0,50 / 1.000.000 = $0,0009
- Totaal: $0,00495 per run
Duizend zulke runs kosten $4,95. Dat is goedkoop genoeg om een agent meerdere stappen te laten denken, maar de groei is het monitoren waard. Met 100.000 tokens ruimte zal een langlopende agent uiteindelijk het venster vullen, en een prompt van die grootte kost 100.000 x 0,15 / 1.000.000 = $0,015 voor input op elke enkele stap.
Drie gewoontes houden het onder controle. Knip grote toolresultaten af voordat ze in de transcriptie gaan, bijvoorbeeld de eerste 2.000 tekens van een webpagina. Vat oude stappen samen tot één kort bericht zodra de geschiedenis een drempel passeert. En sla duurzame feiten op in je eigen database in plaats van te vertrouwen op het gesprek als geheugen.
De X-Balance-USD header op elke response toont het resterende tegoed, zodat een agent supervisor een run kan stoppen als het saldo onder een floor daalt. Credit is prepaid vanaf $20, en het verloopt nooit. Zie de prijspagina voor top-up bonuses.
Eerlijke limieten om mee te plannen
Agents gebouwd op elk model hebben guardrails nodig, en deze is daarop geen uitzondering. Wees voorbereid op het volgende.
- Verkeerde argumenten. Het model kan toolargumenten produceren die geen geldige JSON zijn of een verplicht veld missen. Parse defensief en retourneer de fout als het toolresultaat.
- Verkeerde toolkeuze. Schrijf korte, onderscheidende toolbeschrijvingen. Als twee tools op elkaar lijken, zal het model ze door elkaar halen. Gebruik
tool_choiceom een specifieke aanroep af te dwingen als de flow dat vereist. - Alleen tekst. Geen image input of output, geen audio, geen embeddings, geen fine-tuning. Doe die delen elders en geef het resultaat door als tekst.
- Enkel model. Er is één open-weight model achter de endpoint, geen router tussen vendors. Je kunt geen kleiner model kiezen voor eenvoudige stappen.
- Destructieve tools. Geef een agent geen delete of payment tool zonder een bevestigingsstap in je eigen code.
Plannende agents profiteren ook van een tweede doorloop. Na de lus een antwoord retourneert, kun je nog een goedkope aanroep doen die het model vraagt het antwoord te controleren tegen de toolresultaten die het zag, met behulp van JSON-modus om een oordeel en een lijst van niet-ondersteunde claims terug te geven. Dat voegt een paar honderd tokens toe en vangt de meest voorkomende fout, wat een zelfverzekerd antwoord is dat negeert wat de tools retourneerden.
Log tot slot elke stap. Sla de messages, de tool arguments en de X-Request-Id header van elke response op. Als een run misgaat, laat de request ID je wijzen naar de exacte call, en het gelogde transcript toont welk tool result het model heeft misleid. Agents zijn het makkelijkst te verbeteren als je een slechte run kunt replayen en één ding tegelijk kunt veranderen.
Test een agent met de trial voordat je commit. Nieuwe gebruikers kunnen $0,50 credit claimen, wat bij de zes-staps run hierboven ongeveer 101 volledige runs dekt (0,50 / 0,00495). Houd de 2 gelijktijdige verzoeken van de trial in gedachten en draai één agent tegelijk. Voor een breder overzicht van de service, lees de pay-per-token overview. Prompts worden niet gebruikt voor training.
Meer handleidingen
Vragen en antwoorden
Ondersteunt de API function calling voor agents?
Ja. Het accepteert tools en tool_choice, retourneert tool_calls (ook bij streaming) en accepteert resultaten als berichten met role tool.
Hoeveel agent-calls kunnen parallel draaien?
Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 per minuut toe. Een proefsleutel staat 2 gelijktijdige en 60 per minuut toe.
Wat moet een agent doen bij een 429?
Wacht op de Retry-After waarde, of een paar seconden als die er niet is, en probeer het opnieuw. Afgekeurde verzoeken worden niet in rekening gebracht.
Kan de agent omgaan met afbeeldingen of audio?
Nee. Het model werkt alleen met tekst, dus andere media moeten door je eigen tools worden verwerkt en als tekst worden doorgegeven.
Je sleutel is nog maar één formulier verwijderd
Maak een account aan, kopieer de sleutel, pas de basis-URL aan. Dat is de hele setup.