Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Meklēšana kodā pēc nozīmes

Nodarbība 6 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Meklē kodu pēc nozīmes
  2. Koda direktorija indeksēšana
  3. Kodēšana un indeksēšana
  4. Meklēšana dabiskajā valodā
  5. Meklēšana starp valodām
  6. Meklēšana pēc funkcijas signatūras
  7. Galvenās atziņas

Meklē kodu pēc nozīmes

Tradicionālā koda meklēšana balstās uz atslēgvārdiem: tu ievadi funkcijas nosaukumu vai vārdu no komentāra. Semantiskā koda meklēšana iet tālāk: tā atrod kodu pēc tā nozīmes vai nodoma, pat ja precīzie termini nesakrīt.

Izmantojot codestral-embed, tu vari meklēt kodu, izmantojot dabisko valodu. Vaicājums „funkcija, kas sakārto sarakstu” atradīs quicksort implementāciju, pat ja vārds „sort” kodā nekad neparādās. Tas atspoguļo ikdienas realitāti, kad izstrādātājs pievienojas esošam projektam: tu zini, ko meklē, bet tev nav ne jausmas, kā iepriekšējā komanda to nosaukusi.

Koda direktorija indeksēšana

Pirmais solis ir izgūt un kodēt katru failu vai funkciju projektā. Zemāk esošā funkcija izstaigā direktoriju koku un izfiltrē mapes, kas sabojātu indeksu. Viena vienīga node_modules mape var būt desmit reizes lielāka par kodu, ko esi faktiski rakstījis, un neviens no tās failiem nav relevants tavai meklēšanai.

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

Divas implementācijas detaļas ir pelnījušas uzmanību. dirs[:] modificēšana uz vietas nav tikai saīsinājums; tas ir vienīgais veids, kā novērst os.walk iekļūšanu šajos direktorijos. Mainīgā pārdēvēšana bez šķēluma (slicing) nedotu nekādu efektu. Kas attiecas uz apgriešanu pie 4000 rakstzīmēm, tas pasargā tevi no monstru failiem, kas sabojātu pieprasījumu, vienlaikus saglabājot faila galveni — importus, galvenās definīcijas —, kas nes vissvarīgāko signālu.

Kodēšana un indeksēšana

Kodēšana notiek partijās pa divdesmit failiem, attēlojot progresu. Repozitorijā ar vairākiem simtiem failu šis cikls darbojas vairākas minūtes. Bez skaitītāja tev nav iespējas atšķirt lēnu apstrādi no iestrēguša izsaukuma.

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

Iegulšanu (embeddings) secība matricā precīzi atbilst code_files secībai. Šī netiešā atbilstība ir visu turpmāko darbību ass: tā ļauj rangā atgrieztam indeksam norādīt uz konkrētu faila ceļu.

Meklēšana dabiskajā valodā

Galvenā codestral-embed priekšrocība ir iespēja meklēt, uzdodot jautājumu franču vai angļu valodā. Funkcija kodē vaicājumu ar to pašu modeli, aprēķina līdzības pret visu indeksu un atgriež top_k labākos rezultātus kopā ar satura priekšskatījumu.

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

Laukam preview ir tūlītēja praktiska nozīme: tas ietaupa tevi no piecu failu atvēršanas, lai saprastu, kurš no tiem patiesībā atbilst. Redaktora integrācijā šie divi simti rakstzīmju kļūst par priekšskatījuma rindu, kas tiek parādīta zem katra rezultāta.

Meklēšana starp valodām

codestral-embed saprot loģiku neatkarīgi no valodas. Tu vari meklēt Python rakstu un atrast tam ekvivalentu JavaScript:

# 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

Šī spēja ir nenovērtējama lietotnēm, kas sadalītas starp Python backend un TypeScript frontend, kur viens un tas pats biznesa noteikums dažkārt ir implementēts abās pusēs. Abu implementāciju atrašana no viena vaicājuma palīdz tev pamanīt novirzes, pirms kļūda tās atklāj produkšanas vidē.

Meklēšana pēc funkcijas signatūras

Tu vari arī meklēt pēc paredzētās formas, nevis funkcionālās domēna. Aprakstot struktūru — asinhrona funkcija, klase, starpprogrammatūra (middleware), tests — tu virzi meklēšanu uz koda objekta tipu, nevis uz tēmu.

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

Izmēģini šos četrus vaicājumus savā repozitorijā, pirms dodies tālāk. Tu pamanīsi, ka rezultāti ievērojami pasliktinās ļoti garos failos, kur 4000 rakstzīmju apgriešana ir nogriezusi noderīgo daļu. Šis ir brīdis, kad jāizlemj, vai indeksēt veselus failus vai, vēl labāk, funkcijas, sadalītas pa vienai.

Galvenās atziņas

  • codestral-embed ļauj meklēt kodu, izmantojot aprakstus dabiskajā valodā
  • Indeksēšana ietver visu koda failu kodēšanu vektoros
  • Meklēšana starp valodām darbojas: Python raksts atrod JS ekvivalentu
  • Izgūšanas laikā izfiltrē nerelevantos direktorijus (node_modules, .git, venv)
  • Apriez ļoti garus failus, lai ietilptu modeļa limitos