Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Modellen codestral-embed

Lektion 5 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Specialiserade inbäddningar för kod
  2. Tekniska specifikationer
  3. Grundläggande användning
  4. Parametern output_dimension
  5. Parametern output_dtype
  6. Kombinera dimension och dtype
  7. Språkstöd
  8. Viktiga punkter

Specialiserade inbäddningar för kod

Medan mistral-embed är designat för naturligt språk, är codestral-embed en inbäddningsmodell optimerad specifikt för programmeringsspråk. Den förstår kodsyntax, semantik och logik, vilket gör den betydligt överlägsen en generell textmodell för alla uppgifter som involverar källkod.

Du kan se skillnaden i ett enkelt fall. Två funktioner som gör samma sak – den ena skriven med en for-loop och den andra med listkomprehension – delar nästan inga token. En textmodell ser dem som två distinkta block av interpunktion; en modell tränad på kod för dem samman eftersom den har lärt sig att dessa två former uttrycker samma avsikt.

Tekniska specifikationer

Modellen codestral-embed skiljer sig från mistral-embed på flera avgörande punkter:

Funktioncodestral-embedmistral-embed
Standarddimensioner15361024
Maximala dimensioner3072 (dubbelt så många som standard)—
Uttyperfloat, int8, uint8, binary, ubinary—
OptimeringTränad på källkod på flera språkNaturligt språk

Det är denna flexibilitet gällande dimensioner och uttyper som verkligen skiljer de två modellerna åt i praktiken. Ett kodindex når snabbt en miljon vektorer, och att kunna reducera deras storlek med en faktor fyra förändrar infrastrukturkostnaderna avsevärt.

Grundläggande användning

API:t är identiskt med mistral-embed, förutom modellnamnet codestral-embed. Inget annat ändras i din anropande kod, vilket låter dig köra båda modellerna i samma projekt genom att bara justera en parameter.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Koda kodsnuttar
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

Lägg märke till att alla tre snuttarna implementerar samma logik (Fibonacci) på tre olika språk. Deras inbäddningar kommer att ligga mycket nära varandra trots de syntaktiska skillnaderna. Denna egenskap möjliggör språköverskridande sökning: i en polyglot-kodbas kan en Python-utvecklare hitta den Java-implementering som behövs utan att kunna ett ord Java.

Parametern output_dimension

Du kan reducera vektorstorleken för att spara lagringsutrymme, till priset av en liten förlust i precision:

# Reducerade dimensioner (512 istället för 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örsta dimensionerna i vektorn är de mest informativa. Modellen är designad så att de första n dimensionerna behåller maximal mängd information, vilket möjliggör denna reduktion utan katastrofal förlust. Med andra ord är att trunkera en vektor inte detsamma som att slumpmässigt kasta bort en tredjedel av betydelsen: du behåller kärnsignalen och förlorar nyanserna, vilket fortfarande är fullt gångbart för en första filtreringsomgång.

Välja dimension

Använd följande värden som riktlinjer baserat på ditt projekts kontext. Sökning med hög precision på en måttlig datamängd kräver andra inställningar än ett index som körs på en resursbegränsad maskin:

# Rekommendationer efter användningsområde
DIMENSIONS = {
    "high_precision_search": 3072,   # Maximal kvalitet
    "general_use": 1536,             # Standard, bra kompromiss
    "large_volume": 768,             # Kompromiss mellan lagring och kvalitet
    "prototype": 512,                # Snabb utveckling
    "embedded": 256,                 # Stränga minnesbegränsningar
}

Parametern output_dtype

Uttypen styr precisionen och storleken på värdena. Där output_dimension reducerar antalet värden, reducerar output_dtype vikten för varje enskilt värde. Dessa två reglage är oberoende och kumulativa.

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

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

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

Kombinera dimension och dtype

Du kan kombinera båda parametrarna för exakt kontroll. De två anropen nedan kodar samma SQL-fråga och illustrerar extremerna i spektrumet: det första riktar sig mot ett lättviktigt index som frågas kontinuerligt, medan det andra tjänar en referenssökning där varje precisionpoäng räknas.

# Kompakt och snabbt: 512 dimensioner i int8
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=512,
    output_dtype="int8",
    inputs=["SELECT * FROM users WHERE active = true"],
)

# Hög kvalitet: 3072 dimensioner i float
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=3072,
    output_dtype="float",
    inputs=["SELECT * FROM users WHERE active = true"],
)

Här är en regel du ska etablera direkt: vektorer i ditt index och vektorer i dina frågor måste dela exakt samma parametrar. Att koda ett korpus i 512 dimensioner och sedan fråga i 1536 ger inte bara dåliga resultat; det producerar ett fel eller meningslösa poäng.

Språkstöd

codestral-embed fungerar med alla vanliga programmeringsspråk. På applikationssidan täcker den Python, JavaScript och TypeScript, samt Java, C, C++, C#, Go och Rust. För data och presentation hanterar modellen SQL, HTML och CSS. För verktyg och konfiguration hanterar den Shell/Bash, YAML och JSON – och många andra, effektivt sett alla språk som finns med i träningsdatan. I praktiken kan ett typiskt arkiv som blandar Python, HTML-mallar, SQL-migreringar och YAML-manifest indexeras fullt ut med en enda modell.

Viktiga punkter

  • codestral-embed är optimerat för källkod, inte naturligt språk
  • 1536 dimensioner som standard, skalbart upp till 3072
  • Parametern output_dimension låter dig reducera vektorstorleken
  • Parametern output_dtype styr precisionen (float, int8, binary, etc.)
  • Modellen förstår kodsemantik oavsett språk