Bedste praksis og opsummering
På denne side
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 affinish_reasonog 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.