Bästa praxis för produktion
På denna sida
Från konceptbevis till driftsättning
Du behärskar nu varje parameter i Chat Completions API. Den svåraste delen återstår: att överbrygga gapet mellan en fungerande notebook och en tjänst som andra använder utan ditt ingripande. Denna sista lektion sammanfattar hela kursen till en handlingsbar checklista för produktion och pekar sedan ut vägen till uppföljningskurser.
Autentisering och modellversionering
Två beslut måste fattas innan den första raden affärslogik skrivs. Det första gäller API-nyckeln: den ska finnas i en miljövariabel, aldrig i koden, och en startkontroll är bättre än ett None som propagerar tre lager ner i ett obegripligt felmeddelande. Planera även för rotation – skapa den nya nyckeln, driftsätt den och återkalla sedan den gamla, i den ordningen, om du vill undvika att ta tjänsten ur drift.
import os
# ALLTID: API-nyckel i miljövariabel
api_key = os.getenv("MISTRAL_API_KEY")
assert api_key, "MISTRAL_API_KEY not defined"
# ALDRIG: hårdkodad nyckel i koden
# api_key = "sk-abc123..." # FÖRBJUDET i produktion
# ALLTID: regelbunden nyckelrotation
# Skapa en ny nyckel, driftsätt den och återkalla sedan den gamla
Det andra beslutet gäller modellidentifieraren. Under utveckling ger -latest dig förbättringar utan ansträngning. I produktion betyder samma alias att en versionsändring hos leverantören kan ändra din applikations beteende utan varning, en tisdag morgon, utan någon commit-historik som förklarar det. Lås versionen.
# UTVECKLING — senaste versionen
model = "mistral-large-latest"
# PRODUKTION — fast version för reproducerbarhet
model = "mistral-large-2512"
# Varför? En ändring av "latest" kan ändra din applikations beteende
# utan varning.
En klient som hanterar incidenter
Hjärtat i en produktionsintegration är inte API-anropet utan allt runtomkring. Klassen nedan buntar ihop tre ansvarsområden till en enda kontrollpunkt: försök igen med exponentiell backoff vid 429-fel, en kort paus vid serverfel och omedelbar eskalering av klientfel som inget försök kan åtgärda. Den normaliserar också svaret till en stabil ordbok – innehåll, finish_reason, användning, modell, ID – så att resten av din kod inte längre beror på den exakta strukturen hos objektet som returneras av SDK:t. logger.warning vid trunkeringar motiverar ensam inkapslingen: det är enda sättet att upptäcka att en max_tokens-inställning är för snäv innan användarna rapporterar det.
from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import time
import logging
logger = logging.getLogger(__name__)
class MistralClient:
"""Produktionsklient med försök, tidsgräns och loggning."""
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,
}
# Varna om svaret trunkerats
if result["finish_reason"] == "length":
logger.warning(f"Response truncated — req_id={response.id}")
return result
except SDKError as e:
if e.status_code == 429:
wait = 2 ** attempt
logger.warning(f"Rate limit, retry {attempt+1}/{self.max_retries} in {wait}s")
time.sleep(wait)
elif e.status_code >= 500:
logger.error(f"Server error {e.status_code}, retry {attempt+1}")
time.sleep(1)
else:
logger.error(f"Client error {e.status_code}: {e.message}")
raise
raise Exception(f"Failed after {self.max_retries} attempts")
Spåra kostnader i realtid
Att upptäcka din förbrukning på den månatliga fakturan är en lyx få team har råd med. Spåraren nedan skriver en JSONL-rad per anrop – tidsstämpel, modell, in- och utdatatokens, finish_reason, begärans-ID – och håller en sessionssumma du kan fråga när som helst. JSONL-formatet är inte en detalj: det aggregeras med vilket analysverktyg som helst utan ett parseringssteg, och förekomsten av begärans-ID låter dig koppla en kostnadsavvikelse till ett specifikt anrop.
import json
from datetime import datetime, timezone
class CostTracker:
"""Kostnadsspårning för API i realtid."""
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"
)
Validera i båda ändar
En robust applikation litar varken på det som kommer in eller det som kommer ut. Vid inmatning, avvisa tomma meddelanden, begränsa längden till 10 000 tecken för att förhindra att en olycklig kopiera-klistra blåser upp din faktura, och ta bort kontrolltecken som stör tokeniseringen. Vid utmatning, avvisa ingenting men raised varningar: potentiellt trunkerat svar, onormalt kort svar under fem tecken, onormalt långt svar över 50 000. Dessa tre signaler fångar majoriteten av tysta fel.
def validate_input(user_message: str) -> str:
"""Validera och rensa användarinmatning."""
if not user_message or not user_message.strip():
raise ValueError("Empty message")
if len(user_message) > 10_000:
raise ValueError("Message too long (max 10,000 characters)")
# Rensa kontrolltecken
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:
"""Validera API-utmatning."""
warnings = []
if finish_reason == "length":
warnings.append("Response potentially truncated")
if not content or len(content.strip()) < 5:
warnings.append("Abnormally short response")
if len(content) > 50_000:
warnings.append("Abnormally long response")
return {"content": content, "warnings": warnings, "valid": len(warnings) == 0}
Håll koll på kontextfönstret
En sista fråga: den långsamma glidningen i långa konversationer. Funktionen nedan uppskattar volymen till en token per fyra tecken på franska – en grov approximation men tillräcklig som skyddsräcke – och låter begäranden passera så länge de håller sig under 80 % av gränsen. Utöver det bevarar den systemprompten och tar bort de äldsta meddelandena tills den hamnar under 70 %. Detta gap mellan de två trösklarna är avsiktligt: att klippa endast till utlösningströskeln skulle pusha funktionen tillbaka in i det röda vid nästa meddelande.
def manage_context(messages: list, max_tokens: int = 100_000) -> list:
"""Håll meddelanden inom modellens tokengräns."""
# Uppskattning: 1 token ~ 4 tecken på franska
total_chars = sum(len(m["content"]) for m in messages)
estimated_tokens = total_chars // 4
if estimated_tokens < max_tokens * 0.8:
return messages # Allt får plats
# Behåll system + första och sista meddelanden
system = [m for m in messages if m["role"] == "system"]
history = [m for m in messages if m["role"] != "system"]
# Ta bort äldsta meddelanden
while estimated_tokens > max_tokens * 0.7 and len(history) > 2:
removed = history.pop(0)
estimated_tokens -= len(removed["content"]) // 4
return system + history
Vad du tar med dig från denna kurs
Resan följde fyra steg. Först, grunderna: slutpunkten, roller, grundläggande parametrar och svarsstruktur. Därefter strömning, med SSE-protokollet, dess Python-implementering, stoppsekvenser och härdning via safe_prompt och skyddsräcken. Prompting upptog den tredje fasen – produktionssystemprompter, few-shot, XML- och Markdown-strukturering, anti-mönster. Avancerade parametrar avslutade loopen: temperatur och Top P i detalj, närvaro- och frekvensstraff, N kompletteringar och denna checklista för produktion.
Konfigurationen nedan destillerar dessa val till en försvarbar startpunkt för en första produktionsdriftsättning: fast version, tak för tokens anpassat till användningsfallet, låg temperatur för faktamässig konsekvens, top_p orört eftersom temperaturen justeras, neutrala straff om inget specifikt behov motiverar dem, och safe_prompt aktiverat.
# Typisk konfiguration för en produktionsapplikation
PRODUCTION_CONFIG = {
"model": "mistral-large-2512", # Fast version
"max_tokens": 2000, # Anpassad till användningsfallet
"temperature": 0.3, # Konsekvent och faktamässig
"top_p": 1.0, # Orörd om temperaturen justeras
"presence_penalty": 0.0, # Standard om inget specifikt behov
"frequency_penalty": 0.0, # Standard om inget specifikt behov
"safe_prompt": True, # Säkerhet aktiverad
}
För att gå vidare med Mistral API följer fyra kompletterande kurser på Corsen Academy:
- Embeddings och RAG – Semantisk sökning med
mistral-embedoch vektordatabaser - Function Calling – Anslut modellen till dina verktyg och externa API:er
- Fine-tuning – Anpassa en modell till din specifika domän
- Produktion och utvärdering – Mätvärden, automatiserade utvärderingar, kostnadsoptimering
Viktiga punkter
- Använd versionerade modeller i produktion, aldrig
-latest - Implementera försök + backoff + loggning från första driftsättningen
- Validera både inmatning OCH utmatning för varje API-anrop
- Spåra kostnader i realtid med en tokenspårare
- Hantera kontextfönstret för långa konversationer
- Aktivera
safe_promptsom ett minimalt säkerhetsnät - Testa dina prompts med kantfall före varje produktionsrelease
Testa dina kunskaper
Inga fler hemligheter i chat/completions-slutpunkten? Låt oss verifiera.
1. Vilka roller strukturerar meddelandelistan?
Svar: system (ramen), user (förfrågningar), assistant (modellsvar) – hela historiken startas om vid varje anrop, eftersom API:t är tillståndslöst.
2. Vad hittar du i usage-fältet i svaret?
Svar: Tokens förbrukade vid inmatning och utmatning – grunden för fakturering och metrik att hålla ögonen på för dimensionering och kostnader.
3. Hur fungerar SSE-strömning?
Svar: Svaret anländer som Server-Sent Events, fragment för fragment: du visar det efter hand och sammanfogar för att få det slutgiltiga meddelandet.
4. Vad används stoppsekvenser till?
Svar: För att klippa genereringen så snart en given sträng dyker upp: kontrollera längd, stoppa vid en avgränsare, garantera rena format.
5. Temperatur, Top P, straff: vilken användning i produktion?
Svar: Temperatur/Top P ställer in determinism per uppgift; närvaro-/frekvensstraff begränsar upprepning – inställningar att låsa per användningsfall och dokumentera tillsammans med dina prompts.
Roller, användning, strömning, stopp, finjustering: grunderna håller – bästa praxis för produktion ovan sätter dem i ordning.