Uw eerste API-aanroep in Python
Op deze pagina
Uw eerste uitwisseling met een Mistral-model
De SDK is geïnstalleerd en uw API-sleutel is klaar: het is tijd om een echt verzoek te versturen en, nog belangrijker, te begrijpen wat er terugkomt. Veel ontwikkelaars stoppen bij de eerste regel van het antwoord en negeren de rest van het geretourneerde object. Dat is een fout, omdat kostenbewaking en diagnostiek voor afgekapte antwoorden precies in die overige gegevens zitten. We beginnen met minimale code en werken toe naar de volledige structuur.
De client initialiseren
De client is het toegangspunt voor al uw interacties met de API:
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
Deze verzorgt HTTP-verbindingen, probeert opnieuw bij netwerkfouten en serialiseert verzoeken. Instantieer deze één keer bij het opstarten van de applicatie. Het voor elke aanroep opnieuw maken van een client dwingt u om onnodig te betalen voor het opzetten van verbindingen en is een van de meest subtiele oorzaken van buitensporige latentie.
Een verzoek versturen met chat.complete()
U zult de methode chat.complete() het vaakst gebruiken. Deze verzendt uw berichten en wacht op het volledige antwoord van het model voordat de controle wordt teruggegeven:
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{
"role": "user",
"content": "Leg het concept van tokenisatie uit in drie zinnen."
}
]
)
print(response.choices[0].message.content)
Twee parameters volstaan hier. model specificeert de model-ID: mistral-small-latest wijst altijd naar de nieuwste versie van Mistral Small, waardoor dit de logische keuze is om mee te beginnen, omdat het snel en zuinig is. messages verwacht een lijst met gestructureerde berichten, elk met een role—system, user of assistant—en een content-veld dat de tekst bevat. Deze structuur lijkt misschien zwaar voor een enkele vraag, maar krijgt volledige zin zodra u bij de les over gesprekken met meerdere beurten komt.
Het geretourneerde object lezen
Het response-object bevat veel meer dan alleen de gegenereerde tekst:
# Antwoordtekst
text = response.choices[0].message.content
# Rol (altijd "assistant" voor een antwoord)
role = response.choices[0].message.role
# Reden voor stoppen
finish = response.choices[0].finish_reason # "stop", "length", etc.
# Token-statistieken
input_tokens = response.usage.prompt_tokens
output_tokens = response.usage.completion_tokens
total_tokens = response.usage.total_tokens
print(f"Antwoord ({output_tokens} tokens): {text}")
print(f"Totaal verbruikte tokens: {total_tokens}")
Besteed vanaf dag één veel aandacht aan het veld usage. Door dit bij elke aanroep te loggen, weet u precies welke functie van uw applicatie uw budget opsoupeert, zonder dat u aan het einde van de maand uw factuur hoeft te reverse-engineeren.
Wat finish_reason betreft: dit geeft aan waarom het model stopte en heeft een van de volgende waarden:
stop: het model heeft zijn antwoord op natuurlijke wijze voltooidlength: het antwoord werd afgekap omdatmax_tokenswerd bereiktmodel_length: de totale context (invoer + uitvoer) bereikte de limiet van het model
Een antwoord dat halverwege een zin eindigt, is geen bug in het model: het is een finish_reason van length die niemand heeft gecontroleerd. Verifieer dit altijd voordat u concludeert dat er een kwaliteitsprobleem is.
Modelgedrag aanpassen
Drie extra parameters stellen u in staat de generatie te sturen:
response = client.chat.complete(
model="mistral-large-latest",
messages=[
{
"role": "user",
"content": "Stel drie namen voor voor een educatieve AI-startup."
}
],
temperature=0.7,
max_tokens=500,
top_p=0.95,
)
Temperatuur regelt de mate van vrijheid van het model. Bij 0.0 zijn antwoorden deterministisch: dezelfde prompt levert altijd dezelfde tekst op, wat u wilt bij extractie of classificatie. Tussen 0.3 en 0.5 krijgt u een goede balans voor feitelijke taken. Tussen 0.7 en 1.0 worden antwoorden creatiever en gevarieerder—dit is het bereik dat in het bovenstaande voorbeeld wordt gebruikt, omdat we om naamideeën vragen en het zinloos zou zijn om drie keer hetzelfde idee te zien. Boven 1.0 wordt de generatie zeer willekeurig en heeft deze zelden praktisch nut.
max_tokens beperkt de lengte van het antwoord, wat helpt om kosten te beheersen en uitvoeren hanteerbaar te houden. Denk eraan dat als het model wordt afgekap, finish_reason gelijk zal zijn aan "length". top_p beïnvloedt de diversiteit via een ander mechanisme: het filtert de minst waarschijnlijke tokens eruit. Een waarde van 0.95 betekent dat het model alleen tokens in overweging neemt die samen 95% van de cumulatieve waarschijnlijkheid vertegenwoordigen.
Een productieklare aanroep
Onder reële omstandigheden valt het netwerk uit, verlopen sleutels en raken quota’s vol. Omkleed uw aanroepen altijd met foutafhandeling:
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
try:
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{"role": "user", "content": "Wat is de hoofdstad van Frankrijk?"}
],
max_tokens=100,
)
text = response.choices[0].message.content
print(f"Antwoord: {text}")
print(f"Gebruikte tokens: {response.usage.total_tokens}")
except Exception as e:
print(f"Fout bij API-aanroep: {e}")
Gebruik dit skelet voor uw eigen experimenten door simpelweg de inhoud van het bericht te vervangen. Het is het startpunt voor alles wat volgt in deze cursus.
Belangrijkste punten
client.chat.complete()is de primaire methode voor interactie met modellen- De antwoordtekst staat in
response.choices[0].message.content response.usagevertelt u hoeveel tokens zijn verbruikt (nuttig voor kostenbewaking)temperatureregelt de creativiteit;max_tokensbeperkt de lengte- Begin met
mistral-small-latest: het is snel, zuinig en presteert goed