El modelo mistral-embed
En esta página
Visión general de mistral-embed
mistral-embed es el modelo de embeddings de texto de Mistral AI. Transforma cualquier texto en un vector de 1024 dimensiones, independientemente de la longitud de entrada: ya sea una frase corta o un párrafo entero, el vector de salida siempre tiene el mismo tamaño. Esta dimensionalidad fija no es un detalle menor: te permite indexar tanto el título de un producto como su descripción completa en el mismo espacio vectorial y compararlos directamente sin necesidad de ningún procesamiento especial para conciliar formatos distintos.
Este modelo está optimizado para tareas de búsqueda semántica, clasificación y agrupamiento (clustering) sobre texto en lenguaje natural (artículos, documentos, conversaciones, etc.). Úsalo para indexar una base de conocimientos, preguntas frecuentes (FAQ), transcripciones de reuniones o una década de tickets de soporte.
Configuración e instalación
Antes de llamar a la API, instala el SDK de Python de Mistral y configura tu clave de API:
# Instalación
# pip install mistralai
import os
from mistralai.client import Mistral
# Inicializar el cliente
api_key = os.environ.get("MISTRAL_API_KEY")
client = Mistral(api_key=api_key)
Obtén tu clave de API desde la consola de Mistral. Guárdala en una variable de entorno para mantenerla fuera de tu código. Leerla mediante os.environ.get no es solo una cuestión de higiene teórica: evita que tu clave acabe en una instantánea del historial de Git el día que hagas público tu proyecto.
Generación de embeddings
La llamada a la API es sencilla: pasa una lista de textos y recupera los vectores correspondientes. Ten en cuenta que, incluso para un único texto, la entrada debe ser una lista; la API funciona siempre por lotes, lo cual compensa en cuanto crece tu corpus.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
# Generar embeddings para uno o más textos
response = client.embeddings.create(
model="mistral-embed",
inputs=[
"Los embeddings capturan el significado semántico.",
"Mistral AI ofrece modelos de alto rendimiento.",
"RAG mejora la calidad de las respuestas."
],
)
# Acceder a los vectores
for i, data in enumerate(response.data):
print(f"Texto {i+1}: vector de {len(data.embedding)} dimensiones")
print(f" Primeros elementos: {data.embedding[:5]}")
Salida típica:
Texto 1: vector de 1024 dimensiones
Primeros elementos: [0.0234, -0.1567, 0.0891, 0.0123, -0.0456]
Texto 2: vector de 1024 dimensiones
Primeros elementos: [0.0189, -0.1234, 0.0678, 0.0345, -0.0567]
Texto 3: vector de 1024 dimensiones
Primeros elementos: [0.0312, -0.1456, 0.0789, 0.0234, -0.0345]
Estructura de la respuesta de la API
La respuesta contiene algo más que vectores. También indica qué modelo se ha usado realmente y cuántos tokens se han consumido: dos datos que querrás registrar una vez que la codificación se ejecute en producción y alguien tenga que explicar la factura. Presta especial atención al campo index: indica la posición del texto en la lista que enviaste, lo que te permite mapear cada vector de vuelta a su documento de origen.
response = client.embeddings.create(
model="mistral-embed",
inputs=["Texto de ejemplo para codificar."],
)
# Objeto de respuesta
print(response.model) # "mistral-embed"
print(response.usage) # tokens consumidos
# Datos del embedding
embedding_data = response.data[0]
print(embedding_data.index) # 0 (posición en la lista de inputs)
print(len(embedding_data.embedding)) # 1024
print(type(embedding_data.embedding)) # list[float]
Ejemplo completo: codificar y almacenar
Aquí tienes un flujo típico para codificar un corpus de documentos y preparar los vectores para una búsqueda posterior. El paso crítico es el cambio a NumPy: mientras tus vectores son listas de Python, cada cálculo de similitud ocurre elemento a elemento; una vez construyes una matriz, una única operación compara la consulta contra todo el corpus.
import numpy as np
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
# Corpus de documentos
documents = [
"Mistral AI es una empresa francesa de inteligencia artificial.",
"RAG combina la recuperación de información y la generación de texto.",
"Los embeddings permiten la búsqueda semántica.",
"Python es el lenguaje más utilizado en ciencia de datos.",
"FAISS es una biblioteca de búsqueda vectorial de Meta.",
]
# Codificar todos los documentos
response = client.embeddings.create(
model="mistral-embed",
inputs=documents,
)
# Convertir a una matriz NumPy para los cálculos
embeddings_matrix = np.array([d.embedding for d in response.data])
print(f"Matriz de embeddings: {embeddings_matrix.shape}")
# Matriz de embeddings: (5, 1024)
# Guardar para uso posterior
np.save("document_embeddings.npy", embeddings_matrix)
Guardar como .npy evita pagar por volver a codificar cada vez que se reinicia tu aplicación. En un corpus de varios miles de documentos, esto marca la diferencia entre un inicio instantáneo y varios minutos de llamadas a la API facturadas.
Límites y buenas prácticas
Cuatro factores determinan la calidad de tus resultados. Primero, la longitud máxima: el modelo trunca los textos demasiado largos, y el truncamiento es silencioso; un informe de cuarenta páginas codificado en un solo bloque representará efectivamente solo su comienzo. Prefiere fragmentos de 512 a 2048 tokens, tal como se cubre en la lección sobre fragmentación (chunking).
Segundo, a diferencia de otras APIs, mistral-embed no distingue entre query y document: no hay tipo de entrada, simplemente pasas el texto. En la práctica, las preguntas de los usuarios y los documentos indexados pasan por la misma llamada con los mismos parámetros, lo que simplifica tu código de búsqueda.
El tercer punto es el coste: los embeddings se facturan por token. Codificar mil documentos uno a uno cuesta lo mismo en tokens que codificarlos en lote, pero multiplica los viajes de ida y vuelta de red y el tiempo de procesamiento; optimizas agrupando las llamadas, tema que trata la siguiente lección sobre procesamiento por lotes. Por último, el determinismo juega a tu favor: para el mismo texto, el modelo devuelve siempre el mismo vector. Por tanto, puedes cachear los embeddings mediante el hash del texto y volver a codificar solo lo que haya cambiado realmente entre dos versiones de un documento.
Puntos clave
- mistral-embed produce vectores de 1024 dimensiones para cualquier texto
- La API acepta una lista de entradas y devuelve los vectores correspondientes
- Los vectores son listas de flotantes, fácilmente convertibles a arrays de NumPy
- Almacena tus embeddings como una matriz de NumPy para cálculos de similitud
- Recuerda dividir los textos largos antes de codificarlos