Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Iskanje kode po pomenu

Lekcija 6 od 18 Posodobljeno 2. november 2026 Razvijalec
Na tej strani
  1. Iskanje kode po pomenu
  2. Indeksiranje mape s kodo
  3. Kodiranje in indeksiranje
  4. Iskanje z naravnim jezikom
  5. Iskanje med različnimi jeziki
  6. Iskanje po podpisu funkcije
  7. Ključne ugotovitve

Iskanje kode po pomenu

Tradicionalno iskanje kode temelji na ključnih besedah: vpišeš ime funkcije ali besedo iz komentarja. Semantično iskanje kode gre dlje: najde kodo po njenem pomenu ali namenu, tudi če se točne besede ne ujemajo.

Z modelom codestral-embed lahko iščeš kodo z uporabo naravnega jezika. Poizvedba, kot je „funkcija, ki razvrsti seznam”, bo našla implementacijo quicksort, tudi če se beseda „sort” v kodi nikoli ne pojavi. To odraža vsakdanjo realnost razvijalca, ki se pridruži obstoječemu projektu: veš, kaj iščeš, nimaš pa pojma, kako je to prejšnja ekipa poimenovala.

Indeksiranje mape s kodo

Prvi korak je ekstrakcija in kodiranje vsake datoteke ali funkcije v projektu. Spodnja funkcija prehodi drevo map in filtrira mape, ki bi zasmetile indeksu. Sama mapa node_modules je lahko desetkrat večja od kode, ki si jo dejansko napisal, nobena od njenih datotek pa ni relevantna za tvoje iskanje.

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")

Dve podrobnosti pri implementaciji si zaslužita pozornost. Spreminjanje dirs[:] na mestu ni le okrajšava; je edini način, da preprečiš os.walk spuščanje v te mape. Ponovna dodelitev spremenljivke brez rezanja ne bi imela učinka. Kar zadeva obrezovanje na 4000 znakov, te to ščiti pred pošastnimi datotekami, ki bi uničile zahtevo, hkrati pa ohranja glavo datoteke – uvoze, glavne definicije –, ki nosi najpomembnejši signal.

Kodiranje in indeksiranje

Kodiranje poteka v serijah po dvajset datotek s prikazom napredka. V repozitoriju z več sto datotekami se ta zanka izvaja več minut. Brez števca nimaš načina, da bi ločil počasno obdelavo od zataknjenega klica.

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}")

Vrstni red vdelav v matriki točno ustreza vrstnemu redu code_files. Ta implicitna ujemanja je osnova za vse, kar sledi: omogoča, da indeks, ki ga vrne razvrščanje, kaže na specifično pot do datoteke.

Iskanje z naravnim jezikom

Glavna prednost modela codestral-embed je, da lahko iščeš z vprašanjem v francoščini ali angleščini. Funkcija kodira poizvedbo z istim modelom, izračuna podobnosti glede na celoten indeks in vrne top_k najboljših rezultatov skupaj s predogledom vsebine.

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']}")

Polje preview ima takojšnjo praktično uporabnost: prihrani ti odpiranje petih datotek, da bi ugotovil, katera dejansko ustreza. V integraciji z urejevalnikom teh dvesto znakov postane vrstica predogleda, prikazana pod vsakim rezultatom.

Iskanje med različnimi jeziki

codestral-embed razume logiko ne glede na jezik. Iščeš lahko vzorec v Pythonu in najdeš enakovrednega v JavaScriptu:

# 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

Ta zmožnost je neprecenljiva za aplikacije, razdeljene med zaledje v Pythonu in vmesnik v TypeScriptu, kjer je isto poslovno pravilo včasih implementirano na obeh straneh. Iskanje obeh implementacij z eno samo poizvedbo ti pomaga odkriti razhajanja, preden jih napaka razkrije v proizvodnem okolju.

Iskanje po podpisu funkcije

Iščeš lahko tudi po pričakovani obliki in ne po funkcionalni domeni. Opisovanje strukture – asinhrona funkcija, razred, vmesna programska oprema (middleware), test – usmeri iskanje proti vrsti kodnega objekta in ne predmeta.

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})")

Preizkusi te štiri poizvedbe na svojem repozitoriju, preden nadaljuješ. Opazil boš, da se rezultati znatno poslabšajo pri zelo dolgih datotekah, kjer je obrezovanje na 4000 znakov odrezalo uporaben del. To je trenutek, ko se moraš odločiti, ali boš indeksiral cele datoteke ali, še bolje, funkcije, razčlenjene eno za drugo.

Ključne ugotovitve

  • codestral-embed ti omogoča iskanje kode z opisi v naravnem jeziku
  • Indeksiranje vključuje kodiranje vseh kodnih datotek v vektorje
  • Iskanje med različnimi jeziki deluje: vzorec v Pythonu najde enakovrednega v JS
  • Med ekstrakcijo filtriraj nerelevantne mape (node_modules, .git, venv)
  • Obreži zelo dolge datoteke, da ostaneš znotraj omejitev modela