Bästa praxis och nästa steg
På denna sida
Sammanfattning av kursen
Du har gått igenom alla grunder för att använda Mistral API: kontoskapande, nyckelhantering, val av abonnemang, installation av SDK för Python och TypeScript, strömning, flerstegskonversationer, migrering från V1 till V2 samt driftsättning på stora molnleverantörer. Det som följer handlar inte längre om att lära sig API:t i sig, utan om skillnaden mellan ett skript som fungerar och en applikation som håller i produktion.
Säkra dina API-nycklar
Detta är den vanligaste orsaken till incidenter i produktion, nästan alltid av samma anledning: en nyckel hårdkodad “bara för test” och sedan bortglömd i en commit. En API-nyckel får aldrig förekomma i källkoden; den hör hemma i en miljövariabel eller, ännu bättre, i en hemlighetshanterare som AWS Secrets Manager, Azure Key Vault eller HashiCorp Vault.
Segregering kommer härnäst. Använd en nyckel per miljö – utveckling, staging, produktion – för att förhindra att ett misslyckat test förbrukar din kvot för live-tjänsten. Använd en nyckel per applikation för att begränsa skadeverkningarna: om en nyckel läcker behöver du bara återkalla den för den drabbade applikationen. Planera för rotation var 90:e dag i produktion och konfigurera aviseringar i Mistral Console för onormal användning: en komprometterad nyckel visar sig först som en användningskurva som spikar utan anledning.
Hantera fel
I produktion kan varje API-anrop misslyckas. Frågan är inte om det kommer hända, utan när. Fyra statuskoder täcker det mesta du kommer stöta på:
| Kod | Betydelse | Åtgärd |
|---|---|---|
| 401 Unauthorized | Ogiltig eller utgången API-nyckel | Kontrollera din miljövariabel |
| 429 Too Many Requests | Hastighetsbegränsning nådd | Försök igen med exponentiell backoff |
| 500 Internal Server Error | Problem på Mistrals sida | Automatiskt försök igen efter några sekunder |
| 503 Service Unavailable | Tillfällig överbelastning | Försök igen med backoff |
Skillnaden är viktig: du löser aldrig en 401 genom att försöka igen; felet ligger i din konfiguration. De andra tre är övergående, och rätt svar är att försöka igen med successivt längre dröjsmål – en sekund, sedan två, sedan fyra. Att försöka igen omedelbart i en loop vid en 429 förvärrar bara den mättnad du upplever.
Här är mönstret i Python: maximalt tre försök, propagera undantaget om det sista misslyckas, och dubbla väntetiden efter varje misslyckande med 2 ** attempt.
import time
import os
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def call_with_retry(messages, max_retries=3):
for attempt in range(max_retries):
try:
response = client.chat.complete(
model="mistral-small-latest",
messages=messages,
)
return response
except Exception as e:
if attempt == max_retries - 1:
raise
waitTime = 2 ** attempt # 1s, 2s, 4s
print(f"Error: {e}. Retrying in {waitTime}s...")
time.sleep(waitTime)
Översättningen till TypeScript följer exakt samma logik, förutom att väntetiden uttrycks i millisekunder och pausen byggs med ett promise och setTimeout:
async function callWithRetry(
client: Mistral,
messages: Array<{ role: string; content: string }>,
maxRetries = 3
) {
for (let attempt = 0; attempt < maxRetries; attempt++) {
try {
return await client.chat.complete({
model: 'mistral-small-latest',
messages,
});
} catch (error) {
if (attempt === maxRetries - 1) throw error;
const waitTime = Math.pow(2, attempt) * 1000;
console.log(`Error. Retrying in ${waitTime}ms...`);
await new Promise((r) => setTimeout(r, waitTime));
}
}
}
Leva med hastighetsbegränsningar
Hastighetsbegränsningar skyddar API:t mot missbruk, och retry-logik ensam räcker inte för att respektera dem: den fixar bara saker i efterhand. Kontrollera dina gränser i Mistral Console – förfrågningar per sekund, tokens per minut – och implementera sedan strypning på klientsidan för att förhindra att du överskrider dem. Överskottsförfrågningar bör köas, inte släppas: en användare föredrar hellre att vänta två sekunder än att få ett fel.
När en 429 ändå inträffar trots dina bästa ansträngningar, inkluderar svaret en Retry-After-header som anger när du ska försöka igen; att läsa den är bättre än att gissa. Och om din legitima användning konsekvent överskrider gränserna för Scale-abonnemanget, begär en kvotökning via supporten istället för att multiplicera nödlösningar.
Kontrollera kostnader
Den första hävstången, och långt den mest effektiva, är val av modell. Klassificering, fältextraktion eller omformulering kräver inte avancerat resonerande: mistral-small-latest hanterar detta mycket väl. Spara mistral-large-latest för uppgifter där kvaliteten på resonerandet gör skillnad – analys, komplex syntes, långformigt skrivande – och använd codestral-latest för kodgenerering. Betala inte för Mistral Large 3 för att göra vad Mistral Small kan göra lika bra: vid produktionsvolym mäts skillnaden i storleksordningar.
Den andra hävstången gäller antalet utbytta tokens. En koncis prompt, rensad från redundanta instruktioner som ackumulerats över iterationer, kostar mindre vid varje anrop. I flerstegskonversationer, skicka endast nödvändiga meddelanden: att spela upp en historik på trettio utbyten för varje fråga driver upp fakturan mycket snabbt. Justera max_tokens till vad du faktiskt förväntar dig, och cacha återkommande svar – den billigaste förfrågan är den du inte gör.
Observera vad som händer
I produktion, logga varje anrop. Utan detta vet du inte varför ett svar trunkerades eller vilken användning som förklarar månadens faktura. Funktionen nedan slår in anropet med två spårningar: vad som går ut, sedan vad som kommer tillbaka, inklusive totalt antal tokens och stopporsaken.
import logging
logger = logging.getLogger("mistral")
def logged_call(client, messages, model="mistral-small-latest"):
logger.info(f"API Call — model: {model}, messages: {len(messages)}")
response = client.chat.complete(model=model, messages=messages)
logger.info(
f"Response — tokens: {response.usage.total_tokens}, "
f"finish: {response.choices[0].finish_reason}"
)
return response
Dessa två rader svarar på de flesta frågor du kommer ställa dig senare. En finish_reason som signalerar en längdbegränsning förklarar ett svar som klippts av mitt i; ett glidande genomsnittligt tokenantal avslöjar en prompt som växt eller en historik som inte rensats ordentligt.
Vad händer härnäst?
Med grunderna på plats öppnas flera vägar. Function calling låter modellen anropa dina egna funktioner och API:er. RAG (Retrieval-Augmented Generation) berikar svar med din interna data, medan embeddings, som omvandlar text till vektorer, utgör byggstenen för semantisk sökning. Fine-tuning anpassar en modell till din domän när prompting inte längre räcker, agenter kedjar anrop för att bygga autonoma system, och utvärdering ger dig ett sätt att mäta svarskvalitet istället för att uppskatta den på ögonmåttet.
Varje av dessa ämnen har dedikerade kurser i Corsen Academys katalog.
Viktiga punkter
- Säkra dina API-nycklar med en hemlighetshanterare och regelbunden rotation
- Implementera systematiskt försök igen med exponentiell backoff
- Välj den lättaste modellen som klarar av din uppgift
- Logga varje API-anrop för diagnostik och kostnadsoptimering
- Mistral API är din grund – nästa steg (function calling, RAG, agenter) bygger på allt du lärt dig
Testa dina kunskaper
Console, SDK, molnleverantörer: är API-grunden på plats?
1. Vilka reflexer bör du ha för API-nyckeln så snart den är skapad?
Svar: Lagra den säkert (den visas bara en gång), håll den borta från koden via miljövariabler, använd en nyckel per miljö och rotera den vid tveksamhet.
2. Vad skiljer abonnemangen Experiment och Scale åt?
Svar: Kvoter och prissättning: Experiment för upptäckt och prototyping, Scale för produktion – kontrollera dina gränser i konsolen innan du dimensionerar.
3. Vad är skelettet för ett första Python-anrop?
Svar: Klient initierad med nyckeln, chat-anrop med modell och meddelandelista, läsning av svarsinnehållet – och strömning är aktiverat för progressiv visning.
4. Hur hanterar du en flerstegskonversation via API:t?
Svar: Genom att själv underhålla historiken: varje förfrågan skickar hela listan över meddelanden (användare och assistent) – API:t är tillståndslöst.
5. Vad bör du veta om driftsättning via Azure, Vertex eller Bedrock?
Svar: Mistral-modeller finns tillgängliga där med den valda molnleverantörens autentisering och fakturering – samma modellfamilj, annan åtkomstpunkt, användbart för infrastrukturbegränsningar.
Nyckeln säkrad, historiken hanterad, abonnemanget anpassat: de sista bästa praxis-transformerar denna grund till en produktionsbas.