Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Codestral Embed: Code Embeddings

Oppitunti 11 / 14 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Codestral Embed: Haku koodin semanttiseen etsintään
  2. Mikä on koodin upotus (embedding)?
  3. Tekniset vaatimukset
  4. Rajapinnan käyttö
  5. Semanttinen haku koodikannassa
  6. Edistyneet käyttötavat
  7. Keskeiset asiat

Codestral Embed: Haku koodin semanttiseen etsintään

Koodin generointi ja täydentäminen eivät riitä. Sinun on myös löydettävä satojen tiedostojen joukosta se yksi, joka ratkaisee ongelmasi jo valmiiksi. Tähän tehtävään on olemassa Mistral AI:n kolmas erikoistyökalu: Codestral Embed (v25.05). Tämä upotusmalli muuntaa koodikatkelmat numeerisiksi vektoreiksi, mahdollistaen semanttisen haun koodivarastoissa.

Mikä on koodin upotus (embedding)?

Upotus on tiheä vektorimuotoinen esitys tekstistä tai koodikatkelmasta. Sen keskeinen ominaisuus on yksinkertainen: kaksi semanttisesti samankaltaista katkelmaa tuottaa vektoreita, jotka sijaitsevat lähellä toisiaan vektoritilassa, vaikka niiden syntaksi näyttäisi täysin erilaiselta. Tarkastele alla olevia kahta funktiota. Niillä on eri nimet, eri muuttujanimet ja eri toteutustavat.

# 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-haku ei koskaan löytäisi toista funktiota ensimmäisen perusteella. Codestral Embed tuottaa kuitenkin molemmille läheiset vektorit, koska ne ratkaisevat saman ongelman.

Tekniset vaatimukset

Mallin tunniste on codestral-embed-latest (v25.05). Kutset sitä päätepisteessä /v1/embeddings. Se käsittelee lähdekoodia kaikilla Codestralin tukemilla kielillä. Sen erottuva ominaisuus on säädettävä ulottuvuuksien määrä, joka vaihtelee välillä 1536–3072. 1536-ulotteinen asetus tarjoaa vankan laatu-kustannussuhteen ja sopii useimpiin käyttötarkoituksiin. 3072-ulotteinen asetus on suunniteltu maksimaaliseen laatuun vaativimmissa hauissa. Sääntö on vakio: enemmän ulottuvuuksia tarkoittaa parempaa semanttista tarkkuutta, mutta myös korkeampia tallennuskustannuksia ja enemmän laskentaa jokaiselle vertailulle. Keskikokoisessa koodivarastossa aloita arvosta 1536 ja kasvata sitä vain, jos tulokset vaikuttavat epätarkoilta.

Rajapinnan käyttö

Peruskutsu näyttää samanlaiselta kuin keskustelupäätepiste: alusta asiakasohjelma, syötä katkelma ja saat vektorin takaisin.

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]}")

Huomaa, että inputs-parametri on lista. Tämä yksityiskohta on tärkeä: indeksoidaksesi koko koodivaraston lähetät useita katkelmia yhdessä pyynnössä yhden pyynnön sijaan tiedostoa kohden. Todellisessa koodivarastossa ero tarkoittaa säästettyjä minuutteja.

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]

Semanttinen haku koodikannassa

Ensisijainen käyttötarkoitus seuraa tästä suoraan: avainsanojen sijaan haet tarkoituksen perusteella. Putki koostuu kahdesta vaiheesta. Ensin indeksoi koodikanta kerran liittämällä upotus jokaiseen tiedostoon. Sen jälkeen muunna kysely vektoriksi ja järjestä tiedostot kosinussimilaarisuuden mukaan, mikä on standardimitta kahden vektorin väliselle läheisyydelle.

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
)

Tarkastele viimeistä kyselyä: “function that validates an email address”. Se ei sisällä projektitunnisteita, tiedostonimiä eikä koodin avainsanoja. Siinä koko ero tekstihakuun verrattuna, ja se tekee työkalusta käytettävän jopa henkilölle, joka on uusi koodivarastossa.

Edistyneet käyttötavat

Voimakkain yhdistelmä ketjuttaa Codestral Embedin joko Codestralin tai yleiskäyttöisen mallin, kuten Mistral Small 4:n, kanssa. Tämä on RAG-malli (Retrieval-Augmented Generation) sovellettuna koodiin. Ensin haet asiaankuuluvat tiedostot, syötät ne järjestelmäviestiin ja esität sitten kysymyksesi. Malli vastaa tämän jälkeen koodikantasi perusteella, ei pelkästään yleisen kielitietonsa pohjalta.

# 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 indeksi palvelee myös vähemmän näyttävää mutta erittäin arvokasta tehtävää: kaksoiskoodin havaitsemista. Vertaamalla jokaista funktioparia ja merkitsemällä ne, joiden samankaltaisuus ylittää kynnyksen, saat listan refaktorointiehdokkaista, joita kukaan tiimissäsi ei ole huomannut.

# 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']}")

Sinun tulee säätää 0,90:n kynnysarvo omalle koodillesi ennen johtopäätösten tekemistä. Jos asetat sen liian matalalle, se merkitsee funktioita, jotka näyttävät samanlaisilta mutta tekevät eri asioita. Jos asetat sen liian korkealle, se löytää vain kirjaimelliset kopio-liimaukset – ne, jotka olisit löytänyt muutenkin.

Keskeiset asiat

  • Codestral Embed (v25.05) muuntaa koodin vektoreiksi semanttista hakua varten
  • Se tukee 1536–3072 ulottuvuutta tarkkuustarpeidesi mukaan
  • Semanttinen haku mahdollistaa haun tarkoituksen, ei avainsanojen perusteella
  • RAG-malli (haku + generointi) on voimakkain käyttötapa
  • Upotukset mahdollistavat myös kaksoiskoodin havaitsemisen ja koodin klusteroinnin