Codestral Embed: Embeddings de cod
Pe această pagină
Codestral Embed: Căutare semantică pentru cod
Generarea și completarea codului nu sunt suficiente. Trebuie, de asemenea, să găsiți fișierul dintr-un depozit de sute care rezolvă deja problema dumneavoastră. Aceasta este sarcina celui de-al treilea instrument specializat al Mistral AI: Codestral Embed (v25.05). Acest model de embedding transformă fragmentele de cod în vectori numerici, permițând căutarea semantică în cadrul depozitelor de cod.
Ce este un embedding de cod?
Un embedding este o reprezentare vectorială densă a unui text sau a unui fragment de cod. Proprietatea cheie este simplă: două fragmente similare din punct de vedere semantic produc vectori care se află aproape unul de celălalt în spațiul vectorial, chiar dacă sintaxa lor nu seamănă deloc. Luați în considerare cele două funcții de mai jos. Acestea au nume diferite, nume de variabile diferite și implementări diferite.
# 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)
O căutare grep nu ar găsi niciodată a doua funcție pornind de la prima. Codestral Embed, însă, produce vectori apropiați pentru ambele, deoarece rezolvă aceeași problemă.
Specificații tehnice
ID-ul modelului este codestral-embed-latest (v25.05). Îl apelați la endpoint-ul /v1/embeddings. Acesta gestionează codul sursă în toate limbajele suportate de Codestral. Caracteristica sa distinctivă o reprezintă dimensiunile configurabile, care variază de la 1536 la 3072. Setarea pe 1536 de dimensiuni oferă un raport calitate-cost solid și funcționează pentru majoritatea cazurilor de utilizare. Setarea pe 3072 de dimensiuni vizează calitatea maximă pentru cele mai exigente căutări. Regula este constantă: mai multe dimensiuni înseamnă o precizie semantică mai bună, dar și costuri de stocare mai mari și mai mult calcul pentru fiecare comparație. Pentru un depozit de dimensiuni medii, începeți cu 1536 și creșteți doar dacă rezultatele par neclare.
Utilizarea API-ului
Apelul de bază seamănă cu endpoint-ul de chat: instanțiați clientul, transmiteți un fragment și primiți un vector înapoi.
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]}")
Rețineți că parametrul inputs este o listă. Acest detaliu contează: pentru a indexa un întreg depozit, trimiteți mai multe fragmente într-o singură cerere, în loc de o cerere per fișier. Pe un depozit real, diferența se traduce prin minute economisite.
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]
Căutare semantică într-o bază de cod
Cazul principal de utilizare decurge direct din aceasta: în loc să căutați după cuvinte cheie, căutați după intenție. Fluxul are doi pași. Mai întâi, indexați baza de cod o singură dată, atașând un embedding fiecărui fișier. Apoi, transformați interogarea într-un vector și clasificați fișierele în funcție de similaritatea cosinusului, măsura standard de proximitate între doi vectori.
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
)
Priviți interogarea finală: „function that validates an email address“. Aceasta nu conține identificatori de proiect, nume de fișiere și nici cuvinte cheie de cod. Aceasta este întreaga diferență față de căutarea textului și face instrumentul utilizabil chiar și pentru cineva nou în cadrul depozitului.
Cazuri de utilizare avansate
Cea mai puternică combinație înlănțuie Codestral Embed cu Codestral sau cu un model de uz general, cum ar fi Mistral Small 4. Acesta este modelul RAG (Retrieval-Augmented Generation) aplicat codului. Mai întâi recuperați fișierele relevante, le injectați în mesajul de sistem și apoi puneți întrebarea. Modelul răspunde apoi pe baza bazei dumneavoastră de cod, nu doar pe baza cunoștințelor sale generale despre limbaj.
# 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?"}
],
)
Același index servește unei sarcini mai puțin spectaculoase, dar extrem de valoroase: detectarea codului duplicat. Prin compararea fiecărei perechi de funcții și semnalarea celor cu o similaritate peste un anumit prag, obțineți o listă de candidați pentru refactorizare pe care nimeni din echipă nu i-a observat.
# 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']}")
Ar trebui să reglați pragul de 0,90 pe propriul cod înainte de a trage concluzii. Dacă îl setați prea jos, va semnala funcții care seamănă, dar fac lucruri diferite. Dacă îl setați prea sus, va prinde doar copiile literale – pe cele pe care le-ați fi găsit oricum.
Puncte cheie
- Codestral Embed (v25.05) transformă codul în vectori pentru căutare semantică
- Suportă între 1536 și 3072 de dimensiuni, în funcție de nevoile dumneavoastră de precizie
- Căutarea semantică vă permite să căutați după intenție, nu după cuvinte cheie
- Modelul RAG (recuperare + generare) este cel mai puternic caz de utilizare
- Embedding-urile permit, de asemenea, detectarea duplicatelor și clusterizarea codului