Codestral Embed : Embeddings de Code

Codestral Embed : la recherche sémantique pour le code

Au-delà de la génération et de la complétion, Mistral AI propose un troisième outil spécialisé pour le code : Codestral Embed (v25.05). Ce modèle d’embeddings transforme des extraits de code en vecteurs numériques, permettant la recherche sémantique dans les repositories de code.

Qu’est-ce qu’un embedding de code ?

Un embedding est une représentation vectorielle dense d’un texte (ou d’un morceau de code). Deux extraits de code sémantiquement similaires auront des embeddings proches dans l’espace vectoriel, même si leur syntaxe est très différente.

Par exemple, ces deux fonctions font la même chose mais leur texte est différent :

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

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

Codestral Embed produit des vecteurs proches pour ces deux fonctions, car elles résolvent le même problème.

Caractéristiques techniques

• Modèle : codestral-embed-latest (v25.05)
• Dimensions : 1536 à 3072 (configurable)
• Optimisé pour : code source dans tous les langages supportés par Codestral
• Endpoint : /v1/embeddings

Pourquoi des dimensions variables ?

• 1536 dimensions — bon compromis qualité/coût, adapté à la plupart des cas
• 3072 dimensions — qualité maximale, pour les recherches les plus exigeantes

Plus de dimensions = meilleure précision sémantique, mais plus de stockage et de calcul.

Utilisation via l’API

Générer un embedding

from mistralai 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"Premiers valeurs : {embedding[:5]}")

Embeddings en batch

Pour indexer un repository entier, envoyez plusieurs extraits en une seule requête :

extraits_code = [
    "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=extraits_code,
)

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

Recherche sémantique dans un codebase

Le cas d’usage principal de Codestral Embed est la recherche sémantique. Au lieu de chercher par mots-clés (grep), vous cherchez par intention :

Pipeline complet

import numpy as np
from mistralai import Mistral

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

# 1. Indexer le codebase (à faire une fois)
def indexer_codebase(fichiers: list[dict]) -> list[dict]:
    """Indexe une liste de fichiers avec leurs embeddings."""
    contenus = [f["contenu"] for f in fichiers]

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

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

    return fichiers

# 2. Rechercher par intention
def rechercher_code(requete: str, index: list[dict], top_k: int = 5) -> list[dict]:
    """Recherche sémantique dans le codebase indexé."""
    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=[requete],
    )
    vecteur_requete = np.array(response.data[0].embedding)

    # Calculer la similarité cosinus
    resultats = []
    for fichier in index:
        vecteur_fichier = np.array(fichier["embedding"])
        similarite = np.dot(vecteur_requete, vecteur_fichier) / (
            np.linalg.norm(vecteur_requete) * np.linalg.norm(vecteur_fichier)
        )
        resultats.append({**fichier, "score": similarite})

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

# 3. Utilisation
resultats = rechercher_code(
    "fonction qui valide une adresse email",
    index=mon_index
)

Cas d’usage avancés

RAG pour le code (Retrieval-Augmented Generation)

Combinez Codestral Embed et Codestral/Devstral pour créer un assistant qui répond en se basant sur votre codebase :

# 1. Chercher les fichiers pertinents avec Codestral Embed
resultats = rechercher_code("gestion des erreurs HTTP", index)

# 2. Construire le contexte
contexte = "\n\n".join([r["contenu"] for r in resultats[:3]])

# 3. Générer une réponse avec Codestral
response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {"role": "system", "content": f"Voici le code pertinent du projet :\n{contexte}"},
        {"role": "user", "content": "Comment améliorer la gestion des erreurs HTTP dans ce projet ?"}
    ],
)

Détection de code dupliqué

Utilisez les embeddings pour trouver des fonctions similaires qui pourraient être refactorisées :

# Comparer chaque paire de fonctions
for i, func_a in enumerate(fonctions):
    for j, func_b in enumerate(fonctions):
        if i >= j:
            continue
        similarite = cosinus(func_a["embedding"], func_b["embedding"])
        if similarite > 0.90:
            print(f"Duplication potentielle : {func_a['nom']} <-> {func_b['nom']}")

Points clés à retenir

• Codestral Embed (v25.05) transforme du code en vecteurs pour la recherche sémantique
• Il supporte de 1536 à 3072 dimensions selon le besoin de précision
• La recherche sémantique permet de chercher par intention, pas par mots-clés
• Le pattern RAG (recherche + génération) est le cas d’usage le plus puissant
• Les embeddings permettent aussi la détection de duplication et le clustering de code