Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Bedste praksis for produktion

Lektion 16 af 16 Opdateret 2. november 2026 Udvikler
På denne side
  1. Fra proof of concept til drift
  2. Godkendelse og model-versionering
  3. En klient, der håndterer hændelser
  4. Spor omkostninger, mens de opstår
  5. Valider i begge ender
  6. Hold styr på kontekstvinduet
  7. Hvad du tager med fra dette kursus
  8. Vigtige pointer
  9. Test din viden

Fra proof of concept til drift

Du har nu styr på alle parametre i Chat Completions API’et. Den sværeste del mangler stadig: at overbygge kløften mellem en fungerende notebook og en tjeneste, andre kan bruge uden din indblanding. Denne sidste lektion samler hele kurset til en handlingsorienteret produktionscheckliste og peger derefter mod opfølgende kurser.

Godkendelse og model-versionering

To beslutninger skal træffes før den første linje forretningslogik. Den første vedrører API-nøglen: den skal ligge i en miljøvariabel, aldrig i koden, og en startvalidering slår en None, der propagerer tre lag ned i en uforståelig fejlmeddelelse. Planlæg også rotation – opret den nye nøgle, deploy den, og træk derefter den gamle tilbage, i den rækkefølge, hvis du vil undgå at tage tjenesten offline.

import os

# ALTID: API-nøgle i miljøvariabel
api_key = os.getenv("MISTRAL_API_KEY")
assert api_key, "MISTRAL_API_KEY ikke defineret"

# ALDRIG: hardcodet nøgle i kode
# api_key = "sk-abc123..."  # FORBUDT i produktion

# ALTID: regelmæssig nøglerotation
# Opret en ny nøgle, deploy den, og træk derefter den gamle tilbage

Den anden beslutning vedrører model-identifikatoren. I udvikling giver -latest dig forbedringer uden indsats. I produktion betyder samme alias, at en versionsændring på udbyders side kan ændre din applikations adfærd uden varsel, en tirsdag morgen, uden commit-spor til at forklare det. Pin versionen.

# UDVIKLING — seneste version
model = "mistral-large-latest"

# PRODUKTION — fast version for reproducerbarhed
model = "mistral-large-2512"

# Hvorfor? En ændring i "latest" kan ændre din applikations adfærd
# uden varsel.

En klient, der håndterer hændelser

Hjertet i en produktionsintegration er ikke API-kaldet, men alt omkring det. Klassen nedenfor samler tre ansvarsområder i ét kontrolpunkt: genforsøg med eksponentiel backoff ved 429-fejl, en kort pause ved serverfejl og øjeblikkelig eskalering af klientfejl, som intet genforsøg kan løse. Den normaliserer også svaret til en stabil ordbog – indhold, finish_reason, forbrug, model, ID – så resten af din kode ikke længere afhænger af den nøjagtige form på objektet returneret af SDK’et. logger.warning ved trunkeringer alene begrunder indkapslingen: det er den eneste måde at opdage, at en max_tokens-indstilling er for stram, før brugere rapporterer det.

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import time
import logging

logger = logging.getLogger(__name__)

class MistralClient:
    """Produktionsklient med genforsøg, timeout og logning."""

    def __init__(self, api_key: str, max_retries: int = 3):
        self.client = Mistral(api_key=api_key)
        self.max_retries = max_retries

    def complete(self, messages: list, **kwargs) -> dict:
        for attempt in range(self.max_retries):
            try:
                response = self.client.chat.complete(
                    messages=messages,
                    **kwargs
                )

                result = {
                    "content": response.choices[0].message.content,
                    "finish_reason": response.choices[0].finish_reason,
                    "usage": {
                        "prompt": response.usage.prompt_tokens,
                        "completion": response.usage.completion_tokens,
                        "total": response.usage.total_tokens,
                    },
                    "model": response.model,
                    "id": response.id,
                }

                # Advar hvis svar blev trunkeret
                if result["finish_reason"] == "length":
                    logger.warning(f"Svar trunkeret — req_id={response.id}")

                return result

            except SDKError as e:
                if e.status_code == 429:
                    wait = 2 ** attempt
                    logger.warning(f"Rate limit, genforsøg {attempt+1}/{self.max_retries} om {wait}s")
                    time.sleep(wait)
                elif e.status_code >= 500:
                    logger.error(f"Serverfejl {e.status_code}, genforsøg {attempt+1}")
                    time.sleep(1)
                else:
                    logger.error(f"Klientfejl {e.status_code}: {e.message}")
                    raise

        raise Exception(f"Mislykkedes efter {self.max_retries} forsøg")

Spor omkostninger, mens de opstår

At opdage dit forbrug på den månedlige regning er en luksus, få teams har råd til. Trackeren nedenfor skriver én JSONL-linje per kald – tidsstempel, model, input- og output-tokens, finish_reason, anmodnings-ID – og vedligeholder et sessions-total, du kan spørge til når som helst. JSONL-formatet er ikke en detalje: det aggregerer med ethvert analyseværktøj uden et parsing-trin, og tilstedeværelsen af anmodnings-ID’et lader dig knytte en omkostningsanomali til et specifikt kald.

import json
from datetime import datetime, timezone

class CostTracker:
    """Realtids-sporing af API-omkostninger."""

    def __init__(self, log_path: str = "api_costs.jsonl"):
        self.log_path = log_path
        self.session_tokens = {"prompt": 0, "completion": 0}

    def log(self, response_data: dict):
        usage = response_data["usage"]
        self.session_tokens["prompt"] += usage["prompt"]
        self.session_tokens["completion"] += usage["completion"]

        entry = {
            "ts": datetime.now(timezone.utc).isoformat(),
            "model": response_data["model"],
            "prompt_tokens": usage["prompt"],
            "completion_tokens": usage["completion"],
            "finish_reason": response_data["finish_reason"],
            "id": response_data["id"],
        }

        with open(self.log_path, "a") as f:
            f.write(json.dumps(entry) + "\n")

    def report(self) -> str:
        total = self.session_tokens["prompt"] + self.session_tokens["completion"]
        return (
            f"Session — Prompt: {self.session_tokens['prompt']:,} | "
            f"Completion: {self.session_tokens['completion']:,} | "
            f"Total: {total:,} tokens"
        )

Valider i begge ender

En robust applikation stoler hverken på det, der går ind, eller det, der kommer ud. Ved input skal du afvise tomme beskeder, sætte loftet ved 10.000 tegn for at forhindre, at en uheldig copy-paste får din regning til at eksplodere, og fjerne kontroltegn, der forstyrrer tokenisering. Ved output skal du ikke afvise noget, men rejse advarsler: potentielt trunkeret svar, unormalt kort svar under fem tegn, unormalt langt svar over 50.000. Disse tre signaler fanger langt de fleste stille fejl.

def validate_input(user_message: str) -> str:
    """Valider og rens brugerinput."""
    if not user_message or not user_message.strip():
        raise ValueError("Tom besked")

    if len(user_message) > 10_000:
        raise ValueError("Besked for lang (maks. 10.000 tegn)")

    # Fjern kontroltegn
    cleaned = "".join(c for c in user_message if c.isprintable() or c in "\n\t")
    return cleaned.strip()

def validate_output(content: str, finish_reason: str) -> dict:
    """Valider API-output."""
    warnings = []

    if finish_reason == "length":
        warnings.append("Svar potentielt trunkeret")

    if not content or len(content.strip()) < 5:
        warnings.append("Unormalt kort svar")

    if len(content) > 50_000:
        warnings.append("Unormalt langt svar")

    return {"content": content, "warnings": warnings, "valid": len(warnings) == 0}

Hold styr på kontekstvinduet

Et sidste problem: den langsomme drift i lange samtaler. Funktionen nedenfor estimerer volumen til ét token per fire tegn på fransk – en grov tilnærmelse, men tilstrækkelig som værn – og lader anmodninger passere, så længe de holder sig under 80 % af grænsen. Derudover bevarer den system-prompten og fjerner de ældste beskeder, indtil den falder tilbage under 70 %. Dette gab mellem de to tærskler er bevidst: at skære kun ned til udløsertærsklen ville skubbe funktionen tilbage i det røde felt ved næste besked.

def manage_context(messages: list, max_tokens: int = 100_000) -> list:
    """Hold beskeder inden for modellens token-grænse."""
    # Estimat: 1 token ~ 4 tegn på fransk
    total_chars = sum(len(m["content"]) for m in messages)
    estimated_tokens = total_chars // 4

    if estimated_tokens < max_tokens * 0.8:
        return messages  # Alt passer

    # Behold system + første og sidste beskeder
    system = [m for m in messages if m["role"] == "system"]
    history = [m for m in messages if m["role"] != "system"]

    # Fjern ældste beskeder
    while estimated_tokens > max_tokens * 0.7 and len(history) > 2:
        removed = history.pop(0)
        estimated_tokens -= len(removed["content"]) // 4

    return system + history

Hvad du tager med fra dette kursus

Rejsen fulgte fire trin. Først fundamentet: endpointet, roller, grundlæggende parametre og svarstruktur. Dernæst streaming, med SSE-protokollen, dens Python-implementering, stop-sekvenser og hærdning via safe_prompt og guardrails. Prompting optog den tredje fase – produktions-system-prompts, few-shot, XML- og Markdown-strukturering, anti-mønstre. Avancerede parametre lukkede sløjfen: temperatur og Top P i detaljer, presence- og frequency-penalties, N completions og denne produktionscheckliste.

Konfigurationen nedendestående destillerer disse valg til et forsvarligt udgangspunkt for en første produktionsudrulning: fast version, token-loft tilpasset use caset, lav temperatur for faktuel konsistens, top_p urørt da temperaturen justeres, neutrale penalties medmindre et specifikt behov begrunder dem, og safe_prompt aktiveret.

# Typisk konfiguration til en produktionsapplikation
PRODUCTION_CONFIG = {
    "model": "mistral-large-2512",      # Fast version
    "max_tokens": 2000,                  # Tilpasset use caset
    "temperature": 0.3,                  # Konsistent og faktuel
    "top_p": 1.0,                        # Urørt hvis temperaturen justeres
    "presence_penalty": 0.0,             # Standard medmindre specifikt behov
    "frequency_penalty": 0.0,            # Standard medmindre specifikt behov
    "safe_prompt": True,                 # Sikkerhed aktiveret
}

For at gå videre med Mistral API’et følger fire komplementære kurser på Corsen Academy:

  • Embeddings og RAG – Semantisk søgning med mistral-embed og vektordatabaser
  • Function Calling – Forbind modellen til dine værktøjer og eksterne API’er
  • Fine-tuning – Tilpas en model til dit specifikke domæne
  • Produktion og evaluering – Metrikker, automatiserede evals, omkostningsoptimering

Vigtige pointer

  • Brug versionerede modeller i produktion, aldrig -latest
  • Implementer genforsøg + backoff + logning fra første deployment
  • Valider både input OG output ved hvert API-kald
  • Spor omkostninger i realtid med en token-tracker
  • Håndter kontekstvinduet ved lange samtaler
  • Aktiver safe_prompt som et minimalt sikkerhedsnet
  • Test dine prompts med edge cases før hver produktionsudgivelse

Test din viden

Ingen hemmeligheder tilbage i chat/completions-endpointet? Lad os verificere.

1. Hvilke roller strukturerer beskedlisten?

Svar: system (rammen), user (anmodninger), assistant (modelsvar) – hele historien genstartes ved hvert kald, da API’et er stateless.

2. Hvad finder du i usage-feltet i svaret?

Svar: Tokens forbrugt ved input og output – grundlaget for fakturering og metrikken at holde øje med ved dimensionering og omkostninger.

3. Hvordan fungerer SSE-streaming?

Svar: Svaret ankommer som Server-Sent Events, fragment for fragment: du viser det, efterhånden som det kommer, og sammenkæder for at få den endelige besked.

4. Hvad bruges stop-sekvenser til?

Svar: Til at afbryde generationen, så snart en given streng vises: kontrol af længde, stop ved et skilletegn, garanti for rene formater.

5. Temperatur, Top P, penalties: hvilken brug i produktion?

Svar: Temperatur/Top P sætter determinisme per opgave; presence/frequency-penalties begrænser gentagelse – indstillinger at fastlåse per use case og dokumentere sammen med dine prompts.

Roller, usage, streaming, stops, tuning: fundamentet holder – produktions-bedste-praksis ovenfor sætter dem i orden.