Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Best Practices en Vervolgstappen

Les 14 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Samenvatting van de Cursus
  2. Uw API-sleutels Beveiligen
  3. Foutafhandeling
  4. Omgaan met Ratielimieten
  5. Kosten Beheersen
  6. Observeren Wat Er Gebeurt
  7. Wat Volgt
  8. Belangrijkste punten
  9. Test Uw Kennis

Samenvatting van de Cursus

U heeft alle fundamenten van het gebruik van de Mistral API behandeld: accountaanmaak, sleutelbeheer, planselectie, installatie van de Python- en TypeScript-SDK’s, streaming, gesprekken met meerdere beurten, migratie van V1 naar V2, en implementatie op grote cloudproviders. Wat volgt, gaat niet langer over het leren van de API zelf, maar over het verschil tussen een script dat werkt en een applicatie die standhoudt in productie.

Uw API-sleutels Beveiligen

Dit is de meest voorkomende oorzaak van productie-incidents, bijna altijd om dezelfde reden: een sleutel die “alleen voor testen” hard gecodeerd is en vervolgens vergeten wordt in een commit. Een API-sleutel mag nooit in broncode verschijnen; deze hoort thuis in een omgevingsvariabele of, nog beter, in een secrets manager zoals AWS Secrets Manager, Azure Key Vault of HashiCorp Vault.

Scheiding komt daarna. Gebruik één sleutel per omgeving—ontwikkeling, staging, productie—om te voorkomen dat een mislukte test uw live service-quota opmaakt. Gebruik één sleutel per applicatie om de schade te beperken: als een sleutel lekt, hoeft u alleen die voor de getroffen applicatie in te trekken. Voorzie rotatie om de 90 dagen in productie en configureer waarschuwingen in de Mistral Console voor abnormaal gebruik: een gecompromitteerde sleutel manifesteert zich eerst als een gebruikscurve die zonder reden piekt.

Foutafhandeling

In productie kan elke API-aanroep mislukken. De vraag is niet óf het gebeurt, maar wanneer. Vier statuscodes dekken het meeste van wat u zult tegenkomen:

CodeBetekenisActie
401 UnauthorizedOngeldige of verlopen API-sleutelControleer uw omgevingsvariabele
429 Too Many RequestsRatiolimiet bereiktOpnieuw proberen met exponentiële backoff
500 Internal Server ErrorProbleem aan de kant van MistralAutomatisch opnieuw proberen na enkele seconden
503 Service UnavailableTijdelijke overbelastingOpnieuw proberen met backoff

Het onderscheid is belangrijk: u lost een 401 nooit op door opnieuw te proberen; uw configuratie is dan foutief. De andere drie zijn tijdelijk en de juiste reactie is opnieuw proberen met progressief langere vertragingen—één seconde, dan twee, dan vier. Direct in een lus opnieuw proberen bij een 429 verergert alleen de verzadiging die u ervaart.

Hier is het patroon in Python: maximaal drie pogingen, propageer de uitzondering als de laatste faalt, en verdubbel de wachttijd na elke mislukking met 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)

De TypeScript-vertaling volgt exact dezelfde logica, behalve dat de wachttijd in milliseconden wordt uitgedrukt en de pauze wordt gebouwd met een promise en 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));
    }
  }
}

Omgaan met Ratielimieten

Ratielimieten beschermen de API tegen misbruik, en retry-logica alleen is niet genoeg om ze te respecteren: het lost dingen pas achteraf op. Controleer uw limieten in de Mistral Console—aanvragen per seconde, tokens per minuut—en implementeer vervolgens client-side throttling om overschrijding te voorkomen. Overtollige aanvragen moeten in de wachtrij worden gezet, niet gedropt: een gebruiker wacht liever twee seconden dan dat hij een foutmelding krijgt.

Wanneer er ondanks uw beste inspanningen toch een 429 optreedt, bevat het antwoord een Retry-After-header die aangeeft wanneer u het opnieuw kunt proberen; deze lezen is beter dan gokken. En als uw legitieme gebruik consistent de limieten van het Scale-plan overschrijdt, vraag dan via support om een quotumverhoging in plaats van het vermenigvuldigen van workarounds.

Kosten Beheersen

De eerste hefboom, en veruit de meest effectieve, is modelselectie. Classificatie, veldextractie of herformulering vereisen geen uitgebreid redeneren: mistral-small-latest handelt dit zeer goed af. Reserveer mistral-large-latest voor taken waarbij de kwaliteit van het redeneren het verschil maakt—analyse, complexe synthese, langere teksten—en gebruik codestral-latest voor codegeneratie. Betaal niet voor Mistral Large 3 om te doen wat Mistral Small net zo goed kan: bij productievolume wordt het verschil gemeten in ordes van grootte.

De tweede hefboom betreft het aantal uitgewisselde tokens. Een beknopte prompt, ontdaan van redundante instructies die zich in loop der tijd hebben opgestapeld, kost bij elke aanroep minder. Stuur bij gesprekken met meerdere beurten alleen de noodzakelijke berichten: het voor elke vraag afspelen van een geschiedenis van dertig uitwisselingen drijft de rekening zeer snel op. Pas max_tokens aan aan wat u daadwerkelijk verwacht en cache terugkerende antwoorden—de goedkoopste aanvraag is de aanvraag die u niet doet.

Observeren Wat Er Gebeurt

Log in productie elke aanroep. Zonder dit weet u niet waarom een antwoord werd afgekapt of welk gebruik de rekening van de maand verklaart. De onderstaande functie wrapt de aanroep met twee traces: wat er uitgaat en vervolgens wat er binnenkomt, inclusief het totale aantal tokens en de stopreden.

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

Deze twee regels beantwoorden de meeste vragen die u zich later zult stellen. Een finish_reason die een lengtelimiet signaleert, verklaart een antwoord dat halverwege wordt afgebroken; een driftend gemiddeld tokenaantal onthult een prompt die is gegroeid of een geschiedenis die niet goed is opgeschoond.

Wat Volgt

Nu de fundamenten staan, openen zich verschillende paden. Function calling stelt het model in staat uw eigen functies en API’s aan te roepen. RAG (Retrieval-Augmented Generation) verrijkt antwoorden met uw interne data, terwijl embeddings, die tekst omzetten in vectoren, de bouwsteen vormen voor semantisch zoeken. Fine-tuning past een model aan uw domein aan wanneer prompten niet langer volstaat, agents ketenen aanroepen om autonome systemen te bouwen, en evaluatie geeft u een manier om de kwaliteit van antwoorden te meten in plaats van deze op het oog in te schatten.

Elk van deze onderwerpen heeft toegewijde cursussen in de catalogus van de Corsen Academy.

Belangrijkste punten

  • Beveilig uw API-sleutels met een secrets manager en regelmatige rotatie
  • Implementeer systematisch opnieuw proberen met exponentiële backoff
  • Kies het lichtste model dat uw taak aankan
  • Log elke API-aanroep voor diagnostiek en kostenoptimalisatie
  • De Mistral API is uw fundament—vervolgstappen (function calling, RAG, agents) bouwen voort op alles wat u heeft geleerd

Test Uw Kennis

Console, SDK, cloudproviders: staat het API-fundament?

1. Welke reflexen moet u hebben voor de API-sleutel zodra deze is aangemaakt?

Antwoord: Bewaar deze veilig (deze wordt slechts één keer getoond), houd deze uit de code via omgevingsvariabelen, gebruik één sleutel per omgeving en roteer deze bij twijfel.

2. Wat onderscheidt de Experiment- en Scale-plannen?

Antwoord: Quota’s en prijzen: Experiment voor ontdekking en prototyping, Scale voor productie—controleer uw limieten in de console voordat u schaal bepaalt.

3. Wat is het skelet van een eerste Python-aanroep?

Antwoord: Client geïnitialiseerd met de sleutel, chat-aanroep met het model en de berichtenlijst, lezen van de antwoordinhoud—en streaming is ingeschakeld voor progressieve weergave.

4. Hoe behandelt u een gesprek met meerdere beurten via de API?

Antwoord: Door de geschiedenis zelf te onderhouden: elke aanvraag verzendt de volledige lijst met berichten (gebruiker en assistent)—de API is stateless.

5. Wat moet u weten over implementaties via Azure, Vertex of Bedrock?

Antwoord: Mistral-modellen zijn daar beschikbaar met de authenticatie en facturatie van de gekozen cloud—dezelfde modelfamilie, ander toegangspunt, nuttig voor infrastructuurbeperkingen.

Sleutel beveiligd, geschiedenis beheerd, plan aangepast: definitieve best practices transformeren dit fundament tot een productiebasis.