Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Odpověď a využití

Lekce 4 z 16 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Pochopte, co API vrací
  2. Kompletní anatomie odpovědi
  3. Pole choices
  4. Hodnoty finish_reason
  5. Objekt usage – Sledujte své náklady
  6. Obsah odpovědi
  7. Uveďte to do praxe
  8. Klíčové poznatky

Pochopte, co API vrací

Většina vývojářů, kteří s API teprve začínají, si přečte jen jediný řádek odpovědi – vygenerovaný text – a vše ostatní ignorují. To je chyba. Každé volání /v1/chat/completions vrací bohatý objekt JSON. Právě zde najdete data potřebná ke sledování nákladů, k odhalení oříznuté odpovědi dříve, než se dostane k uživateli, a k identifikaci konkrétního volání při otevírání tiketu na podporu.

Kompletní anatomie odpovědi

Začněme metadaty. Jsou to pole, která zřídka kontrolujete, ale budete si přát, abyste je logovali, když nastane incident:

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}")

Pole id je unikátní identifikátor přiřazený každému požadavku. Toto je reference, kterou uvedete technické podpoře, a ta, která vám umožní propojit stížnost uživatele s konkrétním voláním ve vašich logách. Pole model potvrzuje, který model byl skutečně použit. To je důležitější, než si možná myslíte, když voláte alias -latest a chování se přes noc změní bez jakýchkoli změn ve vašem kódu.

Pole choices

Srdce odpovědi leží v choices. Ve výchozím nastavení toto pole obsahuje jediný prvek. Z něj extrahujete jak text, tak verdikt o tom, jak generování skončilo:

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"

Pokud pomocí parametru n požádáte o více odpovědí, což probereme v lekci 15, bude choices obsahovat více prvků a index znovu nabude významu.

Hodnoty finish_reason

Toto pole určuje spolehlivost vaší aplikace. Existují tři možné hodnoty. stop signalizuje, že model přirozeně dokončil svou odpověď. Toto je běžný případ, kdy můžete obsah zobrazit bez výhrad. length znamená, že generování bylo přerušeno kvůli max_tokens, takže odpověď je potenciálně neúplná – shrnutí chybějící závěr nebo seznam, který se zastaví na sedmé položce. Nakonec tool_calls indikuje, že model žádá provedení externího nástroje v rámci volání funkcí a míč je nyní na vaší straně.

Každý z těchto případů vyžaduje odlišné zpracování, které byste měli napsat jednou provždy:

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}")

Všimněte si, že větev length nenechá text jen tak projít. Buď to zkusíte znovu s vyšším limitem, požádáte model o pokračování, nebo uživatele upozorníte. Co nikdy nesmíte udělat, je zobrazit oříznutý text, jako by byl úplný.

Objekt usage – Sledujte své náklady

Pole usage počítá tokeny spotřebované požadavkem a odděluje vstup od výstupu:

usage = response.usage

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

Tento rozdíl není jen kosmetický. Modely Mistral mají různé sazby pro vstup a výstup. Funkce, která odešle dlouhý kontext, aby získala zpět tři slova, má zcela jiný profil nákladů než dlouhý koncept vygenerovaný z stručného promptu. Výpočet zabere jen několik řádků:

# 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}")

Jedno volání stojí zlomek centu, což je falešně uklidňující. Vynásobte to skutečným provozem aplikace a otázkou se stává: která funkce co spotřebovává? Abyste na to odpověděli, agregujte metriky využití již od prvního nasazení. Logujte každé volání spolu s názvem funkce, která jej spustila:

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")

Soubor JSONL jako tento, po dvou týdnech zkontrolovaný, vám jednoznačně řekne, která obrazovka ve vašem produktu nejvíce zatěžuje účet – a kolik volání končí s hodnotou length.

Obsah odpovědi

Pole content zprávy asistenta může mít dvě formy, přesně jako na straně požadavku:

# 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": "..."}]

V praxi je u standardních volání Chat Completions content vždy řetězec. Strukturovaná forma je vyhrazena pro multimodální odpovědi.

Uveďte to do praxe

Pojďme to vše spojit do utility funkce – té, kterou budete kopírovat z projektu do projektu. Sestaví zprávy, provede volání a vrátí slovník, který zpřístupňuje jak metriky, tak text:

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
    }

Klíčové je, co funkce vrací: nikdy jen text. Tím, že předáte volajícímu finish_reason, počty tokenů a ID požadavku, znemožníte nejčastější chybu – považování useknuté odpovědi za platnou.

Klíčové poznatky

  • Odpověď obsahuje choices (obsah), usage (tokeny) a metadata (id, model)
  • Vždy kontrolujte finish_reason – length znamená neúplnou odpověď
  • usage počítá vstupní a výstupní tokeny odděleně pro přesné sledování nákladů
  • Nastavte si logování metrik již od prvního produkčního nasazení
  • Pole id je nezbytné pro ladění a technickou podporu