Căutare semantică de cod
Pe această pagină
Căutarea codului după semnificație
Căutarea tradițională de cod se bazează pe cuvinte-cheie: tastați un nume de funcție sau un cuvânt dintr-un comentariu. Căutarea semantică de cod merge mai departe: găsește codul după semnificația sau intenția sa, chiar dacă termenii exacți nu se potrivesc.
Cu codestral-embed, puteți căuta cod folosind limbaj natural. O interogare precum „funcție care sortează o listă“ va găsi o implementare quicksort, chiar dacă cuvântul „sort“ nu apare niciodată în cod. Acest lucru reflectă realitatea zilnică a unui dezvoltator care se alătură unui proiect existent: știți ce căutați, dar nu aveți nicio idee cum l-a denumit echipa anterioară.
Indexarea unui director de cod
Primul pas constă în extragerea și codificarea fiecărui fișier sau funcții dintr-un proiect. Funcția de mai jos parcurge arborele de directoare și filtrează folderele care ar aglomera indexul. Doar node_modules poate fi de zece ori mai mare decât codul pe care l-ați scris efectiv, iar niciunul dintre fișierele sale nu este relevant pentru căutarea dumneavoastră.
import os
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def extract_code_files(directory, extensions=(".py", ".js", ".ts")):
"""Extract all code files from a directory."""
code_files = []
for root, dirs, files in os.walk(directory):
# Ignore irrelevant directories
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], # Truncate if too long
})
return code_files
# Extract files
code_files = extract_code_files("./my-project/")
print(f"{len(code_files)} code files found")
Două detalii de implementare merită atenție. Modificarea dirs[:] direct în loc nu este doar o prescurtare; este singura modalitate de a împiedica os.walk să coboare în acele directoare. Reatribuirea variabilei fără slicing nu ar avea niciun efect. În ceea ce privește trunchierea la 4.000 de caractere, aceasta vă protejează de fișiere monstruoase care ar bloca cererea, păstrând în același timp antetul fișierului—importuri, definiții principale—care conține semnalul cel mai semnificativ.
Codificare și indexare
Codificarea are loc în loturi de douăzeci de fișiere, cu un afișaj al progresului. Pe un repository cu câteva sute de fișiere, această buclă rulează timp de câteva minute. Fără un contor, nu aveți nicio modalitate de a distinge o procesare lentă de o apelare blocată.
def index_code_files(code_files, batch_size=20):
"""Create embeddings for all code files."""
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"Encoded {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}")
Ordinea embedding-urilor din matrice corespunde exact ordinii din code_files. Această corespondență implicită este pivotul pentru tot ce urmează: permite ca un index returnat de clasament să indice o cale specifică a fișierului.
Căutare în limbaj natural
Principalul avantaj al codestral-embed este că puteți căuta folosind o întrebare în franceză sau engleză. Funcția codifică interogarea cu același model, calculează similaritățile față de întregul index și returnează cele mai bune top_k rezultate împreună cu o previzualizare a conținutului.
from sklearn.metrics.pairwise import cosine_similarity
def search_code(query, code_files, embeddings, top_k=5):
"""Search for code using natural language descriptions."""
# Encode the query
response = client.embeddings.create(
model="codestral-embed",
inputs=[query],
)
query_emb = np.array(response.data[0].embedding)
# Calculate similarities
sims = cosine_similarity([query_emb], embeddings)[0]
# Top-k results
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
# Natural language searches
queries = [
"email validation function",
"database connection",
"HTTP error handling",
"sorting algorithm",
]
for query in queries:
print(f"\n--- Query: '{query}' ---")
results = search_code(query, code_files, embeddings, top_k=3)
for r in results:
print(f" [{r['score']:.3f}] {r['path']}")
Câmpul preview are o utilitate practică imediată: vă scutește de deschiderea a cinci fișiere pentru a afla care dintre ele se potrivește cu adevărat. Într-o integrare cu editorul, aceste două sute de caractere devin linia de previzualizare afișată sub fiecare rezultat.
Căutare cross-language
codestral-embed înțelege logica indiferent de limbaj. Puteți căuta un model Python și găsi echivalentul în JavaScript:
# Search using a code example in one language...
query_python = "def authenticate(username, password): check credentials and return token"
# ...and find the equivalent in another language
results = search_code(query_python, code_files, embeddings)
# May return a .js file with a similar function
Această capacitate este inestimabilă pentru aplicațiile împărțite între un backend Python și un frontend TypeScript, unde aceeași regulă de afaceri este uneori implementată pe ambele părți. Găsirea ambelor implementări dintr-o singură interogare vă ajută să identificați divergențele înainte ca un bug să le reveleze în producție.
Căutare după semnătura funcției
Puteți, de asemenea, să căutați după forma așteptată, mai degrabă decât după domeniul funcțional. Descrierea structurii—o funcție asincronă, o clasă, middleware, un test—orientează căutarea către un tip de obiect cod, mai degrabă decât către un subiect.
technical_queries = [
"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 technical_queries:
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})")
Încercați aceste patru interogări pe propriul repository înainte de a trece mai departe. Veți observa că rezultatele se degradează semnificativ pe fișierele foarte lungi, unde trunchierea la 4.000 de caractere a eliminat partea utilă. Acesta este momentul să decideți dacă să indexați fișiere întregi sau, mai bine, funcții defalcate una câte una.
Puncte cheie
- codestral-embed vă permite să căutați cod folosind descrieri în limbaj natural
- Indexarea implică codificarea tuturor fișierelor de cod în vectori
- Căutarea cross-language funcționează: un model Python găsește echivalentul JS
- Filtrați directoarele irelevante (node_modules, .git, venv) în timpul extragerii
- Trunchiați fișierele foarte lungi pentru a rămâne în limitele modelului