Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Codestral – Brugscases

Lektion 4 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. De fire søjler i brugen af Codestral
  2. Autoudfyldning i IDE i realtid
  3. Komplet kodegenerering
  4. Automatisk dokumentation
  5. Generering af unit-tests
  6. Oversigt over brugscases
  7. Vigtige pointer

De fire søjler i brugen af Codestral

At reducere Codestral til et simpelt autoudfyldningsværktøj er at overse halvdelen af dets værdi. Dets evner spænder over fire nøgleområder inden for softwareudvikling: IDE-autoudfyldning, kodegenerering, automatisk dokumentation og testproduktion. Hvert område kræver specifikke indstillinger. En klar skelnen mellem dem forhindrer de skuffende resultater, der opstår, når man bruger „den samme prompt til alt”.

Autoudfyldning i IDE i realtid

Dette er modellens mest naturlige brugscase og den, der udnytter Fill-in-the-Middle (FIM) bedst. Scenariet er altid det samme: Du skriver i VS Code eller et JetBrains-IDE, en udvidelse som Continue.dev eller Tabnine registrerer en pause i din skrivning, sender en FIM-anmodning indeholdende filkonteksten, modtager et forslag på under 500 ms, og du accepterer det med Tab eller afviser det med Esc. Hele udfordringen ligger i det budget på 500 ms: Hvis det overskrides, ankommer forslaget, efter du allerede har skrevet linjen manuelt, hvilket gør hjælpen til en gene.

Den primære løftestang er størrelsen på den kontekst, der sendes. Jo mere du giver, desto bedre er relevansen, men desto langsommere er svaret.

# Optimized configuration for autocomplete
response = client.fim.complete(
    model="codestral-latest",
    prompt=context_before_cursor[-2000:],   # Limit context
    suffix=context_after_cursor[:500],      # Short suffix
    temperature=0,
    max_tokens=80,                            # Short completions
    stop=["\n\n", "\ndef ", "\nclass "],
)

I praksis giver 2.000 tegn til prompten og 500 til suffikset et fremragende forhold mellem kvalitet og hastighed. Bemærk asymmetrien: Vi beholder de sidste tegn før markøren og de første efter, fordi relevansen falder, jo længere væk fra indsættelsespunktet man kommer.

Komplet kodegenerering

Når du har brug for en hel funktion, klasse eller modul, bliver chat-endpointet mere velegnet. Kvaliteten af resultatet afhænger derefter direkte af præcisionen i din anmodning: En eksplicit specifikation med listede tekniske begrænsninger producerer brugbar kode; en vag anmodning producerer et skelet, som du skal omskrive fuldstændigt.

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "system",
            "content": "Python expert. Clean, typed code with error handling."
        },
        {
            "role": "user",
            "content": """Create a Python `CacheManager` class with:
            - An in-memory LRU cache with configurable TTL
            - get, set, delete, and clear methods
            - A @cached decorator for functions
            - Thread safety using threading.Lock"""
        }
    ],
    temperature=0.2,
    max_tokens=1500,
)

Denne workflow skinner i fire scenarier: Start af en ny fil eller et tomt modul, implementering af en kompleks algoritme beskrevet i naturligt sprog, hurtig prototyping af et API eller en service for at teste dens form, og konvertering af pseudokode til funktionel kode. Den fælles nævner er fraværet af eksisterende kode, der skal respekteres. Så snart eksisterende kode er involveret, bliver FIM igen at foretrække.

Automatisk dokumentation

Dokumentation er den opgave, teams udskyder til i morgen, men Codestral håndterer den på få sekunder. Tag en udokumenteret funktion med fire parametre og betinget adfærd i headere:

code = """
def parse_csv_to_dict(filepath, delimiter=',', encoding='utf-8', skip_header=False):
    results = []
    with open(filepath, 'r', encoding=encoding) as f:
        reader = csv.reader(f, delimiter=delimiter)
        if skip_header:
            headers = next(reader)
        else:
            headers = [f'col_{i}' for i in range(len(next(reader)))]
        for row in reader:
            results.append(dict(zip(headers, row)))
    return results
"""

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "user",
            "content": f"Add a complete Google-style docstring to this function:\n\n{code}"
        }
    ],
    temperature=0,
)

Den genererede docstring beskriver hver parameter, dens standardværdi og den returnerede struktur. Den samme mekanisme, med en anden instruktion, tilføjer kommentarer til linjer, der fortjener dem – her else-grenen, der fabrikker kunstige kolonnenavne, hvilket kan overraske den næste læser.

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "user",
            "content": f"Add explanatory comments to the complex lines in this code:\n\n{code}"
        }
    ],
    temperature=0,
)

Behold temperature=0 for begge opgaver: Du dokumenterer det, der eksisterer, ikke opfinder noget nyt.

Generering af unit-tests

Codestral genererer tests ud fra kildekode, og det er ofte her, den sparer mest tid, fordi edge cases netop er det, en travl udvikler glemmer.

function_to_test = """
def validate_email(email: str) -> bool:
    import re
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))
"""

response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {
            "role": "system",
            "content": "Generate comprehensive pytest tests. Include edge cases and error cases."
        },
        {
            "role": "user",
            "content": f"Generate tests for this function:\n\n{function_to_test}"
        }
    ],
    temperature=0.1,
    max_tokens=1000,
)

Den resulterende dækning falder i fire familier. Nominelle tilfælde verificerer gyldige adresser. Edge cases presser formatet til dets grænser med lange domæner eller tilladte specialtegn. Fejltilfælde dækker ugyldige formater, tomme strenge og None. Endelig gennemgår regressionstilfælde det, der er gået i stykker andre steder: subdomæner og nyere TLD’er. Gennemgå altid disse tests, før du committer dem – en test genereret fra buggy kode dokumenterer trofast fejlen.

Oversigt over brugscases

BrugscaseEndpointTemperaturMaks. Tokens
IDE-autoudfyldningFIM050-100
FunktionsgenereringChat0,2500-1500
Docstrings / KommentarerChat0300-500
Unit-testsChat0,1800-1500
RefaktoreringChat01000-2000
SprogkonverteringChat01000-2000

Vigtige pointer

  • IDE-autoudfyldning bruger FIM med parametre optimeret til lav latency
  • Komplet kodegenerering bruger chat-endpointet med en struktureret prompt
  • Codestral genererer docstrings og kommentarer i professionel kvalitet
  • Testgenerering dækker automatisk edge cases og fejlscenarier
  • Hvert brugscase har optimale indstillinger for temperatur og tokens