Recherche Sémantique de Code

Chercher du code par signification

La recherche classique de code repose sur des mots-clés : vous tapez le nom d’une fonction ou un mot dans un commentaire. La recherche sémantique de code va plus loin : elle trouve du code par sa signification ou son intention, même si les termes exacts ne correspondent pas.

Avec codestral-embed, vous pouvez rechercher du code en langage naturel : “fonction qui trie une liste” trouvera un quicksort même si le mot “trier” n’apparaît nulle part dans le code.

Indexer un répertoire de code

La première étape est d’extraire et d’encoder tous les fichiers ou fonctions d’un projet :

import os
import numpy as np
from mistralai import Mistral

client = Mistral(api_key=api_key)

def extract_code_files(directory, extensions=(".py", ".js", ".ts")):
    """Extraire tous les fichiers de code d'un répertoire."""
    code_files = []
    for root, dirs, files in os.walk(directory):
        # Ignorer les dossiers non pertinents
        dirs[:] = [d for d in dirs if d not in ("node_modules", ".git", "__pycache__", "venv")]
        for f in files:
            if any(f.endswith(ext) for ext in extensions):
                filepath = os.path.join(root, f)
                with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
                    content = fh.read()
                if content.strip():
                    code_files.append({
                        "path": filepath,
                        "content": content[:4000],  # Tronquer si trop long
                    })
    return code_files

# Extraire les fichiers
code_files = extract_code_files("./mon-projet/")
print(f"{len(code_files)} fichiers de code trouvés")

Encoder et indexer

def index_code_files(code_files, batch_size=20):
    """Créer les embeddings pour tous les fichiers de code."""
    all_embeddings = []

    for i in range(0, len(code_files), batch_size):
        batch = code_files[i:i + batch_size]
        inputs = [f["content"] for f in batch]

        response = client.embeddings.create(
            model="codestral-embed",
            inputs=inputs,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"Encodé {min(i + batch_size, len(code_files))}/{len(code_files)}")

    return np.array(all_embeddings)

embeddings = index_code_files(code_files)
print(f"Index: {embeddings.shape}")

Recherche en langage naturel

L’avantage majeur de codestral-embed : vous pouvez chercher avec une question en français ou en anglais.

from sklearn.metrics.pairwise import cosine_similarity

def search_code(query, code_files, embeddings, top_k=5):
    """Rechercher du code par description en langage naturel."""
    # Encoder la requête
    response = client.embeddings.create(
        model="codestral-embed",
        inputs=[query],
    )
    query_emb = np.array(response.data[0].embedding)

    # Calculer les similarités
    sims = cosine_similarity([query_emb], embeddings)[0]

    # Top-k résultats
    top_indices = np.argsort(sims)[::-1][:top_k]

    results = []
    for idx in top_indices:
        results.append({
            "path": code_files[idx]["path"],
            "score": float(sims[idx]),
            "preview": code_files[idx]["content"][:200],
        })
    return results

# Recherches en langage naturel
queries = [
    "fonction de validation d'email",
    "connexion à la base de données",
    "gestion des erreurs HTTP",
    "algorithme de tri",
]

for query in queries:
    print(f"\n--- Requête: '{query}' ---")
    results = search_code(query, code_files, embeddings, top_k=3)
    for r in results:
        print(f"  [{r['score']:.3f}] {r['path']}")

Recherche cross-langage

codestral-embed comprend la logique indépendamment du langage. Vous pouvez chercher un pattern Python et trouver l’équivalent en JavaScript :

# Chercher par exemple de code dans un langage...
query_python = "def authenticate(username, password): check credentials and return token"

# ...et trouver l'équivalent dans un autre langage
results = search_code(query_python, code_files, embeddings)
# Peut retourner un fichier .js avec une fonction similaire

Recherche par signature de fonction

Vous pouvez aussi chercher par la forme attendue :

queries_techniques = [
    "async function that fetches data from API and handles errors",
    "class with CRUD methods for database operations",
    "middleware that checks authentication token",
    "unit test for user registration",
]

for q in queries_techniques:
    results = search_code(q, code_files, embeddings, top_k=2)
    print(f"\n{q}:")
    for r in results:
        print(f"  -> {r['path']} (score: {r['score']:.3f})")

Points clés à retenir

• codestral-embed permet de chercher du code par description en langage naturel
• L’indexation consiste à encoder tous les fichiers de code en vecteurs
• La recherche cross-langage fonctionne : un pattern Python trouve l’équivalent JS
• Filtrez les dossiers non pertinents (node_modules, .git, venv) lors de l’extraction
• Tronquez les fichiers très longs pour rester dans les limites du modèle