Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Modellen codestral-embed

Lektion 5 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. Specialiserede embeddings til kode
  2. Tekniske specifikationer
  3. Grundlæggende brug
  4. Parameteren output_dimension
  5. Parameteren output_dtype
  6. Kombination af dimension og dtype
  7. Understøttede sprog
  8. Vigtige pointer

Specialiserede embeddings til kode

Mens mistral-embed er designet til naturligt sprog, er codestral-embed en embedding-model optimeret specifikt til programmeringssprog. Den forstår kodesyntaks, semantik og logik, hvilket gør den betydeligt overlegen i forhold til en generisk tekstmodel til enhver opgave, der involverer kildekode.

Du kan se forskellen i et simpelt tilfælde. To funktioner, der gør det samme – den ene skrevet med en for-løkke og den anden ved hjælp af list comprehension – deler næsten ingen tokens. En tekstmodel ser dem som to forskellige blokke af tegnsætning; en model trænet på kode bringer dem sammen, fordi den har lært, at disse to former udtrykker den samme hensigt.

Tekniske specifikationer

Modellen codestral-embed adskiller sig fra mistral-embed på flere centrale punkter:

Funktioncodestral-embedmistral-embed
Standarddimensioner15361024
Maksimale dimensioner3072 (det dobbelte af standarden)—
Outputtyperfloat, int8, uint8, binary, ubinary—
OptimeringTrænet på kildekode på flere sprogNaturligt sprog

Det er denne fleksibilitet i dimensioner og outputtyper, der i praksis adskiller de to modeller markant. Et kodeindeks når hurtigt en million vektorer, og evnen til at reducere deres vægt med en faktor fire ændrer regningen for infrastrukturen.

Grundlæggende brug

API’en er identisk med mistral-embed, bortset fra modelnavnet codestral-embed. Intet andet ændrer sig i din kaldende kode, hvilket giver dig mulighed for at køre begge modeller i samme projekt ved blot at justere én parameter.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Encode code snippets
response = client.embeddings.create(
    model="codestral-embed",
    inputs=[
        "def fibonacci(n): return n if n <= 1 else fibonacci(n-1) + fibonacci(n-2)",
        "function fibonacci(n) { return n <= 1 ? n : fibonacci(n-1) + fibonacci(n-2); }",
        "public int fibonacci(int n) { return n <= 1 ? n : fibonacci(n-1) + fibonacci(n-2); }",
    ],
)

for i, data in enumerate(response.data):
    print(f"Snippet {i+1}: vector of {len(data.embedding)} dimensions")
# Snippet 1: vector of 1536 dimensions
# Snippet 2: vector of 1536 dimensions
# Snippet 3: vector of 1536 dimensions

Bemærk, at alle tre snippets implementerer den samme logik (Fibonacci) på tre forskellige sprog. Deres embeddings vil være meget tæt på hinanden på trods af de syntaktiske forskelle. Denne egenskab muliggør søgning på tværs af sprog: På en polyglot kodebase kan en Python-udvikler finde den Java-implementering, de har brug for, uden at kunne et ord af Java.

Parameteren output_dimension

Du kan reducere vektorstørrelsen for at spare lagerplads, dog på bekostning af et lille tab i præcision:

# Reduced dimensions (512 instead of 1536)
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=512,
    inputs=["def hello(): print('Hello, World!')"],
)

embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}")  # 512

De første dimensioner i vektoren er de mest informative. Modellen er designet, så de første n dimensioner beholder den maksimale mængde information, hvilket muliggør denne reduktion uden katastrofalt tab. Med andre ord er det ikke som tilfældigt at smide en tredjedel af betydningen væk, når du trunkerer en vektor: Du beholder kernesignalet og mister nuancen, hvilket stadig er fuldt ud levedygtigt til en indledende filtreringsrunde.

Valg af dimension

Brug følgende værdier som retningslinjer baseret på din projektkontekst. Søgning med høj præcision på et beskedent korpus kræver andre indstillinger end et indeks, der kører på en ressourcebegrænset maskine:

# Recommendations by use case
DIMENSIONS = {
    "high_precision_search": 3072,   # Maximum quality
    "general_use": 1536,             # Default, good compromise
    "large_volume": 768,             # Storage/quality trade-off
    "prototype": 512,                # Rapid development
    "embedded": 256,                 # Strict memory constraints
}

Parameteren output_dtype

Outputtypen styrer præcisionen og størrelsen af værdierne. Hvor output_dimension reducerer antallet af værdier, reducerer output_dtype vægten af hver enkelt. Disse to løftestænger er uafhængige og kumulative.

# Float (default) - maximum precision
response_float = client.embeddings.create(
    model="codestral-embed",
    output_dtype="float",
    inputs=["def add(a, b): return a + b"],
)

# Int8 - 4x more compact than float32
response_int8 = client.embeddings.create(
    model="codestral-embed",
    output_dtype="int8",
    inputs=["def add(a, b): return a + b"],
)

# Binary - extremely compact
response_binary = client.embeddings.create(
    model="codestral-embed",
    output_dtype="binary",
    inputs=["def add(a, b): return a + b"],
)

Kombination af dimension og dtype

Du kan kombinere begge parametre for præcis kontrol. De to kald nedenfor koder den samme SQL-forespørgsel og illustrerer ekstremerne i spektret: Det første målretter mod et letvægtsindeks, der forespørges kontinuerligt, mens det andet betjener en referencesøgning, hvor hvert præcisionspunkt tæller.

# Compact and fast: 512 dimensions in int8
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=512,
    output_dtype="int8",
    inputs=["SELECT * FROM users WHERE active = true"],
)

# High quality: 3072 dimensions in float
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=3072,
    output_dtype="float",
    inputs=["SELECT * FROM users WHERE active = true"],
)

Her er en regel, du skal etablere med det samme: Vektorer i dit indeks og vektorer i dine forespørgsler skal dele nøjagtig de samme parametre. At kode et korpus i 512 dimensioner og derefter forespørge i 1536 giver ikke bare dårlige resultater; det producerer en fejl eller meningsløse scorer.

Understøttede sprog

codestral-embed fungerer med alle almindelige programmeringssprog. På applikationssiden dækker den Python, JavaScript og TypeScript samt Java, C, C++, C#, Go og Rust. Til data og præsentation håndterer modellen SQL, HTML og CSS. Til værktøjer og konfiguration styrer den Shell/Bash, YAML og JSON – og mange andre, effektivt ethvert sprog, der er til stede i træningsdataene. I praksis kan et typisk repository, der blander Python, HTML-skabeloner, SQL-migrationer og YAML-manifester, indekseres fuldt ud med en enkelt model.

Vigtige pointer

  • codestral-embed er optimeret til kildekode, ikke naturligt sprog
  • 1536 dimensioner som standard, skalerbart op til 3072
  • Parameteren output_dimension lader dig reducere vektorstørrelsen
  • Parameteren output_dtype styrer præcisionen (float, int8, binary osv.)
  • Modellen forstår kodesemantik uanset sproget