Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Bedste praksis og næste skridt

Lektion 14 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. Opsamling på kurset
  2. Sikring af dine API-nøgler
  3. Håndtering af fejl
  4. Leve med rate-grænser
  5. Styring af omkostninger
  6. Observation af hvad der sker
  7. Hvad nu?
  8. Vigtige pointer
  9. Test din viden

Opsamling på kurset

Du har gennemgået alle fundamentale aspekter ved brug af Mistral API: oprettelse af konto, nøglehåndtering, valg af abonnement, installation af Python- og TypeScript-SDK’er, streaming, flervejs-samtaler, migration fra V1 til V2 og implementering på store cloud-udbydere. Det følgende handler ikke længere om at lære selve API’et, men om forskellen mellem et script, der virker, og en applikation, der holder i produktion.

Sikring af dine API-nøgler

Dette er den hyppigste årsag til produktionshændelser, næsten altid af samme grund: en nøgle hardcodet „kun til test” og derefter glemt i et commit. En API-nøgle må aldrig forekomme i kildekoden; den hører hjemme i en miljøvariabel eller endnu bedre i en hemmelighedsadministrator som AWS Secrets Manager, Azure Key Vault eller HashiCorp Vault.

Næste skridt er adskillelse. Brug én nøgle pr. miljø – udvikling, staging, produktion – for at forhindre, at en mislykket test opbruger din live-tjenestes kvote. Brug én nøgle pr. applikation for at begrænse skadevirkningen: hvis en nøgle lækker, tilbagekalder du kun den for den berørte applikation. Planlæg rotation hver 90. dag i produktion, og opsæt alarmer i Mistral Console for unormal brug: en kompromitteret nøgle viser sig først som en brugskurve, der stiger uden grund.

Håndtering af fejl

I produktion kan ethvert API-kald fejle. Spørgsmålet er ikke om det sker, men hvornår. Fire statuskoder dækker det meste af, hvad du vil støde på:

KodeBetydningHandling
401 UnauthorizedUgyldig eller udløbet API-nøgleTjek din miljøvariabel
429 Too Many RequestsRate-grænse nåetGenforsøg med eksponentiel backoff
500 Internal Server ErrorProblem på Mistral-sideAutomatisk genforsøg efter få sekunder
503 Service UnavailableMidlertidig overbelastningGenforsøg med backoff

Distinktionen er vigtig: du løser aldrig en 401 ved at genforsøge; din konfiguration er skyld i fejlen. De andre tre er forbigående, og det korrekte svar er at genforsøge med progressively længere forsinkelser – ét sekund, derefter to, derefter fire. At genforsøge øjeblikkeligt i en løkke ved en 429 forværrer kun den mætning, du oplever.

Her er mønsteret i Python: maksimalt tre forsøg, propager undtagelsen, hvis det sidste fejler, og fordobl ventetiden efter hver fejl ved hjælp af 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)

TypeScript-versionen følger præcis samme logik, bortset fra at ventetiden angives i millisekunder, og pausen bygges med et promise og 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));
    }
  }
}

Leve med rate-grænser

Rate-grænser beskytter API’et mod misbrug, og genforsøgslogik alene er ikke nok til at overholde dem: den reparerer kun tingene i eftertid. Tjek dine grænser i Mistral Console – anmodninger pr. sekund, tokens pr. minut – og implementer derefter klient-side throttling for at forhindre overskridelse. Overskydende anmodninger bør køes, ikke droppes: en bruger foretrækker hellere at vente to sekunder end at få en fejl.

Når en 429 opstår trods dine bedste bestræbelser, indeholder svaret en Retry-After-header, der angiver, hvornår du skal prøve igen; at læse den er bedre end at gætte. Og hvis din legitime brug konsekvent overstiger grænserne for Scale-abonnementet, skal du anmode om en kvoteforøgelse via support i stedet for at gange workaround-løsninger op.

Styring af omkostninger

Den første løftestang, og langt den mest effektive, er modelvalg. Klassificering, feltudtræk eller omformulering kræver ikke avanceret ræsonnement: mistral-small-latest håndterer disse opgaver meget godt. Reserver mistral-large-latest til opgaver, hvor ræsonnementskvalitet gør forskellen – analyse, kompleks syntese, langt format skrivning – og brug codestral-latest til kodegenerering. Betal ikke for Mistral Large 3 til at gøre, hvad Mistral Small kan gøre lige så godt: ved produktionsvolumen måles forskellen i størrelsesordener.

Den anden løftestang angår antallet af udvekslede tokens. En koncist prompt, renset for redundante instruktioner akkumuleret over iterationer, koster mindre ved hvert kald. I flervejs-samtaler skal du kun sende de nødvendige beskeder: at afspille en historik på tredive udvekslinger for hvert spørgsmål driver regningen hurtigt i vejret. Juster max_tokens til det, du faktisk forventer, og cach gentagne svar – den billigste anmodning er den, du ikke foretager.

Observation af hvad der sker

I produktion skal du logge hvert kald. Uden dette vil du ikke vide, hvorfor et svar blev afkortet, eller hvilken brug der forklarer månedens regning. Funktionen nedenfor wrapper kaldet med to spor: hvad der sendes ud, og derefter hvad der kommer tilbage, inklusive det samlede antal tokens og stopårsagen.

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

Disse to linjer besvarer de fleste spørgsmål, du senere vil stille dig selv. En finish_reason, der signalerer en længdegrænse, forklarer et svar, der er afbrudt midt i; et driftende gennemsnitligt tokenantal afslører en prompt, der er vokset, eller en historik, der ikke er blevet ryddet korrekt.

Hvad nu?

Med fundamentet på plads åbner flere veje sig. Function calling tillader modellen at kalde dine egne funktioner og API’er. RAG (Retrieval-Augmented Generation) beriger svar med dine interne data, mens embeddings, der transformerer tekst til vektorer, udgør byggestenen for semantisk søgning. Fine-tuning tilpasser en model til dit domæne, når prompting ikke længere er nok, agenter kæder kald sammen for at bygge autonome systemer, og evaluering giver dig en måde at måle svarkvalitet på i stedet for at estimere den med øjet.

Hvert af disse emner har dedikerede kurser i Corsen Academys katalog.

Vigtige pointer

  • Sikr dine API-nøgler med en hemmelighedsadministrator og regelmæssig rotation
  • Implementer systematisk genforsøg med eksponentiel backoff
  • Vælg den letteste model, der kan håndtere din opgave
  • Log hvert API-kald til diagnosticering og omkostningsoptimering
  • Mistral API er dit fundament – næste skridt (function calling, RAG, agenter) bygger på alt, hvad du har lært

Test din viden

Console, SDK, cloud-udbydere: er API-fundamentet på plads?

1. Hvilke reflekser skal du have for API-nøglen, så snart den er oprettet?

Svar: Opbevar den sikkert (den vises kun én gang), hold den ude af koden via miljøvariabler, brug én nøgle pr. miljø, og roter den ved tvivl.

2. Hvad adskiller Experiment- og Scale-abonnementerne?

Svar: Kvoter og priser: Experiment til opdagelse og prototyping, Scale til produktion – tjek dine grænser i konsollen før dimensionering.

3. Hvad er skelettet for et første Python-kald?

Svar: Klient initialiseret med nøglen, chat-kald med model og beskedliste, læsning af svarindhold – og streaming er aktiveret til progressiv visning.

4. Hvordan håndterer du en flervejs-samtale via API'et?

Svar: Ved selv at vedligeholde historikken: hver anmodning sender den fulde liste over beskeder (bruger og assistent) – API’et er stateless.

5. Hvad skal du vide om implementeringer via Azure, Vertex eller Bedrock?

Svar: Mistral-modeller er tilgængelige der med den valgte clouds autentificering og fakturering – samme modelfamilie, andet adgangspunkt, nyttigt til infrastrukturkrav.

Nøgle sikret, historik styret, abonnement tilpasset: endelige bedste praksis transformerer dette fundament til en produktionsbase.