Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Il modello codestral-embed

Lezione 5 di 18 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Embedding Specializzati per il Codice
  2. Specifiche Tecniche
  3. Utilizzo di Base
  4. Il Parametro output_dimension
  5. Il Parametro output_dtype
  6. Combinare Dimensione e Dtype
  7. Linguaggi Supportati
  8. Punti chiave

Embedding Specializzati per il Codice

Mentre mistral-embed è progettato per il linguaggio naturale, codestral-embed è un modello di embedding ottimizzato specificamente per i linguaggi di programmazione. Comprende la sintassi, la semantica e la logica del codice, rendendolo nettamente superiore a un modello di testo generico per qualsiasi compito che coinvolga codice sorgente.

Puoi osservare la differenza in un caso semplice. Due funzioni che fanno la stessa cosa—una scritta con un ciclo for e l’altra che usa la list comprehension—non condividono quasi nessun token. Un modello di testo le vede come due blocchi distinti di punteggiatura; un modello addestrato sul codice le riunisce perché ha appreso che queste due forme esprimono la stessa intenzione.

Specifiche Tecniche

Il modello codestral-embed differisce da mistral-embed in diversi aspetti chiave:

Caratteristicacodestral-embedmistral-embed
Dimensioni Predefinite15361024
Dimensioni Massime3072 (il doppio del predefinito)—
Tipi di Outputfloat, int8, uint8, binary, ubinary—
OttimizzazioneAddestrato su codice sorgente multi-linguaLinguaggio naturale

Questa flessibilità nelle dimensioni e nei tipi di output è ciò che distingue realmente i due modelli nella pratica. Un indice di codice raggiunge rapidamente il milione di vettori e poter ridurre il loro peso di quattro volte cambia radicalmente la fattura dell’infrastruttura.

Utilizzo di Base

L’API è identica a quella di mistral-embed, eccetto per il nome del modello codestral-embed. Null’altro cambia nel tuo codice di chiamata, il che ti permette di eseguire entrambi i modelli nello stesso progetto modificando solo un parametro.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Codifica snippet di codice
response = client.embeddings.create(
    model="codestral-embed",
    inputs=[
        "def fibonacci(n): return n if n <= 1 else fibonacci(n-1) + fibonacci(n-2)",
        "function fibonacci(n) { return n <= 1 ? n : fibonacci(n-1) + fibonacci(n-2); }",
        "public int fibonacci(int n) { return n <= 1 ? n : fibonacci(n-1) + fibonacci(n-2); }",
    ],
)

for i, data in enumerate(response.data):
    print(f"Snippet {i+1}: vector of {len(data.embedding)} dimensions")
# Snippet 1: vector of 1536 dimensions
# Snippet 2: vector of 1536 dimensions
# Snippet 3: vector of 1536 dimensions

Nota che tutti e tre gli snippet implementano la stessa logica (Fibonacci) in tre linguaggi diversi. I loro embedding saranno molto vicini nonostante le differenze sintattiche. Questa proprietà abilita la ricerca cross-language: su un codebase poliglotta, uno sviluppatore Python può trovare l’implementazione Java di cui ha bisogno senza conoscere una parola di Java.

Il Parametro output_dimension

Puoi ridurre la dimensione del vettore per risparmiare spazio di archiviazione, al costo di una leggera perdita di precisione:

# Dimensioni ridotte (512 invece di 1536)
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=512,
    inputs=["def hello(): print('Hello, World!')"],
)

embedding = response.data[0].embedding
print(f"Dimensions: {len(embedding)}")  # 512

Le prime dimensioni del vettore sono le più informative. Il modello è progettato in modo che le prime n dimensioni conservino la massima quantità di informazioni, permettendo questa riduzione senza una perdita catastrofica. In altre parole, troncare un vettore non significa scartare a caso un terzo del significato: mantieni il segnale centrale e perdi le sfumature, il che rimane perfettamente valido per una fase iniziale di filtraggio.

Scegliere una Dimensione

Usa i seguenti valori come linee guida in base al contesto del tuo progetto. Una ricerca ad alta precisione su un corpus modesto richiede impostazioni diverse rispetto a un indice eseguito su una macchina con risorse limitate:

# Raccomandazioni per caso d'uso
DIMENSIONS = {
    "high_precision_search": 3072,   # Qualità massima
    "general_use": 1536,             # Predefinito, buon compromesso
    "large_volume": 768,             # Compromesso archiviazione/qualità
    "prototype": 512,                # Sviluppo rapido
    "embedded": 256,                 # Vincoli di memoria stretti
}

Il Parametro output_dtype

Il tipo di output controlla la precisione e la dimensione dei valori. Mentre output_dimension riduce il numero di valori, output_dtype riduce il peso di ciascuno di essi. Queste due leve sono indipendenti e cumulative.

# Float (predefinito) - massima precisione
response_float = client.embeddings.create(
    model="codestral-embed",
    output_dtype="float",
    inputs=["def add(a, b): return a + b"],
)

# Int8 - 4 volte più compatto di float32
response_int8 = client.embeddings.create(
    model="codestral-embed",
    output_dtype="int8",
    inputs=["def add(a, b): return a + b"],
)

# Binary - estremamente compatto
response_binary = client.embeddings.create(
    model="codestral-embed",
    output_dtype="binary",
    inputs=["def add(a, b): return a + b"],
)

Combinare Dimensione e Dtype

Puoi combinare entrambi i parametri per un controllo preciso. Le due chiamate seguenti codificano la stessa query SQL e illustrano gli estremi dello spettro: la prima mira a un indice leggero interrogato continuamente, mentre la seconda serve una ricerca di riferimento dove ogni punto di precisione conta.

# Compatto e veloce: 512 dimensioni in int8
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=512,
    output_dtype="int8",
    inputs=["SELECT * FROM users WHERE active = true"],
)

# Alta qualità: 3072 dimensioni in float
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=3072,
    output_dtype="float",
    inputs=["SELECT * FROM users WHERE active = true"],
)

Ecco una regola da stabilire subito: i vettori nel tuo indice e i vettori nelle tue query devono condividere esattamente gli stessi parametri. Codificare un corpus a 512 dimensioni e poi interrogare a 1536 non produce solo risultati scarsi; genera un errore o punteggi privi di senso.

Linguaggi Supportati

codestral-embed funziona con tutti i linguaggi di programmazione comuni. Sul lato applicativo, copre Python, JavaScript e TypeScript, nonché Java, C, C++, C#, Go e Rust. Per dati e presentazione, il modello gestisce SQL, HTML e CSS. Per tooling e configurazione, gestisce Shell/Bash, YAML e JSON—e molti altri, effettivamente qualsiasi linguaggio presente nei dati di addestramento. In pratica, un repository tipico che mescola Python, template HTML, migrazioni SQL e manifesti YAML può essere indicizzato completamente con un singolo modello.

Punti chiave

  • codestral-embed è ottimizzato per il codice sorgente, non per il linguaggio naturale
  • 1536 dimensioni di default, scalabili fino a 3072
  • Il parametro output_dimension ti permette di ridurre la dimensione del vettore
  • Il parametro output_dtype controlla la precisione (float, int8, binary, ecc.)
  • Il modello comprende la semantica del codice indipendentemente dal linguaggio