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

Codestral Embed: Kódba ágyazások

11. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Codestral Embed: Szemantikus keresés kódban
  2. Mi az a kódba ágyazás (embedding)?
  3. Műszaki specifikációk
  4. Az API használata
  5. Szemantikus keresés egy kódbázisban
  6. Haladó használati esetek
  7. Főbb megállapítások

Codestral Embed: Szemantikus keresés kódban

A kód generálása és kiegészítése önmagában nem elég. Meg kell találnod azt a fájlt is egy több száz fájlból álló tárolóban, amely már megoldja a problémádat. Ez a Mistral AI harmadik specializált eszközének, a Codestral Embed (v25.05) feladata. Ez a beágyazási modell kódrészleteket alakít numerikus vektorokká, lehetővé téve a tárolók közötti szemantikus keresést.

Mi az a kódba ágyazás (embedding)?

A beágyazás a szöveg vagy egy kódrészlet sűrű vektoros reprezentációja. A kulcstulajdonság egyszerű: két szemantikailag hasonló részlet olyan vektorokat hoz létre, amelyek közel helyezkednek el a vektortérben, még akkor is, ha a szintaxisuk teljesen különbözik. Nézd meg az alábbi két függvényt. Különböző a nevük, mások a változóneveik, és eltérő a megvalósításuk is.

# Function 1
def calculer_moyenne(nombres):
    return sum(nombres) / len(nombres)

# Function 2
def average(values):
    total = 0
    for v in values:
        total += v
    return total / len(values)

Egy grep keresés sosem találná meg a második függvényt az első alapján. A Codestral Embed azonban mindkettőhöz közeli vektorokat rendel, mivel ugyanazt a problémát oldják meg.

Műszaki specifikációk

A modell azonosítója: codestral-embed-latest (v25.05). A /v1/embeddings végponton érhető el. Kezeli a Codestral által támogatott összes nyelv forráskódját. Kiemelkedő tulajdonsága a konfigurálható dimenziószám, amely 1536 és 3072 között állítható. Az 1536 dimenziós beállítás jó minőség-költség arányt kínál, és a legtöbb használathoz megfelelő. A 3072 dimenziós beállítás a legigényesebb keresésekhez biztosít maximális minőséget. Az szabály állandó: több dimenzió jobb szemantikai pontosságot jelent, de nagyobb tárolási költséggel és több számítási igényel jár minden összehasonlításnál. Közepes méretű tároló esetén kezdd 1536-tal, és csak akkor növeld, ha az eredmények bizonytalannak tűnnek.

Az API használata

Az alapvető hívás hasonló a csevegési végponthoz: példányosítod a klienst, átadsz egy kódrészletet, és visszakapod a vektort.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

code_snippet = """
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
"""

response = client.embeddings.create(
    model="codestral-embed-latest",
    inputs=[code_snippet],
)

embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}")
print(f"First values: {embedding[:5]}")

Figyeld meg, hogy az inputs paraméter egy lista. Ez a részlet számít: egy teljes tároló indexeléséhez több kódrészletet küldesz egyetlen kérésben, nem pedig fájlonként egyet-egyet. Valódi tároló esetén ez a különbség perceket spórol meg.

code_snippets = [
    "def tri_bulle(liste): ...",
    "def tri_rapide(liste): ...",
    "def tri_fusion(liste): ...",
    "def recherche_binaire(liste, cible): ...",
]

response = client.embeddings.create(
    model="codestral-embed-latest",
    inputs=code_snippets,
)

embeddings = [item.embedding for item in response.data]

Szemantikus keresés egy kódbázisban

Az elsődleges használati eset ebből közvetlenül következik: kulcsszavak helyett szándék alapján keresel. A folyamat két lépésből áll. Először egyszer indexeled a kódbázist, és minden fájlhoz hozzárendelsz egy beágyazást. Ezután a lekérdezést vektorrá alakítod, és a fájlokat a koszinusz-hasonlóság alapján rangsorolod, ami a két vektor közötti közelség szabványos mérőszáma.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# 1. Index the codebase (do this once)
def index_codebase(files: list[dict]) -> list[dict]:
    """Indexes a list of files with their embeddings."""
    contents = [f["content"] for f in files]

    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=contents,
    )

    for i, file in enumerate(files):
        file["embedding"] = response.data[i].embedding

    return files

# 2. Search by intent
def search_code(query: str, index: list[dict], top_k: int = 5) -> list[dict]:
    """Semantic search in the indexed codebase."""
    response = client.embeddings.create(
        model="codestral-embed-latest",
        inputs=[query],
    )
    query_vector = np.array(response.data[0].embedding)

    # Calculate cosine similarity
    results = []
    for file in index:
        file_vector = np.array(file["embedding"])
        similarity = np.dot(query_vector, file_vector) / (
            np.linalg.norm(query_vector) * np.linalg.norm(file_vector)
        )
        results.append({**file, "score": similarity})

    results.sort(key=lambda x: x["score"], reverse=True)
    return results[:top_k]

# 3. Usage
results = search_code(
    "function that validates an email address",
    index=my_index
)

Nézd meg az utolsó lekérdezést: „function that validates an email address“. Nincsenek benne projektazonosítók, fájlnevek vagy kód-kulcsszavak. Ez a teljes különbség a szöveges kereséshez képest, és lehetővé teszi az eszköz használatát még azok számára is, akik újak a tárolóban.

Haladó használati esetek

A legerősebb kombináció a Codestral Embed láncolása a Codestrallel vagy egy általános célú modellel, mint például a Mistral Small 4. Ez a RAG (Retrieval-Augmented Generation, visszakereséssel bővített generálás) minta alkalmazása kódra. Először visszakeresed a releváns fájlokat, beilleszted őket a rendszerüzenetbe, majd felteszed a kérdésedet. A modell ezután a saját kódbázisod alapján válaszol, nemcsak a nyelvről szóló általános tudása alapján.

# 1. Find relevant files with Codestral Embed
results = search_code("HTTP error handling", index)

# 2. Build context
context = "\n\n".join([r["content"] for r in results[:3]])

# 3. Generate a response with Codestral
response = client.chat.complete(
    model="codestral-latest",
    messages=[
        {"role": "system", "content": f"Here is the relevant code from the project:\n{context}"},
        {"role": "user", "content": "How can I improve HTTP error handling in this project?"}
    ],
)

Ugyanez az index egy kevésbé látványos, de rendkívül értékes feladatot is szolgál: a duplikált kód észlelését. Minden függvénypár összehasonlításával és egy küszöbérték feletti hasonlóságot mutatók megjelölésével olyan refaktorálási jelöltek listáját kapod, amelyeket a csapat senki sem vett észre.

# Compare every pair of functions
for i, func_a in enumerate(functions):
    for j, func_b in enumerate(functions):
        if i >= j:
            continue
        similarity = cosine(func_a["embedding"], func_b["embedding"])
        if similarity > 0.90:
            print(f"Potential duplication: {func_a['name']} <-> {func_b['name']}")

A következtetések levonása előtt saját kódodon hangold be a 0,90-es küszöbértéket. Ha túl alacsonyra állítod, olyan függvényeket jelöl meg, amelyek hasonlónak tűnnek, de különböző dolgokat csinálnak. Ha túl magasra, akkor csak a szó szerinti másolás-beillesztéseket fogja el – azokat, amelyeket amúgy is megtaláltál volna.

Főbb megállapítások

  • A Codestral Embed (v25.05) vektorokká alakítja a kódot a szemantikus kereséshez
  • Támogatja az 1536 és 3072 közötti dimenziószámot a pontossági igényeid függvényében
  • A szemantikus keresés lehetővé teszi a szándék alapú keresést, nem csak kulcsszavakét
  • A RAG minta (visszakeresés + generálás) a legerősebb használati eset
  • A beágyazások lehetővé teszik a duplikációk észlelését és a kód klaszterezését is