Codestral Embed : plonger le code
Šajā lapā
Codestral Embed : recherche sémantique dans le code
Générer et compléter du code ne suffit pas. Tu dois aussi trouver, parmi des centaines de fichiers, celui qui résout déjà ton problème. C’est le rôle du troisième outil spécialisé de Mistral AI : Codestral Embed (v25.05). Ce modèle de plongement transforme des extraits de code en vecteurs numériques, permettant une recherche sémantique à travers les dépôts.
Qu’est-ce qu’un plongement de code ?
Un plongement est une représentation vectorielle dense d’un texte ou d’un extrait de code. Sa propriété clé est simple : deux extraits sémantiquement similaires produisent des vecteurs proches dans l’espace vectoriel, même si leur syntaxe diffère totalement. Prenons les deux fonctions ci-dessous. Elles ont des noms différents, des noms de variables différents et des implémentations distinctes.
# 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)
Une recherche grep ne trouverait jamais la seconde fonction à partir de la première. Codestral Embed, en revanche, produit des vecteurs voisins pour les deux car elles résolvent le même problème.
Spécifications techniques
L’identifiant du modèle est codestral-embed-latest (v25.05). Tu l’appelles via le point de terminaison /v1/embeddings. Il gère le code source dans tous les langages pris en charge par Codestral. Sa particularité réside dans ses dimensions configurables, allant de 1536 à 3072. Le réglage à 1536 dimensions offre un excellent rapport qualité-coût et convient à la plupart des cas d’usage. Le réglage à 3072 dimensions vise une qualité maximale pour les recherches les plus exigeantes. La règle est constante : plus de dimensions signifient une meilleure précision sémantique, mais aussi des coûts de stockage plus élevés et plus de calculs pour chaque comparaison. Pour un dépôt de taille moyenne, commence à 1536 et n’augmente que si les résultats semblent flous.
Utilisation de l’API
L’appel de base ressemble à celui du point de terminaison de chat : instancie le client, passe un extrait et récupère un vecteur.
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]}")
Note que le paramètre inputs est une liste. Ce détail compte : pour indexer un dépôt entier, tu envoies plusieurs extraits dans une seule requête plutôt qu’une requête par fichier. Sur un vrai dépôt, la différence se compte en minutes gagnées.
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]
Recherche sémantique dans une base de code
Le cas d’usage principal en découle directement : au lieu de chercher par mots-clés, tu cherches par intention. Le pipeline comporte deux étapes. D’abord, indexe la base de code une fois, en attachant un plongement à chaque fichier. Ensuite, transforme la requête en vecteur et classe les fichiers par similarité cosinus, la mesure standard de proximité entre deux vecteurs.
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
)
Observe la requête finale : „function that validates an email address”. Elle ne contient aucun identifiant de projet, aucun nom de fichier et aucun mot-clé de code. C’est toute la différence par rapport à la recherche textuelle, et cela rend l’outil utilisable même par quelqu’un qui découvre le dépôt.
Cas d’usage avancés
La combinaison la plus puissante enchaîne Codestral Embed avec Codestral ou un modèle polyvalent comme Mistral Small 4. C’est le motif RAG (Retrieval-Augmented Generation) appliqué au code. Tu récupères d’abord les fichiers pertinents, tu les injectes dans le message système, puis tu poses ta question. Le modèle répond alors en se basant sur ta base de code, et non seulement sur sa connaissance générale du langage.
# 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?"}
],
)
Le même index sert une tâche moins spectaculaire mais très précieuse : la détection de code dupliqué. En comparant chaque paire de fonctions et en signalant celles dont la similarité dépasse un seuil, tu obtiens une liste de candidats à la refactorisation que personne dans l’équipe n’avait repérés.
# 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']}")
Tu dois ajuster le seuil de 0,90 sur ton propre code avant de tirer des conclusions. Si tu le fixes trop bas, il signale des fonctions qui se ressemblent mais font des choses différentes. Si tu le fixes trop haut, il ne capture que les copier-coller littéraux, ceux que tu aurais trouvés de toute façon.
Galvenās atziņas
- Codestral Embed (v25.05) transforme le code en vecteurs pour la recherche sémantique
- Il prend en charge de 1536 à 3072 dimensions selon tes besoins de précision
- La recherche sémantique permet de chercher par intention, pas par mots-clés
- Le motif RAG (récupération + génération) est le cas d’usage le plus puissant
- Les plongements permettent aussi la détection de doublons et le regroupement de code