Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Vyhledávání kódu podle významu

Lekce 6 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Vyhledávání kódu podle významu
  2. Indexování adresáře s kódem
  3. Kódování a indexování
  4. Vyhledávání přirozeným jazykem
  5. Vyhledávání napříč jazyky
  6. Vyhledávání podle signatury funkce
  7. Klíčové poznatky

Vyhledávání kódu podle významu

Tradiční vyhledávání v kódu spoléhá na klíčová slova: zadáš název funkce nebo slovo z komentáře. Sémantické vyhledávání kódu jde dál: nachází kód podle jeho významu nebo záměru, i když se přesné termíny neshodují.

Díky modelu codestral-embed můžeš kód vyhledávat pomocí přirozeného jazyka. Dotaz jako „funkce, která seřadí seznam“ najde implementaci quicksort, i když se slovo „sort“ v kódu vůbec nevyskytuje. To přesně odpovídá každodenní realitě vývojáře, který nastupuje do existujícího projektu: víš, co hledáš, ale nemáš tušení, jak to předchozí tým pojmenoval.

Indexování adresáře s kódem

Prvním krokem je extrahovat a zakódovat každý soubor nebo funkci v projektu. Níže uvedená funkce projde strom adresářů a odfiltruje složky, které by index zbytečně zanášely. Samotný adresář node_modules může být desetkrát větší než kód, který jsi skutečně napsal, a žádný z jeho souborů není pro tvé vyhledávání 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 zaslouží pozornost. Úprava dirs[:] přímo na místě není jen zkrácený zápis; je to jediný způsob, jak zabránit funkci os.walk, aby do těchto adresářů vstupovala. Přepsání proměnné bez použití řezu by nemělo žádný efekt. Co se týče ořezání na 4 000 znaků, chrání tě to před obrovskými soubory, které by požadavek „zabily“, a zároveň zachovává hlavičku souboru – importy, hlavní definice –, která nese nejdůležitější signál.

Kódování a indexování

Kódování probíhá v dávkách po dvaceti souborech s indikátorem průběhu. V repozitáři s několika stovkami souborů běží tato smyčka několik minut. Bez čítače nemáš jak rozlišit pomalé zpracování od zaseknutého volání.

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

Pořadí vnoření v matici přesně odpovídá pořadí v code_files. Tato implicitní korespondence je klíčová pro vše, co následuje: umožňuje, aby index vrácený při řazení ukazoval na konkrétní cestu k souboru.

Vyhledávání přirozeným jazykem

Hlavní výhodou modelu codestral-embed je, že můžeš vyhledávat pomocí otázky ve francouzštině nebo angličtině. Funkce zakóduje dotaz stejným modelem, vypočítá podobnost vůči celému indexu a vrátí top_k nejlepších výsledků spolu s náhledem 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žitou praktickou využitelnost: ušetří ti otevírání pěti souborů, abys zjistil, který z nich skutečně odpovídá. V integraci s editorem se těchto dvě stě znaků stane řádkem náhledu zobrazeným pod každým výsledkem.

Vyhledávání napříč jazyky

codestral-embed chápe logiku bez ohledu na programovací jazyk. Můžeš hledat vzor v Pythonu a najít ekvivalent 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

Tato schopnost je neocenitelná pro aplikace rozdělené mezi backend v Pythonu a frontend v TypeScriptu, kde se stejné obchodní pravidlo někdy implementuje na obou stranách. Najít obě implementace z jediného dotazu ti pomůže odhalit rozdíly dříve, než se projeví jako chyba v produkci.

Vyhledávání podle signatury funkce

Můžeš také vyhledávat podle očekávané formy místo funkční domény. Popis struktury – asynchronní funkce, třída, middleware, test – nasměruje vyhledávání spíše k typu kódového objektu než k předmětu.

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

Vyzkoušej tyto čtyři dotazy na svém vlastním repozitáři, než půjdeš dál. Všimneš si, že výsledky se výrazně zhoršují u velmi dlouhých souborů, kde ořez na 4 000 znaků odstranil užitečnou část. To je ten pravý moment rozhodnout se, zda indexovat celé soubory, nebo, což je lepší, funkce rozdělené jednotlivě.

Klíčové poznatky

  • codestral-embed ti umožňuje vyhledávat kód pomocí popisů v přirozeném jazyce
  • Indexování zahrnuje zakódování všech kódových souborů do vektorů
  • Vyhledávání napříč jazyky funguje: vzor v Pythonu najde ekvivalent v JS
  • Při extrakci odfiltruj irelevantní adresáře (node_modules, .git, venv)
  • Ořež velmi dlouhé soubory, abys zůstal v limitech modelu