Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Codestral API i Python

Lektion 3 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. Kald Codestral fra Python
  2. Installation og konfiguration
  3. Komplet FIM-kald
  4. Chat-kald til kodegenerering
  5. Avancerede parametre
  6. To mønstre til kopiering
  7. Fejlhåndtering
  8. Vigtige pointer

Kald Codestral fra Python

Denne lektion går fra teori til eksekverbar kode. Du vil bruge Mistral AI Python SDK’et til at spørge Codestral på dens to endpoints, finjustere de avancerede parametre, der adskiller et brugbart forslag fra et verbost ét, og implementere de mønstre, der findes i de fleste integrationer i den virkelige verden.

Installation og konfiguration

Installér SDK’et med en enkelt kommando:

pip install mistralai

Hent din API-nøgle fra console.mistral.ai og læs den fra miljøvariablen i stedet for at hardcode den direkte i din fil:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

To platforme betjener Codestral, og du vælger mellem dem, når du opretter din nøgle. api.mistral.ai kører på en pay-per-use-basis med forbrugsafregning: dette er standardvejen, når Codestral er én komponent blandt mange i en applikation. codestral.mistral.ai er et dedikeret endpoint, tilgængeligt gratis eller via abonnement, designet til direkte brug af en udvikler i deres editor.

Komplet FIM-kald

Her er et detaljeret FIM-kald med alle de vigtige parametre:

from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.fim.complete(
    model="codestral-latest",
    prompt="def calculate_vat(price_excl: float, rate: float = 0.20) -> float:",
    suffix="price = float(input('Price excl. VAT: '))\nprint(f'Price incl. VAT: {calculate_vat(price):.2f} EUR')",
    temperature=0,
    max_tokens=150,
    stop=["\n\n"],
)

completion = response.choices[0].message.content
print(completion)

Gennemgang af svaret

Det returnerede objekt indeholder mere end blot den genererede tekst. I produktion bør du systematisk tjekke tre informationer: selve fuldførelsen, tokenforbruget, der bestemmer din regning, og stopårsagen, som fortæller dig, om modellen sluttede naturligt eller ramte din grænse.

# Få adgang til den genererede fuldførelse
text = response.choices[0].message.content

# Tjek antallet af brugte tokens
tokens_prompt = response.usage.prompt_tokens
tokens_completion = response.usage.completion_tokens
tokens_total = response.usage.total_tokens

# Tjek stopårsagen
reason = response.choices[0].finish_reason  # "stop", "length", osv.

En finish_reason på "length" ved halvdelen af dine kald er et klart signal: din max_tokens er for lav, og du leverer trunkeret kode til dine brugere.

Chat-kald til kodegenerering

Når der ikke er en markør midt i en fil – f.eks. ved fuld generering, forklaring eller refaktorering – overtager chat-endpointet. Systembeskeden definerer derefter outputformatet, hvilket undgår behovet for at rydde op i svaret bagefter:

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "system",
            "content": "You are an expert Python development assistant. Respond with code only, no explanations."
        },
        {
            "role": "user",
            "content": "Write a Python function that validates an email address using regex."
        }
    ],
    temperature=0.2,
    max_tokens=500,
)

code = response.choices[0].message.content
print(code)

Avancerede parametre

Parret min_tokens / max_tokens definerer outputlængden. Gulvet er nyttigt, når du genererer en blok, som du ved ikke kan være kortere end et bestemt volumen, f.eks. en funktion med dens fejlhåndtering.

# min_tokens: gennemtvinger en minimum outputlængde
# max_tokens: begrænser den maksimale længde
response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    min_tokens=20,
    max_tokens=300,
)

Stop-tokens spiller en anden rolle: de stopper genereringen ved et specifikt mønster og holder fuldførelsen inden for rammerne af den aktuelle funktion i stedet for at lade modellen kæde videre til den næste.

# Stop generering ved specifikke mønstre
response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    stop=["\n\n", "\nclass ", "\ndef "],  # Stop før en ny funktion/klasse
)

Endelig styrer temperaturen variabiliteten. Ved 0 giver det samme input altid det samme output, hvilket auto-fuldførelse kræver. Omkring 0,3 foreslår modellen varianter, hvilket er interessant, når du viser flere forslag. Ved 0,7 er du i tilstand til kode-brainstorming, nyttigt til at udforske en tilgang, men uegnet til en redigeringsflow.

# temperature=0: deterministisk (auto-fuldførelse)
# temperature=0.3: let kreativ (flere forslag)
# temperature=0.7: kreativ (kode-brainstorming)

response = client.fim.complete(
    model="codestral-latest",
    prompt=prompt,
    suffix=suffix,
    temperature=0.3,
    top_p=0.95,
)

To mønstre til kopiering

Det første efterligner IDE-adfærd: du deler filindholdet ved markørpositionen, og de to halvdele bliver til prompt og suffix.

def autocomplete_ide(file_content: str, cursor_position: int) -> str:
    """Simulerer IDE auto-fuldførelse med Codestral FIM."""
    prompt = file_content[:cursor_position]
    suffix = file_content[cursor_position:]

    response = client.fim.complete(
        model="codestral-latest",
        prompt=prompt,
        suffix=suffix,
        temperature=0,
        max_tokens=100,
        stop=["\n\n", "\ndef ", "\nclass "],
    )

    return response.choices[0].message.content

Det andet automatiserer dokumentation for et eksisterende projekt: du sender en funktion ind, henter dens docstring, og systeminstruktionen håndhæver et enkelt format, så resultatet kan indsættes uden yderligere redigering.

def generate_docstring(function_code: str) -> str:
    """Genererer en docstring for en Python-funktion."""
    response = client.chat.complete(
        model="codestral-latest",
        messages=[
            {
                "role": "system",
                "content": "Generate a Google-style docstring for the following function. Return ONLY the docstring between triple quotes."
            },
            {
                "role": "user",
                "content": function_code
            }
        ],
        temperature=0,
        max_tokens=300,
    )
    return response.choices[0].message.content

Fejlhåndtering

Et netværkskald vil før eller siden fejle, og en editor-udvidelse, der crascher ved en valideringsfejl, er værre end en udvidelse uden fuldførelse. Derfor skal du altid omslutte dine kald:

from mistralai.client import Mistral
from mistralai.client.errors import HTTPValidationError

try:
    response = client.fim.complete(
        model="codestral-latest",
        prompt=prompt,
        suffix=suffix,
    )
except HTTPValidationError as e:
    print(f"Valideringsfejl: {e}")
except Exception as e:
    print(f"Uventet fejl: {e}")

Vigtige pointer

  • mistralai SDK’et eksponerer client.fim.complete() til FIM og client.chat.complete() til chat
  • Parametrene prompt og suffix er specifikke for FIM-endpointet
  • Brug temperature=0 til auto-fuldførelse, 0,2-0,7 til kreativ generering
  • stop begrænser genereringen til en sammenhængende kodeblok
  • min_tokens og max_tokens styrer outputlængden
  • Håndtér altid HTTP-fejl i produktionskode