Przejdź do głównej treści
Polski— Wybierz język
Menu

Wyszukiwanie semantyczne w kodzie

Lekcja 6 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Wyszukiwanie kodu po znaczeniu
  2. Indeksowanie katalogu z kodem
  3. Kodowanie i indeksowanie
  4. Wyszukiwanie w języku naturalnym
  5. Wyszukiwanie międzyjęzykowe
  6. Wyszukiwanie po sygnaturze funkcji
  7. Kluczowe wnioski

Wyszukiwanie kodu po znaczeniu

Tradycyjne wyszukiwanie w kodzie opiera się na słowach kluczowych: wpisujesz nazwę funkcji lub wyraz z komentarza. Wyszukiwanie semantyczne w kodzie idzie o krok dalej: znajduje kod na podstawie jego znaczenia lub intencji, nawet jeśli dokładne terminy nie pasują.

Dzięki modelowi codestral-embed możesz wyszukiwać kod, używając języka naturalnego. Zapytanie typu „funkcja sortująca listę“ znajdzie implementację quicksort, nawet jeśli słowo „sort“ nigdy nie pojawi się w kodzie. Odzwierciedla to codzienną rzeczywistość programisty dołączającego do istniejącego projektu: wiesz, czego szukasz, ale nie masz pojęcia, jak poprzedni zespół to nazwał.

Indeksowanie katalogu z kodem

Pierwszym krokiem jest wyodrębnienie i zakodowanie każdego pliku lub funkcji w projekcie. Poniższa funkcja przechodzi przez drzewo katalogów i filtruje foldery, które zaśmieciłyby indeks. Sam node_modules może być dziesięciokrotnie większy niż kod, który faktycznie napisałeś, a żaden z jego plików nie jest istotny dla Twojego wyszukiwania.

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

Dwa szczegóły implementacyjne zasługują na uwagę. Modyfikacja dirs[:] w miejscu to nie tylko skrót; to jedyny sposób, aby zapobiec schodzeniu funkcji os.walk do tych katalogów. Ponowne przypisanie zmiennej bez użycia wycinka nie przyniosłoby żadnego efektu. Jeśli chodzi o obcinanie przy 4000 znakach, chroni Cię to przed monstrualnymi plikami, które mogłyby spowodować awarię żądania, jednocześnie zachowując nagłówek pliku – importy, główne definicje – który niesie ze sobą najważniejszy sygnał.

Kodowanie i indeksowanie

Kodowanie odbywa się w partiach po dwadzieścia plików, z wyświetlaniem postępu. W repozytorium liczącym kilkaset plików ta pętla działa przez kilka minut. Bez licznika nie masz sposobu, aby odróżnić wolne przetwarzanie od zawieszonego wywołania.

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

Kolejność osadzeń w macierzy dokładnie odpowiada kolejności w code_files. Ta niejawna odpowiedniość jest osią wszystkiego, co następuje: pozwala indeksowi zwróconemu przez ranking wskazywać na konkretną ścieżkę pliku.

Wyszukiwanie w języku naturalnym

Główną zaletą modelu codestral-embed jest możliwość wyszukiwania za pomocą pytania w języku francuskim lub angielskim. Funkcja koduje zapytanie tym samym modelem, oblicza podobieństwa względem całego indeksu i zwraca top_k najlepszych wyników wraz z podglądem treści.

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 ma natychmiastowe zastosowanie praktyczne: oszczędza Ci otwierania pięciu plików, aby ustalić, który z nich faktycznie pasuje. W integracji z edytorem te dwieście znaków staje się linią podglądu wyświetlaną pod każdym wynikiem.

Wyszukiwanie międzyjęzykowe

codestral-embed rozumie logikę niezależnie od języka. Możesz szukać wzorca w Pythonie i znaleźć jego odpowiednik w 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

Ta umiejętność jest bezcenna w aplikacjach podzielonych między backend w Pythonie a frontend w TypeScript, gdzie ta sama reguła biznesowa bywa implementowana po obu stronach. Znalezienie obu implementacji na podstawie jednego zapytania pomaga wykryć rozbieżności, zanim ujawni się błąd na produkcji.

Wyszukiwanie po sygnaturze funkcji

Możesz również wyszukiwać według oczekiwanej formy, a nie domeny funkcjonalnej. Opisanie struktury – funkcji asynchronicznej, klasy, middleware, testu – kieruje wyszukiwanie w stronę typu obiektu kodu, a nie tematu.

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

Wypróbuj te cztery zapytania we własnym repozytorium, zanim przejdziesz dalej. Zauważysz, że wyniki znacznie się pogarszają w przypadku bardzo długich plików, gdzie obcięcie do 4000 znaków usunęło użyteczną część. To moment, aby zdecydować, czy indeksować całe pliki, czy – co lepsze – funkcje rozbite pojedynczo.

Kluczowe wnioski

  • codestral-embed pozwala wyszukiwać kod za pomocą opisów w języku naturalnym
  • Indeksowanie polega na zakodowaniu wszystkich plików kodu w wektory
  • Wyszukiwanie międzyjęzykowe działa: wzorzec w Pythonie znajduje odpowiednik w JS
  • Filtruj nieistotne katalogi (node_modules, .git, venv) podczas ekstrakcji
  • Obcinaj bardzo długie pliki, aby zmieścić się w limitach modelu