Zoeken in code op betekenis
Op deze pagina
Zoeken in code op betekenis
Traditioneel zoeken in code is gebaseerd op trefwoorden: u typt een functienaam of een woord uit een commentaar. Semantisch zoeken in code gaat verder: het vindt code op basis van de betekenis of intentie, zelfs als de exacte termen niet overeenkomen.
Met codestral-embed kunt u zoeken in code met behulp van natuurlijke taal. Een query zoals “functie die een lijst sorteert” vindt een quicksort-implementatie, zelfs als het woord “sort” nooit in de code voorkomt. Dit weerspiegelt de dagelijkse realiteit van een ontwikkelaar die bij een bestaand project komt: u weet wat u zoekt, maar u hebt geen idee hoe het vorige team het heeft genoemd.
Een codemap indexeren
De eerste stap is het extraheren en coderen van elk bestand of elke functie in een project. De onderstaande functie doorloopt de directorystructuur en filtert mappen eruit die de index zouden vervuilen. Alleen al node_modules kan tien keer zo groot zijn als de code die u daadwerkelijk hebt geschreven, en geen enkel bestand daarvan is relevant voor uw zoekopdracht.
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")
Twee implementatiedetails verdienen aandacht. Het wijzigen van dirs[:] in plaats is niet zomaar een verkorte schrijfwijze; het is de enige manier om te voorkomen dat os.walk die mappen binnengaat. De variabele opnieuw toewijzen zonder slicing zou geen effect hebben. Wat het afkappen bij 4.000 tekens betreft: dit beschermt u tegen monstrueuze bestanden die het verzoek zouden doen mislukken, terwijl de bestandskop—imports, hoofddefinities—behouden blijft, omdat deze het belangrijkste signaal bevat.
Coderen en indexeren
Het coderen gebeurt in batches van twintig bestanden, met een voortgangsindicatie. Bij een repository met enkele honderden bestanden duurt deze lus enkele minuten. Zonder teller kunt u geen onderscheid maken tussen trage verwerking en een vastgelopen aanroep.
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}")
De volgorde van de embeddings in de matrix komt exact overeen met de volgorde van code_files. Deze impliciete overeenkomst is het draaipunt voor alles wat volgt: het maakt het mogelijk dat een index die door de ranking wordt teruggegeven, verwijst naar een specifiek bestandspad.
Zoeken met natuurlijke taal
Het grote voordeel van codestral-embed is dat u kunt zoeken met een vraag in het Frans of Engels. De functie codeert de query met hetzelfde model, berekent de overeenkomsten met de volledige index en retourneert de top_k beste resultaten samen met een voorbeeld van de inhoud.
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']}")
Het veld preview heeft direct praktisch nut: het bespaart u het openen van vijf bestanden om uit te zoeken welk bestand daadwerkelijk overeenkomt. In een editor-integratie worden deze tweehonderd tekens de voorbeeldregel die onder elk resultaat wordt weergegeven.
Taaloverschrijdend zoeken
codestral-embed begrijpt logica ongeacht de taal. U kunt zoeken naar een Python-patroon en het equivalent in JavaScript vinden:
# 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
Deze mogelijkheid is onschatbaar voor applicaties die zijn opgesplitst tussen een Python-backend en een TypeScript-frontend, waarbij dezelfde bedrijfsregel soms aan beide kanten is geïmplementeerd. Het vinden van beide implementaties vanuit één query helpt u afwijkingen op te sporen voordat een bug ze in productie aan het licht brengt.
Zoeken op functiesignatuur
U kunt ook zoeken op verwachte vorm in plaats van op functioneel domein. Het beschrijven van de structuur—een asynchrone functie, een klasse, middleware, een test—stuurt de zoekopdracht naar een type codeobject in plaats van naar een onderwerp.
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})")
Probeer deze vier queries op uw eigen repository voordat u verdergaat. U zult merken dat de resultaten aanzienlijk verslechteren bij zeer lange bestanden, waarbij het afkappen op 4.000 tekens het nuttige deel heeft verwijderd. Dit is het moment om te beslissen of u hele bestanden wilt indexeren of, nog beter, functies die stuk voor stuk zijn opgesplitst.
Belangrijkste punten
- codestral-embed stelt u in staat om code te zoeken met behulp van beschrijvingen in natuurlijke taal
- Indexeren houdt in dat alle codebestanden worden omgezet in vectoren
- Taaloverschrijdend zoeken werkt: een Python-patroon vindt het JS-equivalent
- Filter irrelevante mappen (node_modules, .git, venv) tijdens het extraheren
- Kap zeer lange bestanden in om binnen de modellimieten te blijven