Codestral Embed: Code Embeddings
Sellel lehel
Codestral Embed: otsing koodi tähenduse järgi
Koodi genereerimine ja täiendamine ei piisa. Sa pead leidma ka faili sadade hulgast repositooriumis, mis lahendab juba sinu probleemi. Selle eest hoolitseb Mistral AI kolmas spetsialiseerunud tööriist: Codestral Embed (v25.05). See embedding-mudel teisendab koodilõigud arvvektoriteks, võimaldades repositooriumides teha semantilist otsingut.
Mis on koodi embedding?
Embedding on teksti või koodilõigu tihe vektoriesitus. Põhiomadus on lihtne: kaks semantiliselt sarnast lõiku tekitavad vektorruumis lähestikku asuvad vektorid, isegi kui nende süntaks ei näe sugugi sama välja. Vaata allpool olevaid kahte funktsiooni. Neil on erinevad nimed, erinevad muutujanimed ja erinevad implementatsioonid.
# 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)
grep-otsing ei leiaks kunagi teist funktsiooni, alustades esimesest. Codestral Embed toodab aga mõlema jaoks lähedased vektorid, kuna need lahendavad sama probleemi.
Tehnilised spetsifikatsioonid
Mudeli ID on codestral-embed-latest (v25.05). Sa kutsud seda lõpp-punktis /v1/embeddings. See töötleb lähtekoodi kõigis keeltes, mida Codestral toetab. Selle silmapaistev omadus on konfigureeritav mõõtmearv vahemikus 1536 kuni 3072. 1536-mõõtmeline seade pakub head kvaliteedi ja kulude suhet ning sobib enamiku kasutusjuhtude jaoks. 3072-mõõtmeline seade on suunatud maksimaalsele kvaliteedile kõige nõudlikumate otsingute puhul. Reegel on püsiv: rohkem mõõtmeid tähendab paremat semantilist täpsust, kuid ka suuremaid salvestuskulusid ja rohkem arvutust iga võrdluse jaoks. Keskmise suurusega repositooriumi puhul alusta 1536-ga ja suurenda ainult siis, kui tulemused tunduvad ebatäpsed.
API kasutamine
Põhiline väljakutse näeb välja nagu vestluse lõpp-punkt: loo klient, edasta lõik ja saa vastu 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]}")
Pane tähele, et parameeter inputs on loend. See detail loeb: terve repositooriumi indekseerimiseks saadad ühes päringus mitu lõiku, mitte ühe päringu faili kohta. Reaalses repositooriumis tähendab see kokku minuteid, mida säästad.
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]
Semantiline otsing koodibaasis
Peamine kasutusjuht tuleneb sellest otseselt: selle asemel, et otsida märksõnade järgi, otsid sa kavatsuse järgi. Torustikul on kaks sammu. Esiteks indekseeri koodibaas üks kord, lisades igale failile embeddingu. Seejärel teisenda päring vektoriks ja järjestada failid koosinussarnasuse alusel, mis on standardne mõõt kahe vektori läheduse hindamiseks.
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
)
Vaata lõplikku päringut: „function that validates an email address“. See ei sisalda projekti identifikaatoreid, failinimesid ega koodi märksõnu. See ongi kogu erinevus võrreldes tekstiotsinguga ja see muudab tööriista kasutatavaks isegi kellegi jaoks, kes on repositooriumis uus.
Täiustatud kasutusjuhud
Võimsaim kombinatsioon ühendab Codestral Embedi Codestrali või üldotstarbelise mudeliga, nagu Mistral Small 4. See on koodile rakendatud RAG (Retrieval-Augmented Generation) muster. Esiteks tood sa välja asjakohased failid, sisestad need süsteemi sõnumisse ja esitad seejärel oma küsimuse. Mudel vastab seejärel sinu koodibaasi põhjal, mitte ainult oma üldiste teadmiste põhjal keele kohta.
# 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?"}
],
)
Sama indeks teenib ka vähem silmapaistvat, kuid äärmiselt väärtuslikku ülesannet: dubleeriva koodi tuvastamist. Võrreldes iga funktsioonipaari ja märkides need, mille sarnasus ületab lävendit, saad nimekirja ümberkujundamise kandidaatidest, mida keegi meeskonnas pole märganud.
# 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']}")
Sa peaksid häälestama lävendi 0.90 oma koodi peal, enne kui järeldusi teed. Kui seadad selle liiga madalale, märgib see funktsioone, mis näevad sarnased välja, kuid teevad erinevaid asju. Kui seadad selle liiga kõrgele, tabab see ainult sõnasõnalisi kopeerimisi – neid, oleksid niigi leidnud.
Peamised punktid
- Codestral Embed (v25.05) teisendab koodi vektoriteks semantiliseks otsinguks
- See toetab 1536 kuni 3072 mõõdet, sõltuvalt sinu täpsusvajadustest
- Semantiline otsing võimaldab otsida kavatsuse, mitte märksõnade järgi
- RAG muster (otsing + genereerimine) on võimsaim kasutusjuht
- Embeddingud võimaldavad ka dubleerimiste tuvastamist ja koodi klastrite moodustamist