Ir al contenido principal
Español— Elegir un idioma
Menú

El modelo codestral-embed

Lección 5 de 18 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Incrustaciones especializadas para código
  2. Especificaciones técnicas
  3. Uso básico
  4. El parámetro output_dimension
  5. El parámetro output_dtype
  6. Combinación de dimensión y dtype
  7. Lenguajes admitidos
  8. Puntos clave

Incrustaciones especializadas para código

Mientras que mistral-embed está diseñado para lenguaje natural, codestral-embed es un modelo de incrustaciones optimizado específicamente para lenguajes de programación. Comprende la sintaxis, la semántica y la lógica del código, lo que lo hace significativamente superior a un modelo de texto genérico para cualquier tarea que implique código fuente.

Puedes observar la diferencia en un caso sencillo. Dos funciones que hacen lo mismo, una escrita con un bucle for y la otra utilizando comprensión de listas, apenas comparten tokens. Un modelo de texto las ve como dos bloques distintos de puntuación; un modelo entrenado con código las agrupa porque ha aprendido que estas dos formas expresan la misma intención.

Especificaciones técnicas

El modelo codestral-embed difiere de mistral-embed en varios aspectos clave:

Característicacodestral-embedmistral-embed
Dimensiones predeterminadas15361024
Dimensiones máximas3072 (el doble de las predeterminadas)—
Tipos de salidafloat, int8, uint8, binary, ubinary—
OptimizaciónEntrenado con código fuente multilenguajeLenguaje natural

Esta flexibilidad en dimensiones y tipos de salida es lo que realmente marca la diferencia entre ambos modelos en la práctica. Un índice de código alcanza rápidamente el millón de vectores, y poder reducir su peso a la cuarta parte cambia drásticamente la factura de infraestructura.

Uso básico

La API es idéntica a la de mistral-embed, salvo por el nombre del modelo codestral-embed. Nada más cambia en tu código de llamada, lo que te permite ejecutar ambos modelos en el mismo proyecto ajustando únicamente un parámetro.

from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Codificar fragmentos de código
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

Observa que los tres fragmentos implementan la misma lógica (Fibonacci) en tres lenguajes diferentes. Sus incrustaciones estarán muy próximas a pesar de las diferencias sintácticas. Esta propiedad habilita la búsqueda entre lenguajes: en una base de código políglota, un desarrollador de Python puede encontrar la implementación en Java que necesita sin saber ni una palabra de Java.

El parámetro output_dimension

Puedes reducir el tamaño del vector para ahorrar espacio de almacenamiento, a costa de una ligera pérdida de precisión:

# Dimensiones reducidas (512 en lugar de 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

Las primeras dimensiones del vector son las más informativas. El modelo está diseñado de modo que las primeras n dimensiones retengan la máxima cantidad de información, permitiendo esta reducción sin una pérdida catastrófica. En otras palabras, truncar un vector no es como tirar al azar un tercio del significado: conservas la señal principal y pierdes el matiz, lo cual sigue siendo perfectamente viable para una pasada de filtrado inicial.

Elección de la dimensión

Utiliza los siguientes valores como directrices según el contexto de tu proyecto. Una búsqueda de alta precisión sobre un corpus modesto requiere configuraciones distintas a las de un índice que se ejecuta en una máquina con recursos limitados:

# Recomendaciones por caso de uso
DIMENSIONS = {
    "high_precision_search": 3072,   # Máxima calidad
    "general_use": 1536,             # Predeterminado, buen compromiso
    "large_volume": 768,             # Compromiso almacenamiento/calidad
    "prototype": 512,                # Desarrollo rápido
    "embedded": 256,                 # Restricciones estrictas de memoria
}

El parámetro output_dtype

El tipo de salida controla la precisión y el tamaño de los valores. Mientras que output_dimension reduce el número de valores, output_dtype reduce el peso de cada uno de ellos. Estas dos palancas son independientes y acumulativas.

# Float (predeterminado) - máxima precisión
response_float = client.embeddings.create(
    model="codestral-embed",
    output_dtype="float",
    inputs=["def add(a, b): return a + b"],
)

# Int8 - 4 veces más compacto que float32
response_int8 = client.embeddings.create(
    model="codestral-embed",
    output_dtype="int8",
    inputs=["def add(a, b): return a + b"],
)

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

Combinación de dimensión y dtype

Puedes combinar ambos parámetros para un control preciso. Las dos llamadas siguientes codifican la misma consulta SQL e ilustran los extremos del espectro: la primera apunta a un índice ligero consultado continuamente, mientras que la segunda sirve para una búsqueda de referencia donde cada punto de precisión cuenta.

# Compacto y rápido: 512 dimensiones en int8
response = client.embeddings.create(
    model="codestral-embed",
    output_dimension=512,
    output_dtype="int8",
    inputs=["SELECT * FROM users WHERE active = true"],
)

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

Establece ahora esta regla: los vectores de tu índice y los vectores de tus consultas deben compartir exactamente los mismos parámetros. Codificar un corpus en 512 dimensiones y luego consultar en 1536 no solo produce resultados pobres, sino que genera un error o puntuaciones sin sentido.

Lenguajes admitidos

codestral-embed funciona con todos los lenguajes de programación comunes. En el lado de la aplicación, cubre Python, JavaScript y TypeScript, así como Java, C, C++, C#, Go y Rust. Para datos y presentación, el modelo gestiona SQL, HTML y CSS. Para herramientas y configuración, maneja Shell/Bash, YAML y JSON, y muchos otros; efectivamente, cualquier lenguaje presente en los datos de entrenamiento. En la práctica, un repositorio típico que mezcla Python, plantillas HTML, migraciones SQL y manifiestos YAML puede indexarse por completo con un único modelo.

Puntos clave

  • codestral-embed está optimizado para código fuente, no para lenguaje natural
  • 1536 dimensiones por defecto, escalable hasta 3072
  • El parámetro output_dimension permite reducir el tamaño del vector
  • El parámetro output_dtype controla la precisión (float, int8, binary, etc.)
  • El modelo comprende la semántica del código independientemente del lenguaje