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

Codestral Embed: Incrustaciones de código

Lección 11 de 14 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Codestral Embed: Búsqueda semántica para código
  2. ¿Qué es una incrustación de código?
  3. Especificaciones técnicas
  4. Uso de la API
  5. Búsqueda semántica en una base de código
  6. Casos de uso avanzados
  7. Puntos clave

Codestral Embed: Búsqueda semántica para código

Generar y completar código no es suficiente. También necesitas encontrar el archivo en un repositorio de cientos que ya resuelve tu problema. Esa es la función de la tercera herramienta especializada de Mistral AI: Codestral Embed (v25.05). Este modelo de incrustaciones convierte fragmentos de código en vectores numéricos, lo que permite realizar una búsqueda semántica en los repositorios.

¿Qué es una incrustación de código?

Una incrustación es una representación vectorial densa de texto o de un fragmento de código. La propiedad clave es sencilla: dos fragmentos semánticamente similares generan vectores que están próximos en el espacio vectorial, aunque su sintaxis no se parezca en nada. Observa las dos funciones siguientes. Tienen nombres distintos, nombres de variables diferentes e implementaciones diversas.

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

Una búsqueda con grep nunca encontraría la segunda función partiendo de la primera. Codestral Embed, en cambio, genera vectores cercanos para ambas porque resuelven el mismo problema.

Especificaciones técnicas

El ID del modelo es codestral-embed-latest (v25.05). Se llama mediante el punto de conexión /v1/embeddings. Gestiona código fuente en todos los lenguajes compatibles con Codestral. Su característica destacada son las dimensiones configurables, que van desde 1536 hasta 3072. La configuración de 1536 dimensiones ofrece una buena relación calidad-costo y sirve para la mayoría de los casos de uso. La configuración de 3072 dimensiones apunta a la máxima calidad para las búsquedas más exigentes. La regla es constante: más dimensiones implican mayor precisión semántica, pero también costes de almacenamiento más altos y más cómputo para cada comparación. Para un repositorio de tamaño medio, empieza con 1536 y solo aumenta si los resultados parecen imprecisos.

Uso de la API

La llamada básica se parece a la del punto de conexión de chat: instancia el cliente, pasa un fragmento y obtén un vector de vuelta.

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

Ten en cuenta que el parámetro inputs es una lista. Este detalle importa: para indexar un repositorio entero, envías varios fragmentos en una única solicitud en lugar de una solicitud por archivo. En un repositorio real, la diferencia se traduce en minutos ahorrados.

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]

Búsqueda semántica en una base de código

El caso de uso principal se deriva directamente de esto: en lugar de buscar por palabras clave, buscas por intención. El flujo tiene dos pasos. Primero, indexa la base de código una vez, adjuntando una incrustación a cada archivo. Luego, transforma la consulta en un vector y ordena los archivos por similitud del coseno, la medida estándar de proximidad entre dos vectores.

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íjate en la consulta final: “function that validates an email address”. No contiene identificadores del proyecto, ni nombres de archivo, ni palabras clave de código. Esa es toda la diferencia respecto a la búsqueda de texto, y hace que la herramienta sea usable incluso para alguien nuevo en el repositorio.

Casos de uso avanzados

La combinación más potente encadena Codestral Embed con Codestral o con un modelo de propósito general como Mistral Small 4. Este es el patrón RAG (Generación Aumentada por Recuperación) aplicado al código. Primero recuperas los archivos relevantes, los inyectas en el mensaje del sistema y luego planteas tu pregunta. El modelo responde entonces basándose en tu base de código, no solo en su conocimiento general del lenguaje.

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

El mismo índice sirve para una tarea menos llamativa pero muy valiosa: la detección de código duplicado. Comparando cada par de funciones y marcando aquellas con una similitud superior a un umbral, obtienes una lista de candidatos para refactorizar que nadie en el equipo había detectado.

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

Debes ajustar el umbral de 0,90 con tu propio código antes de sacar conclusiones. Si lo pones demasiado bajo, marcará funciones que se parecen pero hacen cosas distintas. Si lo pones demasiado alto, solo captará copias literales, esas que ya habrías encontrado de todos modos.

Puntos clave

  • Codestral Embed (v25.05) convierte código en vectores para búsqueda semántica
  • Admite de 1536 a 3072 dimensiones según tus necesidades de precisión
  • La búsqueda semántica permite buscar por intención, no por palabras clave
  • El patrón RAG (recuperación + generación) es el caso de uso más potente
  • Las incrustaciones también permiten detectar duplicados y agrupar código