Ver todos los artículos
EmbeddingsRAGOllamaEspañolBenchmarks

El mejor modelo de embeddings local para español: guía

JG
Jacobo González Jaspe
|

Revisado:

Ilustración abstracta: dos caminos de luz que se separan; uno tenue y blanco, otro ámbar. Desde la spark
Ilustración generada con IA en nuestra máquina.
Este artículo también está en inglés:Best Local Embedding Model for Spanish: Measured Guide

Al terminar esta guía sabrás cómo elegir un modelo de embeddings para documentos en español: qué leer en la ficha de un modelo, qué te dice y qué no un benchmark público, y cómo lanzar la comparación con tus archivos. Nosotros la hicimos con los tres modelos más usados con Ollama. Los tres caben en un portátil: el más grande ocupó 0,68 GB cargado.

Qué necesitas

  • Ollama y unos 2 GB de disco para los tres modelos.
  • Python 3 con requests.
  • Tus propias preguntas, cada una con el documento que la responde. Sin ellas comparas modelos sobre el texto de otro.

Qué mirar antes de descargar nada

1. Los idiomas con los que se entrenó. Es el primer filtro. Un modelo entrenado en inglés también devuelve vectores para un texto en español; son peores y nada te avisa.

2. Qué dicen los benchmarks públicos y qué se dejan fuera. MTEB es el benchmark público de referencia y su edición multilingüe cubre más de 500 tareas en más de 250 idiomas. Usa su clasificación para hacer una lista corta. Una nota de esa clasificación es una media de muchas tareas e idiomas, con datos públicos. No conoce tu vocabulario, ni la longitud de tus documentos, ni cómo pregunta tu equipo. Nuestra tabla de abajo tiene para ti el mismo límite: es nuestro texto, no el tuyo.

3. Las dimensiones. Cada vector se guarda en números de 32 bits: 1.024 dimensiones son 4 KB por fragmento y 768 son 3 KB, antes del índice. Es aritmética, no una medición: un millón de fragmentos son unos 4,1 GB o 3,1 GB. En nuestra prueba, más dimensiones no dieron mejor recuperación.

4. Cuánto texto cabe en una llamada. Un fragmento más largo que el límite del modelo pierde el final. El límite declarado y el que te llega pueden no coincidir; nos pasó con bge-m3 (más abajo).

5. Si necesita prefijo. Algunos modelos esperan una etiqueta delante de las preguntas y otra delante de los documentos.

6. La licencia. Decide si puedes distribuir el modelo dentro de un producto.

Los mismos seis puntos en nuestros tres modelos, según cada ficha el 15-11-2026:

bge-m3nomic-embed-text (v1.5)embeddinggemma
Idiomasmás de 100inglésmás de 100
Límite de entrada declarado8.192 tokens8.192 en la ficha; 2K en la versión de Ollama2K tokens
Dimensiones1.024768, recortables hasta 64768, recortables a 512, 256 o 128
Prefijoningunoobligatorioplantillas recomendadas
LicenciaMITApache 2.0Condiciones de uso de Gemma
Fuenteficha de BAAIficha de Nomic, página de Ollamaficha de Google

Dos notas sobre la tabla. Las condiciones de Gemma son un acuerdo propio de Google, no una licencia de código abierto: traen una política de usos prohibidos que debes trasladar si redistribuyes el modelo. Léelas antes de empaquetarlo. Y “multilingüe o solo español” es una elección real: existen modelos de español y bilingües, como jina-embeddings-v2-base-es (español e inglés, Apache 2.0 y 8.192 tokens, según su ficha). No medimos ninguno. Un modelo multilingüe cubre además los documentos en catalán, valenciano o inglés que aparecen en casi cualquier oficina española; tampoco probamos carpetas con varios idiomas.

Paso 1: descarga los tres modelos

bash
ollama pull bge-m3
ollama pull nomic-embed-text
ollama pull embeddinggemma
ollama list | grep -E "bge-m3|nomic|embeddinggemma"

Si tu Ollama dice que embeddinggemma no existe, actualízalo: su página en la biblioteca pide la v0.11.10 o posterior. Nosotros usamos la 0.34.0.

Paso 2: comprueba qué vas a guardar

bash
curl -s localhost:11434/api/embed -d '{"model": "bge-m3", "input": "¿Cuánto daba el Kit Digital?"}' \
  | python3 -c "import sys,json; print(len(json.load(sys.stdin)['embeddings'][0]))"
# 1024
ollama ps

El número es la dimensión de cada vector: 1024 en bge-m3 y 768 en los otros dos. ollama ps te enseña la memoria que ocupa cada modelo mientras está cargado.

Paso 3: dale a cada modelo su prefijo

Dos de los tres se entrenaron para ver una etiqueta delante del texto. bge-m3 toma el texto tal cual.

Python
PROMPTS = {
    "bge-m3": ("", ""),
    "nomic-embed-text": ("search_query: ", "search_document: "),
    "embeddinggemma": ("task: search result | query: ", "title: none | text: "),
}

El primero de cada par va delante de la pregunta y el segundo delante de cada fragmento. La ficha de Nomic dice que el texto debe llevar un prefijo de instrucción de tarea. Si te los saltas no se rompe nada; pierdes puntos, como enseña la tabla de abajo.

Paso 4: pasa las mismas preguntas por cada modelo

Escribe un questions.json con preguntas en las palabras de tu equipo y el archivo que responde cada una:

JSON
[{"q": "¿Cuánto me pagan por kilómetro si voy con mi coche?", "doc": "gastos"},
 {"q": "¿Dónde está el tóner?", "doc": "impresora"}]

Guarda esto como compare_embeddings.py. No necesita base de datos vectorial: tiene los vectores en memoria, que basta para unos miles de fragmentos.

Python
import json, os, sys, pathlib, requests

OLLAMA = os.environ.get("OLLAMA", "http://localhost:11434")
PROMPTS = {                                   # (prefijo de pregunta, prefijo de documento), de cada ficha
    "bge-m3": ("", ""),
    "nomic-embed-text": ("search_query: ", "search_document: "),
    "embeddinggemma": ("task: search result | query: ", "title: none | text: "),
}

def embed(model, texts):
    out = []
    for i in range(0, len(texts), 32):
        r = requests.post(f"{OLLAMA}/api/embed", json={"model": model, "input": texts[i:i + 32],
                                                       "truncate": False, "keep_alive": 0})
        r.raise_for_status()
        out += r.json()["embeddings"]
    return out

def chunks(text, size=1000):
    out, cur, n = [], [], 0
    for w in text.split():
        if cur and n + len(w) >= size:
            out.append(" ".join(cur)); cur, n = [], 0
        cur.append(w); n += len(w) + 1
    return out + [" ".join(cur)]

folder, questions = pathlib.Path(sys.argv[1]), json.load(open(sys.argv[2], encoding="utf-8"))
parts = [(f.stem, c) for f in sorted(folder.glob("*.md")) for c in chunks(f.read_text(encoding="utf-8"))]
print(f"{len(parts)} fragmentos, {len(questions)} preguntas")
for model, (q_prefix, d_prefix) in PROMPTS.items():
    docs = embed(model, [d_prefix + c for _, c in parts])
    hit1 = hit5 = rr = 0
    for item, qv in zip(questions, embed(model, [q_prefix + x["q"] for x in questions])):
        scored = sorted(((sum(a * b for a, b in zip(qv, dv)), d) for dv, (d, _) in zip(docs, parts)), reverse=True)
        ranking = list(dict.fromkeys(d for _, d in scored))            # cada documento, en su mejor fragmento
        rank = ranking.index(item["doc"]) + 1
        hit1 += rank == 1; hit5 += rank <= 5; rr += 1 / rank if rank <= 10 else 0
    n = len(questions)
    print(f"{model:18s} dim {len(docs[0]):4d}  hit@1 {hit1}/{n}  hit@5 {hit5}/{n}  MRR@10 {rr / n:.3f}")
bash
python3 compare_embeddings.py ./mis-documentos questions.json
# 6 fragmentos, 8 preguntas
# bge-m3             dim 1024  hit@1 8/8  hit@5 8/8  MRR@10 1.000
# nomic-embed-text   dim  768  hit@1 8/8  hit@5 8/8  MRR@10 1.000
# embeddinggemma     dim  768  hit@1 8/8  hit@5 8/8  MRR@10 1.000

Esa salida es real, del 15-11-2026, y es un aviso. Lanzamos el script sobre seis documentos cortos de oficina y ocho preguntas fáciles, y los tres modelos lo acertaron todo. Un conjunto tan pequeño y tan fácil no ordena nada. Escribe al menos 20 preguntas, incluye las incómodas y cuenta con que harán falta más. La ejecución está en rag-qdrant-walkthrough-2026-11-15.json.

Los tres números:

  • hit@1 y hit@5: preguntas cuyo documento correcto salió el primero, o entre los cinco primeros.
  • MRR: la media de 1 / posición del primer documento correcto, así que premia ponerlo el primero.

El script usa los vectores tal como los devuelve Ollama, ya normalizados a longitud 1, así que un producto escalar es la similitud coseno. Para ver qué hace esa puntuación, prueba nuestro ejercicio de similitud coseno. Cómo escribir las preguntas y cómo separar una mejora del ruido está en Evalúa tu RAG con 54 preguntas.

Qué medimos

Medido el 2-11-2026. Los tres modelos en Ollama 0.34.0, en nuestra segunda NVIDIA DGX Spark (GB10, 128 GB), uno cargado cada vez. Qdrant 1.18.2 en la primera Spark. Corpus: 50 de nuestros artículos publicados en español (501.917 caracteres) y 60 preguntas escritas a mano con su documento correcto, sin respuestas de referencia. Archivo bruto: rag-embeddings-es-2026-11-02.json. El comando, de nuestro repositorio interno:

bash
python3 scripts/bench/rag_embeddings_es.py --ollama http://<second-box>:11434 \
  --models bge-m3,nomic-embed-text,embeddinggemma --chunks 500,1000,2000 \
  --out docs/measurements/rag-embeddings-es-2026-11-02.json

Encontrar documentos en español (fragmentos de 1.000 caracteres, 15 % de solape, prefijos de la ficha):

Modelohit@1hit@5MRR
bge-m378,3 %96,7 %0,862
nomic-embed-text78,3 %93,3 %0,841
embeddinggemma83,3 %100 %0,910

Lo que cuesta cada uno (velocidad: los 610 fragmentos del conjunto de 1.000 caracteres en lotes de 32, tras una llamada de calentamiento; tiempo por pregunta: mediana de las 60, enviadas desde la primera máquina):

ModeloParámetrosDimensionesArchivoCargado (ollama ps)Contexto declaradoFragmentos por segundoUna pregunta
bge-m3567 M1.0241,16 GB0,66 GB8.192 tokens58,928 ms
nomic-embed-text137 M7680,27 GB0,32 GB2.048 tokens133,17 ms
embeddinggemma308 M7680,62 GB0,68 GB2.048 tokens95,123 ms

MRR según el tamaño del fragmento (hit@5 entre paréntesis):

Modelo500 caracteres1.000 caracteres2.000 caracteres
bge-m30,885 (96,7 %)0,862 (96,7 %)0,895 (100 %)
nomic-embed-text0,798 (91,7 %)0,841 (93,3 %)0,790 (88,3 %)
embeddinggemma0,884 (95,0 %)0,910 (100 %)0,913 (98,3 %)

Sin los prefijos (1.000 caracteres): nomic-embed-text bajó de 0,841 a 0,804 de MRR y del 78,3 % al 73,3 % de hit@1; embeddinggemma bajó de 0,910 a 0,889 de MRR y del 100 % al 96,7 % de hit@5.

Tres cosas que dicen las tablas.

Los dos modelos multilingües van delante y van juntos. Con los tres tamaños, embeddinggemma promedió 0,902 de MRR y bge-m3 0,880. Los comparamos pregunta a pregunta. En el primer puesto y con fragmentos de 1.000 caracteres, embeddinggemma acertó donde bge-m3 falló 6 veces, y al revés pasó 3 veces: la prueba de signos da p = 0,51. Contando cualquier cambio de posición con ese tamaño, embeddinggemma colocó el documento correcto más arriba en 12 preguntas y más abajo en 3 (p = 0,035). Con 500 caracteres fueron 5 más arriba y 6 más abajo, y con 2.000 fueron 6 y 5. Que una comparación de seis baje de 0,05 no da un ganador. El margen del 95 % sobre un hit@5 cercano al 97 % es de unos ±4,5 puntos.

nomic-embed-text es el de inglés. Su ficha indica inglés como idioma y quedó detrás con todos los tamaños, peor con fragmentos largos. También fue con diferencia el más rápido: 133 fragmentos por segundo, 2,3 veces bge-m3, con el archivo más pequeño.

A este tamaño la velocidad casi nunca decide. Nuestro corpus entero tardó 10,4 segundos con bge-m3 y 4,6 con nomic-embed-text. Una pregunta tardó de 7 a 28 ms, contando el viaje entre nuestras dos máquinas. La velocidad de indexado empieza a pesar con cientos de miles de fragmentos, o en una CPU.

Un conjunto más difícil, para situarse. El 15-11-2026 pasamos solo bge-m3 por el texto en español del Reglamento de IA: 761 fragmentos y 54 preguntas ligadas a pasajes exactos. Puso el pasaje correcto el primero en 41 de 54 (MRR 0,81). Según la redacción, fueron 17 de 18 en las preguntas con los términos de la ley y 8 de 18 en las escritas con palabras de la calle. Un reranker de tipo cross-encoder sobre los 25 primeros subió el primer puesto a 44 de 54 (MRR 0,86), algo que la prueba de signos no distingue del ruido (p = 0,51). No pasamos ningún otro modelo de embeddings por ese conjunto. Archivo bruto: reranker-es-legal-2026-11-15.json.

Qué cambia cuando cambias de modelo

Todo lo que hay en el índice. Los vectores de dos modelos viven en espacios distintos aunque la dimensión coincida, así que una pregunta vectorizada con el modelo nuevo no puede buscar entre fragmentos vectorizados con el viejo.

  1. Vuelve a vectorizar todos los fragmentos con el modelo nuevo y sus prefijos. A nuestras velocidades, 610 fragmentos tardaron de 4,6 a 10,4 segundos, así que en una oficina pequeña son minutos.
  2. Crea una colección nueva. Una base vectorial fija la dimensión al crear la colección. Enviar vectores de 768 dimensiones a nuestra colección de Qdrant de 1.024 devolvió Wrong input: Vector dimension error: expected dim: 1024, got 768.
  3. Vectoriza las preguntas con el mismo modelo. La guía de embeddings de Ollama pide usar un solo modelo para indexar y para consultar.
  4. Pasa tu archivo de preguntas por los dos antes de mover a nadie, y después cambia. El cambio de alias que lo hace sin parar el servicio está en RAG local con Qdrant y bge-m3.

Cambiar el tamaño del fragmento, los prefijos o el valor de dimensions obliga al mismo reindexado completo.

Lo que no te dice la ficha técnica

  • El límite de contexto corta sin avisar. El /api/embed de Ollama recorta por defecto lo que sobra en lugar de fallar. Lo comprobamos el 2-11-2026 con embeddinggemma: 5.000 palabras pasaron sin queja, y solo con "truncate": false devolvió “the input length exceeds the context length”. Nuestros fragmentos de 2.000 caracteres rondaban los 600 tokens según el modelo de 7B, muy por debajo.
  • Los 8.192 tokens de bge-m3 no llegaron por defecto. El 15-11-2026, con las opciones por defecto en Ollama 0.34.0, bge-m3 aceptó 2.048 tokens y rechazó 2.049. Enviar num_ctx: 8192 no cambió nada. Con "options": {"num_ctx": 8192, "num_batch": 8192} pasó una entrada de 3.002 tokens. No averiguamos la causa ni medimos la recuperación con fragmentos tan largos.
  • Ollama acorta los vectores de cualquier modelo. La referencia de embed tiene un campo dimensions. Pedimos 256 y los tres modelos devolvieron 256 números con longitud 1,0, bge-m3 incluido. embeddinggemma y nomic-embed-text se entrenaron para que sus vectores se puedan recortar así, y sus fichas dan los tamaños. La ficha de bge-m3 no da ninguno. No medimos la recuperación con ningún tamaño reducido.
  • Tamaño cargado no es tamaño de archivo. ollama ps dio 0,66 GB para bge-m3 aunque el archivo pesa 1,16 GB. Damos lo que dice Ollama y no investigamos más.
  • Las preguntas deciden la clasificación. Nuestras 60 las escribió una persona que había leído los artículos. Con tus documentos y las palabras de tu equipo, el orden puede cambiar.

Otros modelos que no medimos

Todos los datos salen de las páginas enlazadas, el 15-11-2026. Ninguno de los tres corrió en nuestras máquinas.

ModeloQué dice su páginaEn la biblioteca de Ollama
qwen3-embeddingmás de 100 idiomas; tres tamaños, el menor un archivo de 639 MBsí
multilingual-e5-largeMIT, 1.024 dimensiones, entrada cortada a 512 tokens, necesita los prefijos query: y passage: no comprobado
jina-embeddings-v2-base-esespañol e inglés, Apache 2.0, 8.192 tokensno comprobado

Si alguno está en tu lista corta, añádelo a PROMPTS en el script con los prefijos de su ficha y pasa tus preguntas.

Veredicto

  • Documentos en español, fragmentos de 500 a 2.000 caracteres: embeddinggemma o bge-m3. embeddinggemma sacó los mejores resultados en nuestro conjunto con 768 dimensiones y 0,68 GB cargado; comprueba que las condiciones de Gemma encajan con tu uso.
  • La licencia tiene que ser MIT sin más: bge-m3.
  • Fragmentos de más de 2.048 tokens: ninguno de los tres los aceptó por defecto en nuestro Ollama. bge-m3 puede con las dos opciones de arriba; pruébalo antes con tus documentos.
  • Sáltate nomic-embed-text para español salvo que la velocidad de indexado sea tu cuello de botella; si te lo quedas, usa sus prefijos.

Cuándo no hacerlo

Si ya indexas con uno de estos y tu equipo encuentra lo que busca, cambiar cuesta reindexar todo y gana unos pocos puntos como mucho. Mide antes con 20 preguntas tuyas. Y si tus documentos son sobre todo tablas o PDF escaneados, arregla la extracción de texto antes de comparar modelos: ningún modelo de embeddings encuentra el texto que la conversión del PDF perdió.

Preguntas frecuentes

¿Necesito un modelo entrenado solo en español? Con lo que medimos, no. Los dos modelos multilingües encontraron el documento correcto entre los cinco primeros en el 95 % al 100 % de nuestras preguntas en español. No medimos ningún modelo solo de español, así que no podemos decir que no lo haría mejor.

¿Más dimensiones es mejor? Aquí no. Los vectores de 768 dimensiones de embeddinggemma puntuaron tan bien como los de 1.024 de bge-m3 en nuestro conjunto. Las dimensiones marcan lo que ocupa el índice, no la calidad.

¿Puedo conservar mis vectores y añadir otros de un modelo distinto? No. Las puntuaciones entre vectores de modelos distintos no significan nada. Reindexa todo.

¿El primero de la clasificación gana con mis documentos? Puede que no. Una clasificación promedia datos públicos. Úsala para la lista corta y decide con tus preguntas.

¿Cuántas preguntas necesito? Veinte detectan un montaje roto. Con 60 no pudimos separar los dos mejores modelos. La aritmética del tamaño de muestra está en nuestra guía de evaluación.

¿Funciona sin GPU? Estos modelos son pequeños (de 0,32 a 0,68 GB cargados), pero todas las velocidades de este artículo se midieron en una GPU. No tenemos números en CPU.

Próximos pasos

Trabaja con nosotros

Podemos hacer esta comparación con tus documentos reales antes de recomendar nada. Una llamada gratuita de 15 minutos basta para saber si tiene sentido en tu caso: reserva la llamada o mira cómo trabajamos en consultoría.

Diagrama
Compartir: LinkedIn X
Veredicto semanal

Recibe las guías nuevas antes que nadie

Suscríbete y te avisamos cuando publiquemos guías, plantillas y workflows nuevos. Un correo a la semana, sin spam.

Ya publicados: 101 guías y 25 plantillas. Todo gratis y sin registro.

Bonus: el kit de inicio de IA local en PDF al suscribirte
1x por semana Sin spam Cancela cuando quieras

Ver qué recibes