Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Sökning i kod efter betydelse

Lektion 6 av 18 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Sök i kod efter betydelse
  2. Indexering av en kodkatalog
  3. Kodning och indexering
  4. Sökning med naturligt språk
  5. Språköverskridande sökning
  6. Sökning efter funktionssignatur
  7. Viktiga punkter

Sök i kod efter betydelse

Traditionell kodsökning förlitar sig på nyckelord: du skriver in ett funktionsnamn eller ett ord från en kommentar. Semantisk kodsökning går längre: den hittar kod baserat på dess betydelse eller avsikt, även om de exakta termerna inte matchar.

Med codestral-embed kan du söka i kod med naturligt språk. En fråga som “funktion som sorterar en lista” hittar en quicksort-implementering även om ordet “sort” aldrig förekommer i koden. Detta speglar vardagen för en utvecklare som går med i ett befintligt projekt: du vet vad du letar efter, men du har ingen aning om hur det tidigare teamet namngav det.

Indexering av en kodkatalog

Det första steget är att extrahera och koda varje fil eller funktion i ett projekt. Funktionen nedan traverserar katalogträdet och filtrerar bort mappar som skulle skräpa ner indexet. node_modules ensamt kan vara tio gånger större än koden du faktiskt skrivit, och inga av dess filer är relevanta för din sökning.

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

Två implementeringsdetaljer förtjänar uppmärksamhet. Att modifiera dirs[:] på plats är inte bara en genväg; det är det enda sättet att förhindra att os.walk går ner i dessa kataloger. Att tilldela variabeln på nytt utan slicing skulle inte ha någon effekt. När det gäller att trunkera vid 4 000 tecken skyddar detta dig från monstruösa filer som skulle spränga begäran, samtidigt som filhuvudet – importeringar, huvuddefinitioner – behålls, vilket bär den mest signifikanta signalen.

Kodning och indexering

Kodning sker i batchar om tjugo filer, med en förloppsindikator. I ett arkiv med flera hundra filer tar denna loop flera minuter. Utan en räknare har du inget sätt att skilja långsam bearbetning från ett fastnat anrop.

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

Ordningen på inbäddningarna i matrisen matchar exakt ordningen på code_files. Denna implicita korrespondens är navet för allt som följer: den gör att ett index som returneras av rankningen kan peka på en specifik filsökväg.

Sökning med naturligt språk

Den stora fördelen med codestral-embed är att du kan söka med en fråga på franska eller engelska. Funktionen kodar frågan med samma modell, beräknar likheter mot hela indexet och returnerar de top_k bästa resultaten tillsammans med en förhandsgranskning av innehållet.

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

Fältet preview har omedelbar praktisk nytta: det sparar dig från att öppna fem filer för att ta reda på vilken som faktiskt matchar. I en editor-integration blir dessa två hundra tecken förhandsgranskningsraden som visas under varje resultat.

Språköverskridande sökning

codestral-embed förstår logik oavsett språk. Du kan söka efter ett Python-mönster och hitta motsvarigheten i 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

Denna förmåga är ovärderlig för applikationer som är uppdelade mellan en Python-backend och en TypeScript-frontend, där samma affärsregel ibland implementeras på båda sidorna. Att hitta båda implementationerna från en enda fråga hjälper dig att upptäcka avvikelser innan en bugg avslöjar dem i produktion.

Sökning efter funktionssignatur

Du kan också söka efter förväntad form snarare än funktionellt domän. Att beskriva strukturen – en asynkron funktion, en klass, middleware, ett test – styr sökningen mot en typ av kodobjekt snarare än ett ämne.

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

Prova dessa fyra frågor på ditt eget arkiv innan du går vidare. Du kommer att märka att resultaten försämras avsevärt på mycket långa filer, där trunkeringen på 4 000 tecken klippt bort den användbara delen. Det är då du måste besluta om du ska indexera hela filer eller, ännu bättre, funktioner uppdelade en och en.

Viktiga punkter

  • codestral-embed låter dig söka efter kod med beskrivningar i naturligt språk
  • Indexering innebär att koda alla kodfiler till vektorer
  • Språköverskridande sökning fungerar: ett Python-mönster hittar JS-motsvarigheten
  • Filtrera bort irrelevanta kataloger (node_modules, .git, venv) under extrahering
  • Trunkera mycket långa filer för att hålla sig inom modellens gränser