Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Codestral Embed: Leabaithe Cóid

Ceacht 11 as 14 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Codestral Embed: Cuardach Seimeantach do Chód
  2. Cad é Leabú Cóid?
  3. Sonraíochtaí Teicniúla
  4. An API a Úsáid
  5. Cuardach Seimeantach i mBunachar Cóid
  6. Cásanna Úsáide Casta
  7. Príomhphointí

Codestral Embed: Cuardach Seimeantach do Chód

Ní leor cód a ghiniúint ná a chur i gcrích. Caithfidh tú an comhad a aimsiú i stór ina bhfuil na céadta comhad ann cheana féin a réitíonn do fhadhb. Sin post an tríú uirlis speisialaithe ó Mistral AI: Codestral Embed (v25.05). Tiontaíonn an tsamhail leabaithe seo blúirí cóid ina veicteoirí uimhriúla, rud a chuireann cuardach seimeantach ar fáil thar stórais.

Cad é Leabú Cóid?

Is léiriú veicteora dlúth de théacs nó de bhlúire cóid é leabú. Is simplí an príomh-airí: cruthaíonn dhá bhlúire atá cosúil go seimeantach veicteoirí atá gar dá chéile sa spás veicteora, fiú mura bhfuil aon chosúlacht idir a gcomhréir. Breathnaigh ar an dá fheidhm thíos. Tá ainmneacha difriúla acu, ainmneacha athróg difriúla, agus cur chun feidhme difriúil.

# 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)

Ní aimsíodh an dara feidhm riamh ag tosú ón gcéad cheann le cuardach grep. Mar sin féin, cruthaíonn Codestral Embed veicteoirí atá gar dá chéile don bheirt toisc go réitíonn siad an fhadhb chéanna.

Sonraíochtaí Teicniúla

Is é codestral-embed-latest (v25.05) an t-aithneoir samhla. Glaoitear air ar an bpointe deiridh /v1/embeddings. Láimhseálann sé cód foinse i ngach teanga a dtacaíonn Codestral léi. Is é an ghné is suntasaí ná toisí inchoigeartaithe, ó 1536 go 3072. Tairgeann an socrú 1536 toise cóimheas soladach idir cáilíocht agus costas, agus oibríonn sé don chuid is mó de chásanna úsáide. Díríonn an socrú 3072 toise ar cháilíocht uasta do na cuardaigh is éilithí. Is tairiseach an riail: ciallaíonn níos mó toisí cruinneas seimeantach níos fearr, ach freisin costais stórála níos airde agus níos mó ríomhaireachta do gach comparáid. I gcás stóir mheánmhéide, tosaigh ag 1536 agus méadaigh é ach amháin má tá na torthaí doiléir.

An API a Úsáid

Tá an glao bunúsach cosúil leis an bpointe deiridh comhrá: déan an cliant a shamhlú, cuir blúire isteach, agus faigh veicteoir ar ais.

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

Tabhair faoi deara gur liosta é an paraiméadar inputs. Tá tábhacht leis an mionsonra seo: chun stór iomlán a innéacsú, seolann tú blúirí iolracha in aon iarratas amháin seachas iarratas amháin in aghaidh an chomhaid. Ar stór fíor, suimíonn an difríocht go dtí nóiméad a shábháiltear.

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]

Cuardach Seimeantach i mBunachar Cóid

Leanann an príomhchás úsáide go díreach as seo: in ionad cuardach a dhéanamh de réir eochairfhocail, déanann tú cuardach de réir rúin. Tá dhá chéim sa phíblíne. Ar dtús, déan an bunachar cóid a innéacsú uair amháin, ag ceangal leabaithe le gach comhad. Ansin, tiontaigh an cheist ina veicteoir agus déan rangú ar na comhaid de réir cosain chomhchosúlachta, an tomhas caighdeánach ar ghareacht idir dhá veicteoir.

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
)

Féach ar an gceist dheireanach: “function that validates an email address”. Níl aon aitheantóirí tionscadail, aon ainmneacha comhaid, ná aon eochairfhocail cóid ann. Sin an difríocht iomlán i gcomparáid le cuardach téacs, agus déanann sé an uirlis inúsáidte fiú do dhuine atá nua don stór.

Cásanna Úsáide Casta

Is é an comhcheangal is cumhachtaí ná Codestral Embed a shlabhrú le Codestral nó le samhail gheneralta cosúil le Mistral Small 4. Is é seo an patrún RAG (Retrieval-Augmented Generation) curtha i bhfeidhm ar chód. Aimsíonn tú comhaid ábhartha ar dtús, insteallann tú isteach sa teachtaireacht chórais iad, agus ansin faigheann tú do cheist. Ansin freagraíonn an tsamhail bunaithe ar do bhunachar cóid, ní hamháin bunaithe ar a eolas ginearálta ar an teanga.

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

Freastalaíonn an t-innéacs céanna ar thasc nach bhfuil chomh gléineach ach atá an-luachmhar: braithint cóid dhúbailte. Trí gach péire feidhme a chur i gcomparáid agus iad siúd a bhfuil cosúlacht os cionn tairsí acu a bhrath, faigheann tú liosta d’iarrthóirí athfhoirmithe nár thug aon duine ar an bhfoireann faoi deara.

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

Ba chóir duit an tairseach 0.90 a choigeartú ar do chód féin sula dtarraingíonn tú conclúidí. Má shocraíonn tú ró-íseal é, brathfaidh sé feidhmeanna a bhfuil cuma chosúil orthu ach a dhéanann rudaí difriúla. Má shocraíonn tú ró-ard é, ní ghabhfaidh sé ach cóipeáil-greamú litriúil – na cinn a d’aimsíodh tú sowasó.

Príomhphointí

  • Tiontaíonn Codestral Embed (v25.05) cód ina veicteoirí le haghaidh cuardaigh sheimeantaigh
  • Tacaíonn sé le 1536 go 3072 toise ag brath ar do riachtanais cruinnis
  • Ligeann cuardach seimeantach duit cuardach a dhéanamh de réir rúin, seachas eochairfhocail
  • Is é an patrún RAG (aisghabháil + giniúint) an cás úsáide is cumhachtaí
  • Cumasaíonn leabaithe braithint dúbailt agus braislíocht cóid freisin