Codestral Embed: Vkládání kódu
Na této stránce
Codestral Embed: Sémantické vyhledávání v kódu
Generování a doplňování kódu nestačí. Také potřebuješ najít soubor v repozitáři o stovkách položek, který tvůj problém již řeší. To je úkolem třetího specializovaného nástroje od Mistral AI: Codestral Embed (v25.05). Tento model pro vytváření vnoření (embeddings) převádí úryvky kódu na číselné vektory, což umožňuje sémantické vyhledávání napříč repozitáři.
Co je vnoření kódu?
Vnoření (embedding) je hustá vektorová reprezentace textu nebo úryvku kódu. Klíčová vlastnost je jednoduchá: dva sémanticky podobné úryvky vytvoří vektory, které jsou ve vektorovém prostoru blízko u sebe, i když jejich syntaxe vypadá zcela odlišně. Podívej se na níže uvedené dvě funkce. Mají různé názvy, různé názvy proměnných a různé implementace.
# 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)
Vyhledávání pomocí grep by nikdy nenašlo druhou funkci na základě té první. Codestral Embed však pro obě vytvoří blízké vektory, protože řeší stejný problém.
Technické specifikace
ID modelu je codestral-embed-latest (v25.05). Voláš jej na koncovém bodě /v1/embeddings. Zpracovává zdrojový kód ve všech jazycích podporovaných modelem Codestral. Jeho vynikající funkcí jsou konfigurovatelné rozměry v rozsahu od 1536 do 3072. Nastavení s 1536 rozměry nabízí solidní poměr kvality k nákladům a funguje pro většinu případů použití. Nastavení s 3072 rozměry cílí na maximální kvalitu pro nejnáročnější vyhledávání. Pravidlo je stálé: více rozměrů znamená lepší sémantickou přesnost, ale také vyšší náklady na úložiště a více výpočtů pro každé porovnání. U repozitáře střední velikosti začni na 1536 a zvyšuj počet pouze tehdy, pokud se výsledky zdají být nepřesné.
Použití API
Základní volání vypadá jako u koncového bodu pro chat: vytvoř instance klienta, předej úryvek kódu a získej zpět vektor.
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]}")
Všimni si, že parametr inputs je seznam. Tento detail je důležitý: pro indexaci celého repozitáře odešleš více úryvků v jedné žádosti, nikoli jednu žádost na soubor. U skutečného repozitáře se tento rozdíl sčítá na ušetřené minuty.
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]
Sémantické vyhledávání v kódové základně
Primární případ použití z toho vyplývá přímo: místo vyhledávání podle klíčových slov vyhledáváš podle záměru. Pipeline má dva kroky. Nejprve jednou zaindexuješ kódovou základnu a ke každému souboru připojíš vnoření. Poté převedeš dotaz na vektor a seřadíš soubory podle kosinové podobnosti, což je standardní míra blízkosti mezi dvěma vektory.
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
)
Podívej se na finální dotaz: „function that validates an email address“. Neobsahuje žádné identifikátory projektu, žádné názvy souborů ani žádná klíčová slova kódu. To je celý rozdíl oproti textovému vyhledávání a díky tomu je nástroj použitelný i pro někoho, kdo je v repozitáři nový.
Pokročilé případy použití
Nejsilnější kombinace řetězí Codestral Embed s modelem Codestral nebo modelem pro obecné účely, jako je Mistral Small 4. Jedná se o vzor RAG (Retrieval-Augmented Generation) aplikovaný na kód. Nejprve získáš relevantní soubory, vložíš je do systémové zprávy a poté položíš svou otázku. Model pak odpoví na základě tvé kódové základny, nejen na základě svých obecných znalostí daného jazyka.
# 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?"}
],
)
Stejný index slouží také méně efektnímu, ale vysoce cennému úkolu: detekci duplicitního kódu. Porovnáním každého páru funkcí a označením těch s podobností nad určitým prahem získáš seznam kandidátů na refaktorizaci, které si nikdo v týmu nevšiml.
# 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']}")
Prahovou hodnotu 0,90 bys měl vyladit na vlastním kódu, než vyvodíš závěry. Pokud ji nastavíš příliš nízko, označí funkce, které vypadají podobně, ale dělají různé věci. Pokud ji nastavíš příliš vysoko, zachytí pouze doslovné kopie – ty, které bys stejně našel sám.
Klíčové poznatky
- Codestral Embed (v25.05) převádí kód na vektory pro sémantické vyhledávání
- Podporuje 1536 až 3072 rozměrů v závislosti na tvých potřebách přesnosti
- Sémantické vyhledávání ti umožňuje hledat podle záměru, nikoli podle klíčových slov
- Vzor RAG (vyhledávání + generování) je nejmocnějším případem použití
- Vnoření také umožňují detekci duplicit a shlukování kódu