Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Pretraživanje koda po značenju

Lekcija 6 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Pretraživanje koda po značenju
  2. Indeksiranje direktorija s kodom
  3. Kodiranje i indeksiranje
  4. Pretraživanje prirodnim jezikom
  5. Pretraživanje između jezika
  6. Pretraživanje po potpisu funkcije
  7. Ključne točke

Pretraživanje koda po značenju

Tradicionalno pretraživanje koda oslanja se na ključne riječi: upisuješ ime funkcije ili riječ iz komentara. Semantičko pretraživanje koda ide korak dalje: pronalazi kod prema njegovom značenju ili namjeri, čak i ako se točni izrazi ne podudaraju.

Pomoću modela codestral-embed možeš pretraživati kod koristeći prirodni jezik. Upit poput „funkcija koja sortira listu“ pronaći će implementaciju quicksort čak i ako se riječ „sort“ nikada ne pojavljuje u kodu. To odražava svakodnevnu stvarnost programera koji se pridružuje postojećem projektu: znaš što tražiš, ali nemaš pojma kako je prethodni tim to nazvao.

Indeksiranje direktorija s kodom

Prvi korak je izdvajanje i kodiranje svake datoteke ili funkcije u projektu. Donja funkcija prolazi kroz stablo direktorija i filtrira mape koje bi zakrpile indeks. Sam node_modules može biti deset puta veći od koda koji si stvarno napisao, a nijedna njegova datoteka nije relevantna za tvoje pretraživanje.

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

Dva detalja implementacije zaslužuju pozornost. Izmjena dirs[:] na mjestu nije samo skraćeni zapis; to je jedini način da se spriječi da os.walk ulazi u te direktorije. Ponovno dodjeljivanje varijable bez rezanja (slicing) ne bi imalo učinka. Što se tiče skraćivanja na 4000 znakova, to te štiti od golemih datoteka koje bi srušile zahtjev, a istovremeno zadržava zaglavlje datoteke – uvoze, glavne definicije – koje nosi najznačajniji signal.

Kodiranje i indeksiranje

Kodiranje se odvija u serijama od dvadeset datoteka, s prikazom napretka. Na repozitoriju s nekoliko stotina datoteka, ova petlja traje nekoliko minuta. Bez brojača nemaš načina razlikovati sporo procesuiranje od zaglavljenog poziva.

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

Redoslijed ugradnji u matrici točno odgovara redoslijedu u code_files. Ta implicitna povezanost je osnova za sve što slijedi: omogućuje da indeks vraćen rangiranjem pokazuje na specifičan put do datoteke.

Pretraživanje prirodnim jezikom

Glavna prednost modela codestral-embed je što možeš pretraživati koristeći pitanje na hrvatskom ili engleskom. Funkcija kodira upit istim modelom, izračunava sličnosti prema cijelom indeksu i vraća top_k najboljih rezultata zajedno s pregledom sadržaja.

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 trenutnu praktičnu korisnost: štedi ti otvaranje pet datoteka kako bi shvatio koja se stvarno podudara. U integraciji s uređivačem, tih dvjesto znakova postaje linija pregleda prikazana ispod svakog rezultata.

Pretraživanje između jezika

codestral-embed razumije logiku bez obzira na jezik. Možeš tražiti Python uzorak i pronaći ekvivalent u 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

Ova mogućnost je neprocjenjiva za aplikacije podijeljene između Python pozadinskog sustava i TypeScript prednjeg dijela, gdje je isto poslovno pravilo ponekad implementirano na obje strane. Pronalaženje obje implementacije iz jednog upita pomaže ti uočiti razlike prije nego što bug otkrije njih u produkciji.

Pretraživanje po potpisu funkcije

Također možeš pretraživati po očekivanom obliku, a ne funkcionalnoj domeni. Opisivanje strukture – asinkrone funkcije, klase, srednjeg sloja (middleware), testa – usmjerava pretraživanje prema vrsti kodnog objekta, a ne prema temi.

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

Isprobaj ova četiri upita na vlastitom repozitoriju prije nego što nastaviš dalje. Primijetit ćeš da se rezultati značajno pogoršavaju na vrlo dugim datotekama, gdje je skraćivanje od 4000 znakova odrezalo korisni dio. To je trenutak kada trebaš odlučiti hoćeš li indeksirati cijele datoteke ili, još bolje, funkcije raščlanjene jednu po jednu.

Ključne točke

  • codestral-embed ti omogućuje pretraživanje koda koristeći opise prirodnim jezikom
  • Indeksiranje uključuje kodiranje svih kodnih datoteka u vektore
  • Pretraživanje između jezika funkcionira: Python uzorak pronalazi JS ekvivalent
  • Filtriraj nebitne direktorije (node_modules, .git, venv) tijekom izdvajanja
  • Skrati vrlo duge datoteke kako bi ostao unutar ograničenja modela