Codestral Embed: Embeddingi kodu
Na tej stronie
Codestral Embed: Wyszukiwanie semantyczne w kodzie
Generowanie i uzupełnianie kodu to za mało. Musisz też znaleźć plik w repozytorium liczącym setki pozycji, który już rozwiązuje Twój problem. To zadanie dla trzeciego wyspecjalizowanego narzędzia Mistral AI: Codestral Embed (v25.05). Ten model embeddingowy zamienia fragmenty kodu w wektory numeryczne, umożliwiając wyszukiwanie semantyczne w obrębie całych repozytoriów.
Czym jest embedding kodu?
Embedding to gęsta reprezentacja wektorowa tekstu lub fragmentu kodu. Jego kluczowa właściwość jest prosta: dwa fragmenty o podobnym znaczeniu generują wektory położone blisko siebie w przestrzeni wektorowej, nawet jeśli ich składnia wygląda zupełnie inaczej. Spójrz na poniższe dwie funkcje. Mają różne nazwy, różne nazwy zmiennych i różne implementacje.
# 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)
Wyszukiwanie grep nigdy nie znalazłoby drugiej funkcji, zaczynając od pierwszej. Codestral Embed natomiast wygeneruje dla obu bliskie sobie wektory, ponieważ rozwiązują ten sam problem.
Specyfikacja techniczna
ID modelu to codestral-embed-latest (v25.05). Wywołujesz go na punkcie końcowym /v1/embeddings. Obsługuje on kod źródłowy we wszystkich językach wspieranych przez Codestral. Jego wyróżnikiem są konfigurowalne wymiary, od 1536 do 3072. Ustawienie 1536 wymiarów oferuje solidny stosunek jakości do kosztów i sprawdza się w większości przypadków użycia. Ustawienie 3072 wymiarów celuje w maksymalną jakość dla najbardziej wymagających wyszukiwań. Zasada jest stała: więcej wymiarów oznacza lepszą precyzję semantyczną, ale też wyższe koszty przechowywania i więcej obliczeń przy każdym porównaniu. Dla repozytorium średniej wielkości zacznij od 1536 i zwiększaj tę wartość tylko wtedy, gdy wyniki wydają się nieostre.
Korzystanie z API
Podstawowe wywołanie wygląda podobnie jak w przypadku punktu końcowego czatu: instancjujesz klienta, przekazujesz fragment kodu i otrzymujesz wektor.
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]}")
Zauważ, że parametr inputs jest listą. Ten szczegół ma znaczenie: aby zaindeksować całe repozytorium, wysyłasz wiele fragmentów w jednym żądaniu, zamiast tworzyć osobne żądanie dla każdego pliku. W przypadku prawdziwego repozytorium różnica ta przekłada się na zaoszczędzone 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]
Wyszukiwanie semantyczne w bazie kodu
Główny przypadek użycia wynika bezpośrednio z powyższego: zamiast szukać po słowach kluczowych, szukasz według zamiaru. Proces składa się z dwóch kroków. Najpierw indeksujesz bazę kodu raz, dołączając embedding do każdego pliku. Następnie przekształcasz zapytanie w wektor i rankujesz pliki według podobieństwa kosinusowego, będącego standardową miarą bliskości między dwoma wektorami.
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
)
Spójrz na końcowe zapytanie: „function that validates an email address“. Nie zawiera ono identyfikatorów projektu, nazw plików ani słów kluczowych związanych z kodem. To właśnie stanowi całą różnicę w porównaniu z wyszukiwaniem tekstowym i sprawia, że narzędzie jest użyteczne nawet dla osoby nowej w danym repozytorium.
Zaawansowane przypadki użycia
Najpotężniejszą kombinacją jest połączenie Codestral Embed z modelem Codestral lub modelem ogólnego przeznaczenia, takim jak Mistral Small 4. To wzorzec RAG (Retrieval-Augmented Generation) zastosowany do kodu. Najpierw pobierasz odpowiednie pliki, wstrzykujesz je do wiadomości systemowej, a następnie zadajesz swoje pytanie. Model odpowiada wtedy w oparciu o Twoją bazę kodu, a nie tylko na podstawie swojej ogólnej wiedzy o języku.
# 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?"}
],
)
Ten sam indeks służy również mniej efektownemu, ale niezwykle cennemu zadaniu: wykrywaniu zduplikowanego kodu. Porównując każdą parę funkcji i flagując te, których podobieństwo przekracza określony próg, otrzymujesz listę kandydatów do refaktoryzacji, których nikt w zespole wcześniej nie zauważył.
# 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']}")
Powinieneś dostroić próg 0,90 do własnego kodu przed wyciągnięciem wniosków. Jeśli ustawisz go zbyt nisko, system będzie flagował funkcje, które wyglądają podobnie, ale robią co innego. Jeśli ustawisz go zbyt wysoko, wykryje tylko literalne kopiuj-wklej – te, które i tak byś znalazł.
Kluczowe wnioski
- Codestral Embed (v25.05) zamienia kod w wektory umożliwiające wyszukiwanie semantyczne
- Obsługuje od 1536 do 3072 wymiarów, w zależności od Twoich potrzeb dotyczących precyzji
- Wyszukiwanie semantyczne pozwala szukać według zamiaru, a nie słów kluczowych
- Wzorzec RAG (pobieranie + generowanie) to najpotężniejszy przypadek użycia
- Embeddingi umożliwiają również wykrywanie duplikatów i klastrowanie kodu