Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Het codestral-embed-model

Les 5 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Gespecialiseerde embeddings voor code
  2. Technische specificaties
  3. Basisgebruik
  4. De parameter output_dimension
  5. De parameter output_dtype
  6. Dimensie en Dtype combineren
  7. Ondersteunde talen
  8. Belangrijkste punten

Gespecialiseerde embeddings voor code

Hoewel mistral-embed is ontworpen voor natuurlijke taal, is codestral-embed een embedding-model dat specifiek is geoptimaliseerd voor programmeertalen. Het begrijpt syntaxis, semantiek en logica van code, waardoor het aanzienlijk superieur is aan een generiek tekstmodel voor elke taak die broncode betreft.

U ziet het verschil al in een eenvoudig geval. Twee functies die hetzelfde doen—de ene geschreven met een for-lus en de andere met list comprehension—delen bijna geen tokens. Een tekstmodel ziet ze als twee verschillende blokken leestekens; een model dat op code is getraind, brengt ze samen omdat het heeft geleerd dat deze twee vormen dezelfde intentie uitdrukken.

Technische specificaties

Het codestral-embed-model verschilt op verschillende belangrijke punten van mistral-embed:

Functiecodestral-embedmistral-embed
Standaarddimensies15361024
Maximale dimensies3072 (het dubbele van de standaard)—
Uitvoertypenfloat, int8, uint8, binary, ubinary—
OptimalisatieGetraind op broncode in meerdere talenNatuurlijke taal

Deze flexibiliteit in dimensies en uitvoertypen is wat de twee modellen in de praktijk echt van elkaar onderscheidt. Een code-index bereikt snel een miljoen vectoren, en het kunnen verlagen van hun gewicht met een factor vier heeft directe invloed op uw infrastructuurkosten.

Basisgebruik

De API is identiek aan die van mistral-embed, behalve de modelnaam codestral-embed. Er verandert niets anders in uw aanroepcode, waardoor u beide modellen in hetzelfde project kunt draaien door slechts één parameter aan te passen.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Codefragmenten coderen
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

Merk op dat alle drie de fragmenten dezelfde logica (Fibonacci) implementeren in drie verschillende talen. Hun embeddings zullen zeer dicht bij elkaar liggen, ondanks de syntactische verschillen. Deze eigenschap maakt zoekopdrachten tussen talen mogelijk: op een polyglot codebase kan een Python-ontwikkelaar de benodigde Java-implementatie vinden zonder ook maar één woord Java te kennen.

De parameter output_dimension

U kunt de vectorgrootte verkleinen om opslagruimte te besparen, ten koste van een licht verlies aan precisie:

# Verminderde dimensies (512 in plaats van 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 eerste dimensies van de vector zijn het meest informatief. Het model is zo ontworpen dat de eerste n dimensies de maximale hoeveelheid informatie behouden, waardoor deze reductie mogelijk is zonder catastrofale gevolgen. Met andere woorden: het afkappen van een vector is niet hetzelfde als willekeurig een derde van de betekenis weggooien: u behoudt het kernsignaal en verliest de nuance, wat perfect bruikbaar blijft voor een eerste filterstap.

Een dimensie kiezen

Gebruik de volgende waarden als richtlijn op basis van uw projectcontext. Zoeken met hoge precisie op een bescheiden corpus vereist andere instellingen dan een index die draait op een machine met beperkte resources:

# Aanbevelingen per use case
DIMENSIONS = {
    "high_precision_search": 3072,   # Maximale kwaliteit
    "general_use": 1536,             # Standaard, goed compromis
    "large_volume": 768,             # Afweging opslag/kwaliteit
    "prototype": 512,                # Snelle ontwikkeling
    "embedded": 256,                 # Strikte geheugenbeperkingen
}

De parameter output_dtype

Het uitvoertype bepaalt de precisie en de grootte van de waarden. Waar output_dimension het aantal waarden vermindert, verlaagt output_dtype het gewicht van elke afzonderlijke waarde. Deze twee hendels zijn onafhankelijk en cumulatief.

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

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

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

Dimensie en Dtype combineren

U kunt beide parameters combineren voor nauwkeurige controle. De twee onderstaande aanroepen coderen dezelfde SQL-query en illustreren de uitersten van het spectrum: de eerste is gericht op een lichtgewicht index die continu wordt bevraagd, terwijl de tweede dient voor referentiezoeekopdrachten waarbij elk punt van precisie telt.

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

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

Hier is een regel die u nu al moet vaststellen: vectoren in uw index en vectoren in uw query’s moeten exact dezelfde parameters hebben. Het coderen van een corpus in 512 dimensies en vervolgens bevragen in 1536 levert niet alleen slechte resultaten op; het produceert een fout of betekenisloze scores.

Ondersteunde talen

codestral-embed werkt met alle gangbare programmeertalen. Aan de applicatiekant bestrijkt het Python, JavaScript en TypeScript, evenals Java, C, C++, C#, Go en Rust. Voor data en presentatie behandelt het model SQL, HTML en CSS. Voor tooling en configuratie beheert het Shell/Bash, YAML en JSON—en vele andere, effectief elke taal die in de trainingsdata aanwezig is. In de praktijk kan een typische repository met een mix van Python, HTML-sjablonen, SQL-migraties en YAML-manifesten volledig worden geïndexeerd met één enkel model.

Belangrijkste punten

  • codestral-embed is geoptimaliseerd voor broncode, niet voor natuurlijke taal
  • Standaard 1536 dimensies, schaalbaar tot 3072
  • De parameter output_dimension stelt u in staat de vectorgrootte te verkleinen
  • De parameter output_dtype bepaalt de precisie (float, int8, binary, enz.)
  • Het model begrijpt codesemantiek ongeacht de taal