Spring til hovedindhold
Dansk— Vælg et sprog
Menu

API-anti-mønstre

Lektion 12 af 16 Opdateret 2. november 2026 Udvikler
På denne side
  1. Fejl, der koster penge i produktion
  2. At behandle et afkortet svar som fuldstændigt
  3. At lade samtalehistorikken vokse uden grænser
  4. At antage, at netværket altid svarer
  5. At bede modellen gøre det, den ikke kan
  6. At deploye uden at efterlade spor
  7. En debug-rutine
  8. Vigtige pointer

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_reason for 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