API-anti-mønstre
På denne side
Fejl, der koster penge i produktion
Efter at have gennemgået bedste praksis er det tid til at se på bagsiden af medaljen. Anti-mønstrene nedenfor er de hyppigste faldgruber ved brug af Chat Completions API’en, og de deler én ubehagelig egenskab: De viser sig ikke under udviklingen. Ud af ti testforespørgsler virker alt fint. Det er i produktion, det eksploderer og forårsager uventede omkostninger, inkohærente svar, høj latens eller – værre endnu – lækage af følsomme data.
At behandle et afkortet svar som fuldstændigt
Den mest almindelige fejl er at ignorere finish_reason. Du beder om en kontrakt, får noget tekst tilbage og gemmer den i databasen: bortset fra at max_tokens=100 afbrød genereringen midt i en klausul, og ingen opdager det, før kunden underskriver. Løsningen tager tre kod linjer og bør blive en refleks.
# DÅRLIGT — ingen verifikation
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Draft a complete contract."}],
max_tokens=100 # For kort til en kontrakt!
)
contract = response.choices[0].message.content # Potentielt afkortet!
# GODT — systematisk verifikation
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Draft a complete contract."}],
max_tokens=4000
)
if response.choices[0].finish_reason == "length":
print("ADVARSEL: Svar afkortet, øg max_tokens")
else:
contract = response.choices[0].message.content
At lade samtalehistorikken vokse uden grænser
Den anden fælde udløses langsomt. En chat-løkke, der sender hele samtalehistorikken ved hvert skift, fungerer perfekt de første ti udvekslinger, koster det dobbelte ved det tyvende og overskrider til sidst kontekstvinduet ved det hundredede – med regningen, der følger samme kurve. Løsningen er at beholde system-prompten (ikke-forhandlingsbar) og kun beholde de sidste N beskeder.
# DÅRLIGT — historikken vokser ubegrænset
conversation = []
while True:
user_input = input("Du: ")
conversation.append({"role": "user", "content": user_input})
response = client.chat.complete(
model="mistral-large-latest",
messages=conversation # 100 runder = tusindvis af tokens!
)
reply = response.choices[0].message.content
conversation.append({"role": "assistant", "content": reply})
# GODT — glidende vindue med beskæring
MAX_MESSAGES = 20
def trim_conversation(messages: list, max_messages: int = MAX_MESSAGES) -> list:
"""Beholder system-prompten + de sidste N beskeder."""
system = [m for m in messages if m["role"] == "system"]
history = [m for m in messages if m["role"] != "system"]
if len(history) > max_messages:
history = history[-max_messages:]
return system + history
At antage, at netværket altid svarer
Et bart API-kald antager, at intet går galt: ingen timeouts, ingen 429’er, ingen 500’er. I produktion sker alle tre, og den tredje sker på det værst tænkelige tidspunkt. Bemærk forskellen i koden: En 429 berettiger eksponentiel backoff, en serverfejl kræver et sekunds tålmodighed, men en klientfejl som en 400 eller 401 må aldrig genprøves – din nøgle bliver ikke gyldig ved tredje forsøg; du forsinker blot diagnosen.
# DÅRLIGT — ingen fejlhåndtering
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Hello"}]
)
# Crasher ved timeout, 429, 500...
# GODT — genprøv med backoff
from mistralai.client.errors import SDKError
import time
def safe_complete(client, messages, max_retries=3, **kwargs):
"""API-kald med genprøvning og eksponentiel backoff."""
for attempt in range(max_retries):
try:
return client.chat.complete(messages=messages, **kwargs)
except SDKError as e:
if e.status_code == 429:
wait = 2 ** attempt
print(f"Rate limit ramt, venter {wait}s...")
time.sleep(wait)
elif e.status_code >= 500:
time.sleep(1)
else:
raise # Klientfejl (400, 401) — genprøv ikke
raise Exception("Mislykkedes efter 3 forsøg")
At bede modellen gøre det, den ikke kan
Tre anti-mønstre løber sammen her. Det første er subjektivt sprog: „kort”, „mange”, „interessant” refererer til intet verificerbart, og modellen vil beslutte anderledes fra kald til kald. Erstat hvert tillægsord med et tal eller et observerbart kriterium.
# DÅRLIGT — subjektivt, ikke målbart
"Skriv et kort resumé." # Kort = 1 sætning? 1 afsnit?
"Giv mange eksempler." # Mange = 3? 10? 50?
"Svar på en interessant måde." # Interessant efter hvilke kriterier?
# GODT — objektive kriterier
"Skriv et resumé på 50 til 80 ord."
"Giv præcis 5 eksempler, ét pr. linje."
"Start hvert svar med en relevant statistik."
Det andet er at lade modellen tælle. LLM’er er notorisk dårlige til at tælle ord, tegn og elementer: At bede om „præcis 280 tegn” vil producere tekst på 240 eller 310. Tælling hører hjemme i din applikation, ikke i modellen.
# DÅRLIGT — modellen kan ikke tælle præcist
"Skriv præcis 280 tegn til en tweet."
# GODT — tæl på applikationssiden
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Write a tweet about AI in France."}],
max_tokens=100
)
tweet = response.choices[0].message.content
if len(tweet) > 280:
tweet = tweet[:277] + "..."
print(f"Tweet ({len(tweet)} tegn): {tweet}")
Det tredje falder i samme familie: numeriske skalaer. „Bedøm fra 1 til 5” antager, at modellen har en stabil repræsentation af kløften mellem 3 og 4, hvilket den ikke har. En verbal skala, hvor hvert trin er defineret af et kriterium, giver langt mere reproducerbare bedømmelser.
# DÅRLIGT — modeller fortolker numeriske skalaer dårligt
"Bedøm kvaliteten af denne tekst fra 1 til 5."
# GODT — verbal skala med definitioner
"""Bedøm kvaliteten af denne tekst efter følgende skala:
- FORTRÆFFELIG: Klar, velstruktureret, ingen fejl
- GOD: Generelt korrekt, mindre forbedringer mulige
- MIDDEL: Forståelig, men mangler struktur eller indeholder fejl
- DÅRLIG: Svær at forstå, betydelige fejl
- MEGET DÅRLIG: Uforståelig eller off-topic
Svar kun med mærkatet med store bogstaver."""
At deploye uden at efterlade spor
Det sidste anti-mønster er det mest diskrete: At kalde API’en, returnere indholdet og beholde ingenting. Den dag en bruger rapporterer et aberrant svar, har du hverken request-ID’et, den faktiske model, der blev betjent, eller token-forbruget. Struktureret logning pr. kald koster få millisekunder og gør undersøgelse mulig.
# DÅRLIGT — intet spor
response = client.chat.complete(
model="mistral-large-latest",
messages=messages
)
return response.choices[0].message.content
# GODT — struktureret logning
import logging
import json
logger = logging.getLogger("mistral_api")
def logged_complete(client, messages, **kwargs):
"""API-kald med struktureret logning."""
response = client.chat.complete(messages=messages, **kwargs)
logger.info(json.dumps({
"request_id": response.id,
"model": response.model,
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"finish_reason": response.choices[0].finish_reason
}))
return response
En debug-rutine
Når et svar ikke lever op til dine forventninger, er fristelsen at omskrive prompten. Start i stedet med fem mekaniske tjek, i rækkefølge: Er svaret fuldstændigt? Svarede den korrekte model? Hvor mange tokens blev brugt? Er svaret tomt? Er output/input-forholdet plausibelt? Et forhold under 1 % ved en stor prompt signalerer næsten altid, at modellen nægtede at behandle forespørgslen snarere end at mishandle den.
def debug_response(response):
"""Debug-tjekliste for uventede svar."""
choice = response.choices[0]
# 1. Er svaret fuldstændigt?
if choice.finish_reason == "length":
print("PROBLEM: Svar afkortet — øg max_tokens")
# 2. Blev den korrekte model brugt?
print(f"Model: {response.model}")
# 3. Hvor mange tokens brugt?
print(f"Input tokens: {response.usage.prompt_tokens}")
print(f"Output tokens: {response.usage.completion_tokens}")
# 4. Er svaret tomt?
if not choice.message.content or not choice.message.content.strip():
print("PROBLEM: Tomt svar")
# 5. Mistænkeligt input/output-forhold?
ratio = response.usage.completion_tokens / max(response.usage.prompt_tokens, 1)
if ratio < 0.01:
print(f"ADVARSEL: Meget lavt output/input-forhold ({ratio:.4f})")
Vigtige pointer
- Tjek altid
finish_reasonfor at opdage afkortning - Begræns samtalehistorikken med et glidende vindue
- Implementér genprøvning med eksponentiel backoff ved netværksfejl
- Brug objektive, målbare kriterier i dine prompts
- Lad aldrig modellen tælle – valider på applikationssiden
- Log hvert API-kald i produktion til debugging og omkostningssporing