Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Bedste praksis og opsummering

Lektion 12 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. Opsummering af kurset
  2. Valg af tilgang
  3. De ti gyldne regler
  4. Tre dyre faldgruber
  5. Hvad du skal overvåge
  6. Gå videre
  7. En komplet pipeline
  8. Vigtige pointer
  9. Test din viden

Opsummering af kurset

Du har udforsket hele spektret af strukturerede output-mekanismer, som Mistral API tilbyder. Denne sidste lektion samler trådene omkring det, der gør forskellen i det daglige arbejde: hvordan du vælger mellem de to tilgange, de ufravigelige indstillinger, de hyppigste faldgruber, og hvad du skal overvåge, når du er i produktion.

Valg af tilgang

Fire spørgsmål er nok til at beslutte sig, i denne rækkefølge. Har du et defineret output-skema? Hvis svaret er nej, så hold dig til JSON-tilstand: du befinder dig i en udforskende eller prototyping-fase, og det ville være for tidligt at låse en datamodel fast. Hvis ja, så gå videre til næste spørgsmål.

Arbejder du i Python eller TypeScript? Hvis ja, er tilpassede strukturerede outputs klar til dig med Pydantic eller Zod. Hvis ikke, er JSON-tilstand med manuel validering stadig din vej.

Er du i produktion? Hvis ja, er tilpassede strukturerede outputs obligatoriske, altid. Ellers er JSON-tilstand mere end tilstrækkelig til prototyping.

Ændres skemaet hyppigt? Et skema, der stadig er under udvikling, gør JSON-tilstand mere praktisk i første omgang, indtil kravene stabiliseres; et fast skema taler for tilpassede strukturerede outputs og den pålidelighed, de bringer.

De ti gyldne regler

De første fem vedrører, hvordan du skriver dine kald. Sæt altid temperature=0 i produktion: temperaturvariation er fjenden af pålidelighed, og udtrækning har ikke brug for kreativitet.

# Produktion: deterministisk
response = client.chat.parse(
    model="mistral-large-latest",
    messages=messages,
    response_format=MonSchema,
    temperature=0  # Reproducerbarhed
)

Tjek altid finish_reason. Dette er den eneste indikator, der advarer dig om et afkortet svar, før du forsøger at bruge det.

if response.choices[0].finish_reason != "stop":
    # Svaret er afkortet — øg max_tokens
    raise ValueError(f"Ufuldstændigt svar: {response.choices[0].finish_reason}")

I JSON-tilstand skal du altid instruere modellen i prompten. Parameteren garanterer syntaks, ikke struktur: det er op til dig at angive nøglerne og deres typer.

# JSON-tilstand — prompten SKAL beskrive strukturen
messages = [
    {
        "role": "system",
        "content": "Returner JSON med nøgler: name (string), age (number), city (string)."
    },
    {"role": "user", "content": text}
]

I tilpasset tilstand skal du dokumentere dine felter. En præcis beskrivelse er mere værd end en lang prompt, og den rejser med skemaet på begge sprog.

class Product(BaseModel):
    name: str = Field(description="Kommercielt produktnavn")
    price: float = Field(description="Pris i EUR ekskl. moms, afrundet til 2 decimaler")
const ProductSchema = z.object({
  name: z.string().describe("Kommercielt produktnavn"),
  price: z.number().describe("Pris i EUR ekskl. moms, afrundet til 2 decimaler"),
});

Adskil kontekst fra indhold. Instruktioner hører hjemme i system-beskeden, de data der skal behandles i bruger-beskeden – aldrig omvendt, ellers vil modellen forveksle instruktionen med kildeteksten.

messages = [
    {"role": "system", "content": "Du er en data-udtrækker. [Formatinstruktioner]"},
    {"role": "user", "content": "[Tekst der skal behandles — INGEN formatinstruktioner her]"}
]

De næste to regler vedrører dit sikkerhedsnet. Implementer en genforsøgsmekanisme: lav aldrig et enkelt kald uden en backup; genforsøg med feedback er det minimale mønster i produktion. Og valider ud over skemaet, da skemaet kun garanterer struktur, mens semantisk validering – grænser, konsistens, forretningslogik – forbliver dit ansvar.

De sidste tre vedrører orkestrering. Vælg den rigtige model til det rigtige use case: mistral-large-latest til komplekse opgaver og udtrækning af flere felter, mistral-small-latest til simpel klassificering og grundlæggende udtrækning, ministral-8b-latest til høj frekvens og minimal ventetid. Log hvert kald i produktion, hvor du registrerer den brugte model, varighed, finish_reason og resultat: uden logs er du blind. Endelig skal du ikke overoptimere prompten for tidligt – start simpelt, mål, iterér; for tidlig prompt-optimering er en almindelig fælde, hvorimod skemaet og valideringen er de virkelige løftestænger.

Tre dyre faldgruber

Den første er en max_tokens-værdi, der er for lav. JSON vil blive afkortet ved lange svar, og fejlen vil først vise sig på store dokumenter, ofte efter go-live.

# Farligt — JSON vil blive afkortet ved lange svar
response = client.chat.parse(
    model="mistral-large-latest",
    messages=messages,
    response_format=MonSchema,
    max_tokens=128  # For lavt til et komplekst skema
)

Sæt max_tokens baseret på den forventede størrelse af dit output: en faktura med 20 linjer kræver flere tokens end en simpel klassificering.

Den anden er en temperatur forskellig fra nul, hvilket gør dine resultater ikke-reproducerbare uden nogen gevinst ved en udtrækningsopgave.

# Farligt i produktion — ikke-reproducerbare resultater
response = client.chat.parse(
    ...,
    temperature=0.7  # Unødvendig variation til udtrækning
)

Den tredje er refleksen til at bruge en enkelt model. Brug ikke mistral-large til alt: en binær klassificering kræver ikke den mest kraftfulde model, og ministral-8b vil gøre jobbet 5 gange hurtigere til lavere omkostninger.

Hvad du skal overvåge

Fire metrikker fortæller om sundhedstilstanden i din pipeline. Succesraten måler procentdelen af kald, der returnerer et gyldigt objekt ved første forsøg; genforsøgsraten er procentdelen af kald, der krævede en ny chance. P50/P95-latens giver den mediane svartid og 95. percentilen, hvilket er mere afslørende end gennemsnittet. Omkostninger pr. udtrækning, udtrykt i forbrugte tokens pr. kald, holder regningen under kontrol.

Baseret på disse metrikker holder nogle få alarmtærskler godt: en succesrate under 95 % berettiger en gul alarm, under 85 % en rød alarm; P95-latens større end 10 s kræver undersøgelse; og en åben kredsløbsafbryder kræver en øjeblikkelig alarm.

Gå videre

Fire retninger udvider naturligt dette kursus. Function calling bruger strukturerede outputs til at fodre funktionskald i en agent. Streaming giver dig mulighed for at modtage det strukturerede output progressivt, hvilket betyder noget ved lange svar. Fine-tuning justerer en Mistral-model for at forbedre udtrækningskvaliteten på dine specifikke data. Evaluering består endelig i at opsætte et automatisk framework baseret på et gyldent datasæt og metrikker – dette er det, der vil fortælle dig, om en prompt-ændring faktisk forbedrer tingene.

En komplet pipeline

Følgende kode samler kursets bedste praksis i ét flow: et skema beskrevet felt for felt, en validator der afviser scores uden for grænserne, en model tilpasset opgaven, temperature=0, en eksplicit max_tokens, verifikation af finish_reason og logning for begge mulige udfald.

from mistralai.client import Mistral
from pydantic import BaseModel, Field, field_validator
import logging
import time

logger = logging.getLogger("pipeline")

class CustomerFeedback(BaseModel):
    sentiment: str = Field(description="positive, negative, or neutral")
    score: float = Field(description="Score between -1.0 and 1.0")
    category: str = Field(description="product, service, delivery, price, or other")
    action_required: bool = Field(description="True if action is required")
    summary: str = Field(description="One-sentence summary")

    @field_validator("score")
    @classmethod
    def score_in_range(cls, v):
        if not -1.0 <= v <= 1.0:
            raise ValueError(f"Score out of bounds: {v}")
        return v

def analyze_feedback(client: Mistral, text: str) -> CustomerFeedback:
    start = time.time()
    try:
        response = client.chat.parse(
            model="mistral-small-latest",
            messages=[
                {"role": "system", "content": "Analyze customer feedback."},
                {"role": "user", "content": text}
            ],
            response_format=CustomerFeedback,
            temperature=0,
            max_tokens=256
        )
        assert response.choices[0].finish_reason == "stop"
        result = response.choices[0].message.parsed
        logger.info(f"OK in {time.time()-start:.2f}s — {result.sentiment} ({result.score:+.1f})")
        return result
    except Exception as e:
        logger.error(f"ERROR in {time.time()-start:.2f}s — {e}")
        raise

Omkring tredive linjer, og du har en komponent, der sikkert kan plugs ind midt i et system: det er præcis det, strukturerede outputs muliggør.

Vigtige pointer

  • Brug tilpassede strukturerede outputs i produktion, JSON-tilstand til prototyping
  • temperature=0, tjek af finish_reason og genforsøg er ufravigelige
  • Vælg modellen baseret på opgavens kompleksitet og budget
  • Overvåg succesrate, latens og omkostninger
  • Start simpelt, mål, og optimer derefter

Test din viden

JSON-tilstand, skemaer, genforsøg: har du styr på struktureret output?

1. JSON-tilstand kontra tilpassede strukturerede outputs: hvad er forskellen?

Svar: JSON-tilstand garanterer syntaktisk gyldig JSON; tilpassede strukturerede outputs håndhæver derudover dit nøjagtige skema – felter, typer, struktur: den fulde kontrakt.

2. Hvad tilbyder client.chat.parse() med Pydantic?

Svar: Den fulde løkke: Pydantic-skemaet definerer strukturen, API’et begrænser genereringen, og svaret ankommer allerede valideret og typet som et Python-objekt – nul manuel parsing.

3. Og på TypeScript-siden?

Svar: Samme komfort med Zod: Zod-skemaet definerer og validerer strukturen – en enkelt kilde til sandhed for generering og typning.

4. Hvad gør du, når outputtet ikke overholder skemaet?

Svar: Valider systematisk, og planlæg en genforsøgsstrategi: anmod igen med fejlen i konteksten, eller degrader elegant – stol aldrig blindt på outputtet.

5. Hvornår er struktureret output uundværligt?

Svar: Så snart et program forbruger svaret uden menneskelig gennemgang: udtrækning, integrationer, pipelines – formatet ophører med at være en høflighed, det bliver en grænseflade.

Deklareret skema, begrænset generering, output-validering: triaden, der gør AI plugbar i rigtig software.