Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Sémantické vyhľadávanie v kóde

Lekcia 6 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Vyhľadávanie kódu podľa významu
  2. Indexovanie adresára s kódom
  3. Zakódovanie a indexovanie
  4. Vyhľadávanie v prirodzenom jazyku
  5. Vyhľadávanie naprieč jazykmi
  6. Vyhľadávanie podľa signatúry funkcie
  7. Kľúčové poznatky

Vyhľadávanie kódu podľa významu

Tradičné vyhľadávanie v kóde sa spolieha na kľúčové slová: zadáš názov funkcie alebo slovo z komentára. Sémantické vyhľadávanie v kóde ide ďalej: nájde kód podľa jeho významu alebo zámeru, aj keď sa presné termíny nezhodujú.

Pomocou modelu codestral-embed môžeš vyhľadávať v kóde pomocou prirodzeného jazyka. Dopyt ako „funkcia, ktorá zoradí zoznam“ nájde implementáciu quicksort, aj keď sa slovo „sort“ v kóde nikdy neobjaví. Toto zrkadlí každodennú realitu vývojára, ktorý nastupuje do existujúceho projektu: vieš, čo hľadáš, ale nemáš tušenia, ako to predchádzajúci tím pomenoval.

Indexovanie adresára s kódom

Prvým krokom je extrahovanie a zakódovanie každého súboru alebo funkcie v projekte. Nižšie uvedená funkcia prechádza stromom adresárov a filtruje priečinky, ktoré by zahlteli index. Samotný node_modules môže byť desaťkrát väčší ako kód, ktorý si skutočne napísal, a žiadny z jeho súborov nie je pre tvoje vyhľadávanie relevantný.

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 implementačné detaily si zaslúžia pozornosť. Úprava dirs[:] na mieste nie je len skratka; je to jediný spôsob, ako zabrániť funkcii os.walk zostupovať do týchto adresárov. Priradenie premennej bez použitia rezov by nemalo žiadny účinok. Čo sa týka orezania na 4 000 znakov, chráni ťa to pred obludnými súbormi, ktoré by nafúkli požiadavku, pričom zachováva hlavičku súboru – importy, hlavné definície –, ktorá nesie najvýznamnejší signál.

Zakódovanie a indexovanie

Kódovanie prebieha v dávkach po dvadsať súborov so zobrazením priebehu. V repozitári s niekoľkými stovkami súborov sa táto slučka spúšťa niekoľko minút. Bez počítadla nemáš spôsob, ako rozlíšiť pomalé spracovanie od zaseknutého volania.

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

Poradie vkladania (embeddings) v matici presne zodpovedá poradiu v code_files. Táto implicitná korešpondencia je kľúčom pre všetko, čo nasleduje: umožňuje indexu vrátenému hodnotením ukázať na konkrétnu cestu k súboru.

Vyhľadávanie v prirodzenom jazyku

Hlavnou výhodou modelu codestral-embed je, že môžeš vyhľadávať pomocou otázky vo francúzštine alebo angličtine. Funkcia zakóduje dopyt rovnakým modelom, vypočíta podobnosti voči celému indexu a vráti najlepšie výsledky top_k spolu s ukážkou obsahu.

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

Pole preview má okamžitú praktickú využiteľnosť: ušetrí ti otváranie piatich súborov, aby si zistil, ktorý z nich skutočne zodpovedá zadaniu. Pri integrácii do editora sa týchto dvesto znakov stane riadkom náhľadu zobrazeným pod každým výsledkom.

Vyhľadávanie naprieč jazykmi

codestral-embed chápe logiku bez ohľadu na jazyk. Môžeš vyhľadávať vzor v Pythone a nájsť ekvivalent v JavaScripte:

# 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

Táto schopnosť je neoceniteľná pre aplikácie rozdelené medzi backend v Pythone a frontend v TypeScripte, kde sa rovnaké business pravidlo niekedy implementuje na oboch stranách. Nájdenie oboch implementácií z jedného dopytu ti pomôže odhaliť nezrovnalosti skôr, než ich v produkcii odhalí chyba.

Vyhľadávanie podľa signatúry funkcie

Môžeš tiež vyhľadávať podľa očakávanej formy namiesto funkčnej domény. Opis štruktúry – asynchrónna funkcia, trieda, middleware, test – nasmeruje vyhľadávanie skôr k typu kódového objektu než k predmetu.

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

Skús tieto štyri dopyty na vlastnom repozitári ešte predtým, než pôjdeš ďalej. Všimneš si, že výsledky sa výrazne zhoršujú pri veľmi dlhých súboroch, kde orezanie na 4 000 znakov odstrihlo užitočnú časť. Toto je moment, keď sa musíš rozhodnúť, či indexovať celé súbory, alebo, čo je lepšie, funkcie rozložené jednu po druhej.

Kľúčové poznatky

  • codestral-embed ti umožňuje vyhľadávať kód pomocou opisov v prirodzenom jazyku
  • Indexovanie zahŕňa zakódovanie všetkých kódových súborov do vektorov
  • Vyhľadávanie naprieč jazykmi funguje: vzor v Pythone nájde ekvivalent v JS
  • Počas extrakcie odfiltruj irelevantné adresáre (node_modules, .git, venv)
  • Orež veľmi dlhé súbory, aby si zostal v limitoch modelu