Codestral Embed: Code-Einbettungen
Auf dieser Seite
Codestral Embed: Semantische Suche für Code
Das Generieren und Vervollständigen von Code reicht nicht aus. Sie müssen auch die Datei in einem Repository mit Hunderten von Dateien finden, die Ihr Problem bereits löst. Dafür ist das dritte spezialisierte Werkzeug von Mistral AI zuständig: Codestral Embed (v25.05). Dieses Einbettungsmodell wandelt Code-Ausschnitte in numerische Vektoren um und ermöglicht so die semantische Suche über Repositories hinweg.
Was ist eine Code-Einbettung?
Eine Einbettung ist eine dichte Vektorrepräsentation von Text oder einem Code-Ausschnitt. Die wesentliche Eigenschaft ist einfach: Zwei semantisch ähnliche Ausschnitte erzeugen Vektoren, die im Vektorraum nah beieinander liegen, auch wenn ihre Syntax nichts miteinander zu tun hat. Betrachten Sie die beiden Funktionen unten. Sie haben unterschiedliche Namen, unterschiedliche Variablennamen und unterschiedliche Implementierungen.
# Funktion 1
def calculer_moyenne(nombres):
return sum(nombres) / len(nombres)
# Funktion 2
def average(values):
total = 0
for v in values:
total += v
return total / len(values)
Eine grep-Suche würde die zweite Funktion niemals von der ersten aus finden. Codestral Embed erzeugt jedoch für beide nahe beieinander liegende Vektoren, da sie dasselbe Problem lösen.
Technische Spezifikationen
Die Modell-ID lautet codestral-embed-latest (v25.05). Sie rufen es über den Endpunkt /v1/embeddings auf. Es verarbeitet Quellcode in allen von Codestral unterstützten Sprachen. Seine herausragende Eigenschaft sind konfigurierbare Dimensionen im Bereich von 1536 bis 3072. Die Einstellung mit 1536 Dimensionen bietet ein solides Verhältnis von Qualität zu Kosten und funktioniert für die meisten Anwendungsfälle. Die Einstellung mit 3072 Dimensionen zielt auf maximale Qualität für die anspruchsvollsten Suchen ab. Die Regel ist konstant: Mehr Dimensionen bedeuten eine bessere semantische Präzision, aber auch höhere Speicherkosten und mehr Rechenleistung für jeden Vergleich. Für ein mittelgroßes Repository beginnen Sie mit 1536 und erhöhen dies nur, wenn die Ergebnisse ungenau erscheinen.
Nutzung der API
Der grundlegende Aufruf ähnelt dem Chat-Endpunkt: Instantiieren Sie den Client, übergeben Sie einen Ausschnitt und erhalten Sie einen Vektor zurück.
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]}")
Beachten Sie, dass der Parameter inputs eine Liste ist. Dieser Detailaspekt ist wichtig: Um ein ganzes Repository zu indizieren, senden Sie mehrere Ausschnitte in einer einzigen Anfrage statt einer Anfrage pro Datei. In einem echten Repository macht sich der Unterschied in Minuten gespart bemerkbar.
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]
Semantische Suche in einem Codebase
Der primäre Anwendungsfall folgt direkt daraus: Statt nach Schlüsselwörtern suchen Sie nach Absicht (Intent). Der Pipeline besteht aus zwei Schritten. Indizieren Sie das Codebase einmalig, indem Sie jeder Datei eine Einbettung zuweisen. Transformieren Sie dann die Abfrage in einen Vektor und ranken Sie die Dateien nach kosinusähnlichkeit, dem Standardmaß für die Nähe zwischen zwei Vektoren.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# 1. Indizieren des Codebases (einmalig durchführen)
def index_codebase(files: list[dict]) -> list[dict]:
"""Indiziert eine Liste von Dateien mit ihren Einbettungen."""
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. Suche nach Absicht
def search_code(query: str, index: list[dict], top_k: int = 5) -> list[dict]:
"""Semantische Suche im indizierten Codebase."""
response = client.embeddings.create(
model="codestral-embed-latest",
inputs=[query],
)
query_vector = np.array(response.data[0].embedding)
# Berechnung der kosinusähnlichkeit
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. Nutzung
results = search_code(
"Funktion, die eine E-Mail-Adresse validiert",
index=my_index
)
Schauen Sie sich die finale Abfrage an: “Funktion, die eine E-Mail-Adresse validiert”. Sie enthält keine Projekt-Identifikatoren, keine Dateinamen und keine Code-Schlüsselwörter. Das ist der gesamte Unterschied im Vergleich zur Textsuche, und es macht das Werkzeug auch für jemanden nutzbar, der neu im Repository ist.
Erweiterte Anwendungsfälle
Die leistungsfähigste Kombination verknüpft Codestral Embed mit Codestral oder einem allgemeinen Modell wie Mistral Small 4. Dies ist das RAG-Muster (Retrieval-Augmented Generation), angewendet auf Code. Sie rufen zunächst relevante Dateien ab, injizieren diese in die Systemnachricht und stellen dann Ihre Frage. Das Modell antwortet dann basierend auf Ihrem Codebase, nicht nur auf seinem allgemeinen Sprachwissen.
# 1. Relevante Dateien mit Codestral Embed finden
results = search_code("HTTP-Fehlerbehandlung", index)
# 2. Kontext aufbauen
context = "\n\n".join([r["content"] for r in results[:3]])
# 3. Antwort mit Codestral generieren
response = client.chat.complete(
model="codestral-latest",
messages=[
{"role": "system", "content": f"Hier ist der relevante Code aus dem Projekt:\n{context}"},
{"role": "user", "content": "Wie kann ich die HTTP-Fehlerbehandlung in diesem Projekt verbessern?"}
],
)
Der gleiche Index dient einer weniger aufwendigen, aber hoch wertvollen Aufgabe: der Erkennung von Duplikaten. Indem Sie jedes Paar von Funktionen vergleichen und diejenigen mit einer Ähnlichkeit über einem Schwellenwert markieren, erhalten Sie eine Liste von Refactoring-Kandidaten, die niemand im Team bemerkt hat.
# Vergleich jedes Paares von Funktionen
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"Potenzielle Duplizierung: {func_a['name']} <-> {func_b['name']}")
Sie sollten den Schwellenwert von 0.90 an Ihrem eigenen Code anpassen, bevor Sie Schlüsse ziehen. Stellen Sie ihn zu niedrig ein, und es werden Funktionen markiert, die ähnlich aussehen, aber unterschiedliche Dinge tun. Stellen Sie ihn zu hoch ein, und es werden nur wörtliche Kopien erfasst – die Sie ohnehin gefunden hätten.
Kernaussagen
- Codestral Embed (v25.05) wandelt Code in Vektoren für die semantische Suche um
- Es unterstützt 1536 bis 3072 Dimensionen, abhängig von Ihren Präzisionsanforderungen
- Die semantische Suche ermöglicht die Suche nach Absicht, nicht nach Schlüsselwörtern
- Das RAG-Muster (Abruf + Generierung) ist der leistungsfähigste Anwendungsfall
- Einbettungen ermöglichen auch die Erkennung von Duplikaten und die Gruppierung von Code