Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Codestral Embed: Code Embeddings

Les 11 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Codestral Embed: Zoeken op betekenis in code
  2. Wat is een code-embedding?
  3. Technische specificaties
  4. De API gebruiken
  5. Semantisch zoeken in een codebase
  6. Geavanceerde use cases
  7. Belangrijkste punten

Codestral Embed: Zoeken op betekenis in code

Het genereren en aanvullen van code volstaat niet. U moet ook het bestand kunnen vinden in een repository met honderden bestanden dat uw probleem al oplost. Dat is de taak van het derde gespecialiseerde instrument van Mistral AI: Codestral Embed (v25.05). Dit embedding-model zet codefragmenten om in numerieke vectoren, waardoor semantisch zoeken door repositories mogelijk wordt.

Wat is een code-embedding?

Een embedding is een dichte vectorrepresentatie van tekst of een codefragment. De belangrijkste eigenschap is eenvoudig: twee semantisch vergelijkbare fragmenten produceren vectoren die dicht bij elkaar liggen in de vectorruimte, zelfs als hun syntaxis totaal verschillend lijkt. Bekijk de onderstaande twee functies. Ze hebben verschillende namen, verschillende variabelenamen en verschillende implementaties.

# Function 1
def calculer_moyenne(nombres):
    return sum(nombres) / len(nombres)

# Function 2
def average(values):
    total = 0
    for v in values:
        total += v
    return total / len(values)

Een grep-zoekopdracht zou de tweede functie nooit vinden vertrekkende van de eerste. Codestral Embed produceert echter nabije vectoren voor beide omdat ze hetzelfde probleem oplossen.

Technische specificaties

De model-ID is codestral-embed-latest (v25.05). U roept deze aan via het /v1/embeddings-endpoint. Het verwerkt broncode in alle talen die door Codestral worden ondersteund. Het meest opvallende kenmerk is de configureerbare dimensionaliteit, variërend van 1536 tot 3072. De instelling met 1536 dimensies biedt een goede verhouding tussen kwaliteit en kosten en werkt voor de meeste use cases. De instelling met 3072 dimensies richt zich op maximale kwaliteit voor de meest veeleisende zoekopdrachten. De regel blijft constant: meer dimensies betekenen betere semantische precisie, maar ook hogere opslagkosten en meer rekenkracht voor elke vergelijking. Begin voor een repository van gemiddelde grootte bij 1536 en verhoog dit alleen als de resultaten vaag lijken.

De API gebruiken

De basisaanroep lijkt op die van het chat-endpoint: initialiseer de client, geef een fragment door en ontvang een vector terug.

from mistralai.client import Mistral
import os

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

code_snippet = """
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
"""

response = client.embeddings.create(
    model="codestral-embed-latest",
    inputs=[code_snippet],
)

embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}")
print(f"First values: {embedding[:5]}")

Merk op dat de parameter inputs een lijst is. Dit detail is belangrijk: om een volledige repository te indexeren, stuurt u meerdere fragmenten in één enkel verzoek in plaats van één verzoek per bestand. Bij een echte repository loopt dit verschil op tot minuten tijdwinst.

code_snippets = [
    "def tri_bulle(liste): ...",
    "def tri_rapide(liste): ...",
    "def tri_fusion(liste): ...",
    "def recherche_binaire(liste, cible): ...",
]

response = client.embeddings.create(
    model="codestral-embed-latest",
    inputs=code_snippets,
)

embeddings = [item.embedding for item in response.data]

Semantisch zoeken in een codebase

De primaire use case volgt hier direct uit: in plaats van op trefwoorden te zoeken, zoekt u op intentie. De pipeline bestaat uit twee stappen. Indexeer eerst de codebase eenmalig door aan elk bestand een embedding toe te voegen. Transformeer vervolgens de zoekvraag naar een vector en rangschik de bestanden op basis van cosinusgelijkenis, de standaardmaatstaf voor nabijheid tussen twee vectoren.

import numpy as np
from mistralai.client import Mistral

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

# 1. Index the codebase (do this once)
def index_codebase(files: list[dict]) -> list[dict]:
    """Indexes a list of files with their embeddings."""
    contents = [f["content"] for f in files]

    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=contents,
    )

    for i, file in enumerate(files):
        file["embedding"] = response.data[i].embedding

    return files

# 2. Search by intent
def search_code(query: str, index: list[dict], top_k: int = 5) -> list[dict]:
    """Semantic search in the indexed codebase."""
    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=[query],
    )
    query_vector = np.array(response.data[0].embedding)

    # Calculate cosine similarity
    results = []
    for file in index:
        file_vector = np.array(file["embedding"])
        similarity = np.dot(query_vector, file_vector) / (
            np.linalg.norm(query_vector) * np.linalg.norm(file_vector)
        )
        results.append({**file, "score": similarity})

    results.sort(key=lambda x: x["score"], reverse=True)
    return results[:top_k]

# 3. Usage
results = search_code(
    "function that validates an email address",
    index=my_index
)

Bekijk de laatste zoekvraag: “function that validates an email address”. Deze bevat geen projectidentificatoren, geen bestandsnamen en geen code-trefwoorden. Dat is het hele verschil ten opzichte van tekstzoekopdrachten, en het maakt de tool bruikbaar, zelfs voor iemand die nieuw is in de repository.

Geavanceerde use cases

De krachtigste combinatie koppelt Codestral Embed aan Codestral of een algemeen model zoals Mistral Small 4. Dit is het RAG-patroon (Retrieval-Augmented Generation) toegepast op code. U haalt eerst relevante bestanden op, injecteert deze in het systeembericht en stelt vervolgens uw vraag. Het model antwoordt dan op basis van uw codebase, niet alleen op basis van zijn algemene kennis van de taal.

# 1. Find relevant files with Codestral Embed
results = search_code("HTTP error handling", index)

# 2. Build context
context = "\n\n".join([r["content"] for r in results[:3]])

# 3. Generate a response with Codestral
response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {"role": "system", "content": f"Here is the relevant code from the project:\n{context}"},
        {"role": "user", "content": "How can I improve HTTP error handling in this project?"}
    ],
)

Dezelfde index dient een minder opvallende, maar zeer waardevolle taak: detectie van dubbele code. Door elk paar functies te vergelijken en die met een gelijkenis boven een bepaalde drempelwaarde te markeren, krijgt u een lijst met kandidaten voor refactoring die niemand in het team had opgemerkt.

# Compare every pair of functions
for i, func_a in enumerate(functions):
    for j, func_b in enumerate(functions):
        if i >= j:
            continue
        similarity = cosine(func_a["embedding"], func_b["embedding"])
        if similarity > 0.90:
            print(f"Potential duplication: {func_a['name']} <-> {func_b['name']}")

U moet de drempelwaarde van 0,90 afstemmen op uw eigen code voordat u conclusies trekt. Stel deze te laag in en het markeert functies die op elkaar lijken maar verschillende dingen doen. Stel deze te hoog in en het vangt alleen letterlijke kopieën—die had u toch al gevonden.

Belangrijkste punten

  • Codestral Embed (v25.05) zet code om in vectoren voor semantisch zoeken
  • Het ondersteunt 1536 tot 3072 dimensies, afhankelijk van uw precisiebehoeften
  • Semantisch zoeken stelt u in staat om op intentie te zoeken, niet op trefwoorden
  • Het RAG-patroon (ophalen + genereren) is de krachtigste use case
  • Embeddings maken ook detectie van duplicaten en clustering van code mogelijk