Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Szemantikus kódkeresés

6. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Keresés kód jelentése alapján
  2. Kódkönyvtár indexelése
  3. Kódolás és indexelés
  4. Természetes nyelvű keresés
  5. Nyelveken átnyúló keresés
  6. Keresés függvényaláírás alapján
  7. Főbb megállapítások

Keresés kód jelentése alapján

A hagyományos kódkeresés kulcsszavakra támaszkodik: beírsz egy függvénynevet vagy egy szót egy megjegyzésből. A szemantikus kódkeresés ennél tovább megy: a kód jelentése vagy szándéka alapján találja meg a megfelelő részt, még akkor is, ha a pontos kifejezések nem egyeznek.

A codestral-embed segítségével természetes nyelven kereshetsz a kódban. Egy olyan lekérdezés, mint „lista rendezését végző függvény“, megtalálja a quicksort megvalósítását akkor is, ha a „sort“ szó soha nem szerepel a kódban. Ez tükrözi egy fejlesztő mindennapi valóságát, amikor egy meglévő projekthez csatlakozik: tudod, mit keresel, de fogalmad sincs, hogyan nevezte el azt az előző csapat.

Kódkönyvtár indexelése

Az első lépés a projekt minden egyes fájljának vagy függvényének kinyerése és kódolása. Az alábbi függvény végigjárja a könyvtárstruktúrát, és kiszűri azokat a mappákat, amelyek csak szemetelnék az indexet. Önmagában a node_modules tízszer akkora lehet, mint a ténylegesen írt kódod, és egyetlen fájlja sem releváns a keresésed szempontjából.

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

Két megvalósítási részletre érdemes odafigyelni. A dirs[:] helyben történő módosítása nem csupán rövidítés; ez az egyetlen módja annak, hogy megakadályozd az os.walk belépését ezekbe a könyvtárakba. Ha szeletelés nélkül újraértékelnéd a változót, annak nem lenne hatása. Ami a 4000 karakteres levágást illeti, ez megvéd a monstrum méretű fájloktól, amelyek felrobbantanák a kérést, miközben megtartja a fájl fejlécét – importálásokat, fő definíciókat –, amely a legjelentősebb jelet hordozza.

Kódolás és indexelés

A kódolás húszas csoportokban történik, haladásjelzővel. Néhány száz fájlt tartalmazó tároló esetén ez a ciklus több percig is eltarthat. Számláló nélkül nincs módod megkülönböztetni a lassú feldolgozást a beragadt hívástól.

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

A mátrixban lévő beágyazások sorrendje pontosan megegyezik a code_files sorrendjével. Ez az implicit megfelelés mindennek a kulcsa, ami ezután következik: lehetővé teszi, hogy a rangsorolás által visszaadott index egy adott fájlútvonalra mutasson.

Természetes nyelvű keresés

A codestral-embed legnagyobb előnye, hogy francia vagy angol nyelvű kérdéssel is kereshetsz. A függvény ugyanazzal a modellel kódolja a lekérdezést, kiszámítja a hasonlóságot a teljes indexszel szemben, és visszaadja a top_k legjobb találatot egy tartalom-előnézettel együtt.

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

A preview mezőnek azonnali gyakorlati haszna van: megspórolod vele, hogy öt fájlt kelljen megnyitnod, hogy kiderítsd, melyik illik valójában. Egy szerkesztőbe integrálva ez a kétszáz karakter válik az egyes találatok alatt megjelenített előnézeti sorrá.

Nyelveken átnyúló keresés

A codestral-embed a nyelvtől függetlenül érti a logikát. Kereshetsz egy Python-mintára, és megtalálhatod a JavaScript megfelelőjét:

# 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

Ez a képesség felbecsülhetetlen olyan alkalmazásoknál, amelyek Python backendre és TypeScript frontendre oszlanak, ahol ugyanazt az üzleti szabályt néha mindkét oldalon megvalósítják. Ha egyetlen lekérdezéssel megtalálod mindkét megvalósítást, még anteszt felfedezheted az eltéréseket, mielőtt egy hiba éles környezetben derülne ki.

Keresés függvényaláírás alapján

Kereshetsz várt forma alapján is, nemcsak funkcionális domain szerint. A struktúra leírása – aszinkron függvény, osztály, middleware, teszt – a keresést a kódobjektum típusa felé tereli, nem pedig egy tárgy felé.

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óbáld ki ezt a négy lekérdezést a saját tárolódon, mielőtt tovább lépnél. Azt fogod tapasztalni, hogy az eredmények jelentősen romlanak nagyon hosszú fájloknál, ahol a 4000 karakteres levágás elvágt a hasznos részt. Ilyenkor kell eldöntened, hogy egész fájlokat indexelsz-e, vagy – ami még jobb – függvényeket bontasz szét egyesével.

Főbb megállapítások

  • A codestral-embed lehetővé teszi, hogy természetes nyelvű leírások alapján keress a kódban
  • Az indexelés magában foglalja az összes kódfájl vektorokká alakítását
  • A nyelveken átnyúló keresés működik: egy Python-minta megtalálja a JS megfelelőjét
  • Szűrd ki a nem releváns könyvtárakat (node_modules, .git, venv) a kinyerés során
  • Vágd le a nagyon hosszú fájlokat, hogy a modell korlátain belül maradj