Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Svar og brug

Lektion 4 af 16 Opdateret 2. november 2026 Udvikler
På denne side
  1. Forstå, hvad API’en returnerer
  2. Den fulde anatomi af et svar
  3. Arrayet choices
  4. Værdier for finish_reason
  5. Objektet usage – Spor dine omkostninger
  6. Svarindhold
  7. Sæt det i praksis
  8. Vigtige pointer

Forstå, hvad API’en returnerer

De fleste udviklere, der er nye til API’en, læser kun én linje i svaret – den genererede tekst – og ignorerer alt andet. Det er en fejl. Hvert kald til /v1/chat/completions returnerer et omfattende JSON-objekt. Her finder du de data, du har brug for til at spore omkostninger, opdage et afkortet svar, før det når brugeren, og identificere et specifikt kald, når du åbner en support-sag.

Den fulde anatomi af et svar

Lad os starte med metadataene. Det er de felter, du sjældent tjekker, men som du vil ønske, du havde logget den dag, en hændelse indtræffer:

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "What is machine learning?"}],
    max_tokens=500
)

# Access metadata
print(f"Request ID : {response.id}")
print(f"Model used : {response.model}")
print(f"Created at : {response.created}")

Feltet id er en unik identifikator, der tildeles hver anmodning. Det er den reference, du angiver til teknisk support, og som giver dig mulighed for at knytte en brugerklage til et specifikt kald i dine logs. Feltet model bekræfter, hvilken model der faktisk blev brugt. Det er vigtigere, end du måske tror, når du kalder et -latest-alias, og adfærden ændrer sig over natten uden kodeændringer fra din side.

Arrayet choices

Hjertet i svaret findes i choices. Som standard indeholder dette array ét enkelt element. Herfra udtrækker du både teksten og dommen over, hvordan genereringen sluttede:

choice = response.choices[0]

# The generated message
print(choice.message.role)      # "assistant"
print(choice.message.content)   # The response text

# The index of this response in the array
print(choice.index)             # 0

# The stop reason
print(choice.finish_reason)     # "stop", "length", or "tool_calls"

Hvis du anmoder om flere svar ved hjælp af parameteren n, hvilket vi dækker i lektion 15, vil choices indeholde flere elementer, og indekset vil igen få betydning.

Værdier for finish_reason

Dette felt afgør din applikations pålidelighed. Der er tre mulige værdier. stop signalerer, at modellen har afsluttet sit svar naturligt. Dette er det normale tilfælde, hvor du kan vise indholdet uden forbehold. length betyder, at genereringen blev afbrudt af max_tokens, så svaret er potentielt ufuldstændigt – et sammendrag, der mangler sin konklusion, eller en liste, der stopper ved det syvende punkt. Endelig indikerer tool_calls, at modellen anmoder om udførelse af et eksternt værktøj som led i funktionskald, og bolden er nu på din banehalvdel.

Hver af disse tilfælde kræver særskilt håndtering, som du bør skrive én gang for alle:

response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Write a detailed report."}],
    max_tokens=200
)

choice = response.choices[0]

if choice.finish_reason == "stop":
    # Complete response — normal processing
    result = choice.message.content

elif choice.finish_reason == "length":
    # Truncated response — retry with more tokens or warn the user
    print("Warning: The response was truncated.")
    # Option: Retry with a higher max_tokens limit
    # Option: Ask the model to continue

elif choice.finish_reason == "tool_calls":
    # The model requests a tool call
    for tool_call in choice.message.tool_calls:
        print(f"Requested tool: {tool_call.function.name}")

Bemærk, at grenen for length ikke bare lader teksten passere videre. Du forsøger enten igen med en højere grænse, beder modellen om at fortsætte, eller advarer brugeren. Det, du aldrig må gøre, er at vise afkortet tekst, som om den var komplet.

Objektet usage – Spor dine omkostninger

Feltet usage tæller de tokens, der er forbrugt af anmodningen, og adskiller input fra output:

usage = response.usage

print(f"Input tokens  : {usage.prompt_tokens}")
print(f"Output tokens : {usage.completion_tokens}")
print(f"Total         : {usage.total_tokens}")

Denne sondring er ikke kun kosmetisk. Mistral-modeller har forskellige takster for input og output. En funktion, der sender en lang kontekst for at få tre ord tilbage, har en helt anden omkostningsprofil end et langt udkast genereret fra en kort prompt. Beregningen tager kun få linjer:

# Hypothetical rates per million tokens (check current pricing)
RATE_INPUT = 2.0    # $/M tokens input
RATE_OUTPUT = 6.0   # $/M tokens output

cost_input = (usage.prompt_tokens / 1_000_000) * RATE_INPUT
cost_output = (usage.completion_tokens / 1_000_000) * RATE_OUTPUT
cost_total = cost_input + cost_output

print(f"Cost of this call: ${cost_total:.6f}")

Et enkelt kald koster en brøkdel af en cent, hvilket er falsk beroligende. Gang det med den reelle trafik i en applikation, og spørgsmålet bliver: hvilken funktion forbruger hvad? For at besvare det skal du aggregere brugsmetrics helt fra din første implementering. Log hvert kald sammen med navnet på den funktion, der udløste det:

import json
from datetime import datetime

def log_usage(response, endpoint_name: str):
    """Logs usage metrics for each API call."""
    log_entry = {
        "timestamp": datetime.utcnow().isoformat(),
        "endpoint": endpoint_name,
        "model": response.model,
        "prompt_tokens": response.usage.prompt_tokens,
        "completion_tokens": response.usage.completion_tokens,
        "total_tokens": response.usage.total_tokens,
        "finish_reason": response.choices[0].finish_reason,
        "request_id": response.id
    }

    with open("api_usage.jsonl", "a") as f:
        f.write(json.dumps(log_entry) + "\n")

# Usage
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Hello"}]
)
log_usage(response, "main_chatbot")

En JSONL-fil som denne, gennemgået efter to uger, vil fortælle dig utvetydigt, hvilken skærm i dit produkt, der belaster regningen mest – og hvor mange kald der ender med length.

Svarindhold

Feltet content i assistentens besked kan antage to former, præcis som på anmodningssiden:

# Simple form — string
content = response.choices[0].message.content
# "Machine learning is a branch of artificial intelligence..."

# Structured form — list of blocks (rare in standard chat)
# [{"type": "text", "text": "..."}]

I praksis er content altid en streng ved standard Chat Completions-kald. Den strukturerede form er reserveret til multimodale svar.

Sæt det i praksis

Lad os samle alt dette i en hjælpefunktion – den, du kopierer fra projekt til projekt. Den samler beskederne, foretager kaldet og returnerer et ordbogsobjekt, der eksponerer både metrics og tekst:

from mistralai.client import Mistral

def chat_complete(
    client: Mistral,
    prompt: str,
    system: str = "",
    model: str = "mistral-large-latest",
    max_tokens: int = 1000
) -> dict:
    """Chat Completions call with error handling and metrics."""
    messages = []
    if system:
        messages.append({"role": "system", "content": system})
    messages.append({"role": "user", "content": prompt})

    response = client.chat.complete(
        model=model,
        messages=messages,
        max_tokens=max_tokens
    )

    return {
        "content": response.choices[0].message.content,
        "finish_reason": response.choices[0].finish_reason,
        "tokens_in": response.usage.prompt_tokens,
        "tokens_out": response.usage.completion_tokens,
        "model": response.model,
        "id": response.id
    }

Nøglen er, hvad funktionen returnerer: aldrig kun teksten. Ved at føre finish_reason, tokentællinger og anmodnings-ID videre til kalderen gør du den mest almindelige fejl umulig – at behandle et afkortet svar som et gyldigt ét.

Vigtige pointer

  • Svaret indeholder choices (indhold), usage (tokens) og metadata (id, model)
  • Tjek altid finish_reason – length betyder et ufuldstændigt svar
  • usage tæller input- og output-tokens separat for præcis omkostningssporing
  • Opsæt logning af metrics helt fra din første produktionsimplementering
  • Feltet id er afgørende for fejlfinding og teknisk support