Semantisk kodesøgning
På denne side
Søg i kode efter betydning
Traditionel kodesøgning baserer sig på nøgleord: du indtaster et funktionsnavn eller et ord fra en kommentar. Semantisk kodesøgning går videre: den finder kode ud fra dens betydning eller hensigt, selvom de præcise begreber ikke matcher.
Med codestral-embed kan du søge efter kode ved hjælp af naturligt sprog. En forespørgsel som „funktion der sorterer en liste” vil finde en quicksort-implementering, selvom ordet „sort” aldrig optræder i koden. Dette spejler hverdagen for en udvikler, der tilslutter sig et eksisterende projekt: du ved, hvad du leder efter, men har ingen anelse om, hvordan det tidligere team navngav det.
Indeksering af et kodemappe
Første skridt er at udtrække og kode hver fil eller funktion i et projekt. Funktionen nedenfor gennemgår mappetræet og filtrerer mapper fra, der ville rode indekset til. Alene node_modules kan være ti gange større end den kode, du faktisk har skrevet, og ingen af dens filer er relevante for din søgning.
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")
To implementeringsdetaljer fortjener opmærksomhed. At modificere dirs[:] direkte er ikke bare en genvej; det er den eneste måde at forhindre os.walk i at dykke ned i disse mapper på. En tildeling af variablen uden slicing ville ikke have nogen effekt. Hvad angår afkortning ved 4.000 tegn, beskytter det dig mod monstrøse filer, der ville sprænge forespørgslen, samtidig med at filens header – imports, hoveddefinitioner – bevares, da den bærer det mest signifikante signal.
Kodning og indeksering
Kodningen sker i batches på tyve filer med et fremskridtsdisplay. På et repository med flere hundrede filer kører denne løkke i flere minutter. Uden en tæller har du ingen måde at skelne langsom behandling fra en hængende kald.
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}")
Rækkefølgen af embeddings i matricen matcher præcist rækkefølgen af code_files. Denne implicitte sammenhæng er omdrejningspunktet for alt, der følger: den tillader et indeks returneret af rangeringen at pege på en specifik filsti.
Søgning på naturligt sprog
Den store fordel ved codestral-embed er, at du kan søge ved hjælp af et spørgsmål på fransk eller engelsk. Funktionen koder forespørgslen med samme model, beregner ligheder mod hele indekset og returnerer de top_k bedste resultater sammen med et forhåndsvisningsuddrag af indholdet.
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']}")
Feltet preview har øjeblikkelig praktisk nytte: det sparer dig for at åbne fem filer for at finde ud af, hvilken der faktisk matcher. I en editor-integration bliver disse to hundrede tegn til forhåndsvisningslinjen, der vises under hvert resultat.
Søgning på tværs af sprog
codestral-embed forstår logik uanset sproget. Du kan søge efter et Python-mønster og finde modstykket i 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
Denne evne er uvurderlig for applikationer opdelt mellem en Python-backend og en TypeScript-frontend, hvor den samme forretningsregel nogle gange er implementeret på begge sider. At finde begge implementeringer ud fra en enkelt forespørgsel hjælper dig med at spotte afvigelser, før en bug afslører dem i produktion.
Søgning efter funktionssignatur
Du kan også søge efter forventet form snarere end funktionelt domæne. Ved at beskrive strukturen – en asynkron funktion, en klasse, middleware, en test – styrer du søgningen mod en type kodeobjekt frem for et emne.
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})")
Prøv disse fire forespørgsler på dit eget repository, før du går videre. Du vil bemærke, at resultaterne forringes markant på meget lange filer, hvor afkortningen på 4.000 tegn har skåret den nyttige del væk. Dette er tidspunktet til at beslutte, om du skal indeksere hele filer eller, endnu bedre, funktioner opdelt én efter én.
Vigtige pointer
- codestral-embed lader dig søge efter kode ved hjælp af beskrivelser i naturligt sprog
- Indeksering indebærer at kode alle kodefiler til vektorer
- Søgning på tværs af sprog virker: et Python-mønster finder JS-modstykket
- Filtrer irrelevante mapper fra (node_modules, .git, venv) under udtrækning
- Afkort meget lange filer for at overholde modellens grænser