~/ / Artículos de IA / LLM locales en un VPS / Embeddings con Ollama: lo básico para búsqueda y RAG

Embeddings con Ollama: lo básico para búsqueda y RAG

Una búsqueda que encuentra pasajes por su significado y el RAG, en el que un modelo de chat responde a partir de tus propios documentos, empiezan los dos con embeddings. Ollama puede crearlos en el mismo servidor que ejecuta tu modelo de chat. Este artículo explica la petición, los modelos que lista la biblioteca de Ollama, los ajustes que cambian el resultado y cómo comparar los vectores, usando solo lo que dicen la documentación y las páginas de la biblioteca de Ollama. Dos herramientas de esta página te permiten probar los pasos en el navegador.

Publicado: 2026-11-04 · 5 min de lectura · Datos comprobados con la documentación y las páginas de la biblioteca de Ollama el 2026-11-04. Los modelos y los campos cambian, así que consulta las páginas actuales antes de confiar en ellos.

Qué es un embedding

La página de embeddings de Ollama dice que los embeddings convierten texto en vectores numéricos que se pueden guardar en una base de datos vectorial, buscar con la similitud del coseno o usar en pipelines de RAG. La longitud del vector depende del modelo; la página indica que suele ir de 384 a 1024 dimensiones.

Una búsqueda crea el embedding de la pregunta con el mismo modelo y busca los vectores guardados que más se parecen a él.

Crear embeddings con /api/embed

El endpoint es POST /api/embed. La petición necesita model e input, y input puede ser una sola cadena o un array de cadenas. Con un array, la respuesta contiene un vector por cada cadena en el campo embeddings, en el mismo orden, así que un lote de pasajes necesita una sola petición.

La documentación también muestra la línea de comandos: ollama run embeddinggemma "Hello world" imprime el vector como un array JSON, y el texto se puede pasar por una tubería con echo.

Campo	Lo que dice la referencia de la API
model	Obligatorio. El nombre del modelo.
input	Obligatorio. Un texto o un array de textos.
truncate	Por defecto true: las entradas que superan la ventana de contexto se truncan. Si es false, se devuelve un error.
dimensions	El número de dimensiones para las que se generan los embeddings.
keep_alive	Cuánto tiempo permanece cargado el modelo.
options	Opciones de ejecución, como num_ctx para la longitud del contexto.

Ollama también tiene un endpoint compatible con OpenAI, /v1/embeddings. Su documentación indica como compatibles model, input como cadena o array de cadenas, encoding format y dimensions, y como no compatibles los arrays de tokens y user.

Modelos de embeddings en la biblioteca de Ollama

La biblioteca de Ollama tiene una categoría de embeddings. La tabla muestra seis de los modelos que aparecen allí, con el tamaño y la ventana de contexto que la página de etiquetas de cada modelo indica para la etiqueta latest. Cuatro de los seis pesan menos de 1GB.

Modelo	Tamaño de la etiqueta latest	Ventana de contexto
all-minilm	46MB	512
nomic-embed-text	274MB	2K
embeddinggemma	622MB	2K
mxbai-embed-large	670MB	512
bge-m3	1.2GB	8K
qwen3-embedding	4.7GB	40K

Otras etiquetas cambian el tamaño: por ejemplo, la biblioteca lista qwen3-embedding:0.6b con 639MB y una ventana de contexto de 32K, y embeddinggemma:300m-qat-q4_0 con 239MB. No comparamos la calidad de estos modelos; las páginas de la biblioteca no los clasifican. Al probar all-minilm en Ollama 0.40.11, ollama show mostró una longitud de contexto de 512 y un parámetro num_ctx de 256, y una entrada larga se cortó en 256 tokens. Comprueba ollama show para el modelo que uses.

El texto largo se corta sin ningún error

La ventana de contexto se cuenta en tokens. Como truncate vale true por defecto, un texto más largo que la ventana de contexto del modelo se acorta y aun así devuelve un vector, sin ningún error. Un documento largo enviado como una sola entrada puede perder su final de este modo.

Hay dos cosas que ayudan. Dividir los documentos largos en fragmentos (chunks) más pequeños y crear el embedding de cada uno, lo que además permite que una búsqueda devuelva la parte que responde a la pregunta. Y enviar truncate con el valor false, para que Ollama devuelva un error en lugar de acortar un fragmento que sigue siendo demasiado largo.

El divisor de aquí abajo parte el texto por párrafos, líneas, frases y espacios, con un solapamiento (overlap), y construye una única petición /api/embed para todos los fragmentos. Cuenta caracteres, no tokens, porque cada modelo tiene su propio tokenizador, así que deja un margen por debajo de la ventana de contexto.

Pruébalo: RAG Text Chunker

Texto que dividirSepara los párrafos con una línea en blanco

Longitud máxima del fragmento (caracteres)De 50 a 20000Solapamiento (caracteres)0 para ninguno. Debe ser menor que la longitud máximaModelo de embeddingsEl mismo modelo que usarás para la búsquedaDirección de Ollamahttp://localhost:11434

Fallar en lugar de truncar ("truncate": false)Por defecto, Ollama trunca la entrada más larga que la ventana de contexto del modelo.

Las longitudes están en caracteres. La ventana de contexto del modelo está en tokens, y cuántos tokens usa un texto depende del modelo, así que deja un margen.

Comando curl

Ejecútalo en una máquina que pueda llegar a Ollama. La respuesta tiene un vector por fragmento, en este orden.

curl http://localhost:11434/api/embed -d '{
  "model": "embeddinggemma",
  "input": [
    "Embeddings turn text into numeric vectors. You can store them in a vector database and search them with cosine similarity, or use them in a RAG pipeline.\n\nThe length of each vector depends on the embedding model. Use the same model when you index your documents and when you embed a question.\n\n",
    "Ollama'\''s /api/embed endpoint takes a single string or an array of strings. By default, input that is longer than the model'\''s context window is truncated. Set truncate to false to get an error instead.\n\n",
    "Split long documents into smaller chunks before you embed them, so that each chunk fits in the context window and a search can return the part that answers the question."
  ],
  "truncate": false
}'

Fragmentos

3 fragmentos. El más largo tiene 294 caracteres.

#0 · 294 caracteres · empieza en la posición 0
Embeddings turn text into numeric vectors. You can store them in a vector database and search them with cosine similarity, or use them in a RAG pipeline. The length of each vector depends on the embedding model. Use the same model when you index your documents and when you embed a question.
#1 · 202 caracteres · empieza en la posición 294
Ollama's /api/embed endpoint takes a single string or an array of strings. By default, input that is longer than the model's context window is truncated. Set truncate to false to get an error instead.
#2 · 169 caracteres · empieza en la posición 496
Split long documents into smaller chunks before you embed them, so that each chunk fits in the context window and a search can return the part that answers the question.

Cuerpo JSON para /api/embed

{
  "model": "embeddinggemma",
  "input": [
    "Embeddings turn text into numeric vectors. You can store them in a vector database and search them with cosine similarity, or use them in a RAG pipeline.\n\nThe length of each vector depends on the embedding model. Use the same model when you index your documents and when you embed a question.\n\n",
    "Ollama's /api/embed endpoint takes a single string or an array of strings. By default, input that is longer than the model's context window is truncated. Set truncate to false to get an error instead.\n\n",
    "Split long documents into smaller chunks before you embed them, so that each chunk fits in the context window and a search can return the part that answers the question."
  ],
  "truncate": false
}

Campos de la petición tal como figuran en la referencia de la API de Ollama para /api/embed, comprobados el 2026-11-04. Ollama API: Generate embeddings

Todo se hace en tu navegador. La herramienta solo escribe el comando y no envía nada.

Usa un solo modelo para indexar y para buscar

La página de embeddings dice que se use el mismo modelo de embeddings tanto para indexar como para consultar. La longitud del vector depende del modelo, así que los vectores de dos modelos distintos pueden ni siquiera tener el mismo número de dimensiones.

Lo mismo vale para dimensions: si lo estableces al indexar tus documentos, establece el mismo valor al crear los embeddings de las preguntas. Si cambias el modelo o este ajuste, vuelve a crear los embeddings de los documentos guardados.

Comparar los vectores

La documentación recomienda la similitud del coseno para la mayoría de los casos de búsqueda semántica y dice que /api/embed devuelve vectores normalizados L2, de longitud unitaria. Para vectores de longitud unitaria, la similitud del coseno y el producto escalar son el mismo número, de modo que una base de datos vectorial configurada con cualquiera de los dos ordenará los resultados igual.

Para probar un modelo con tus propios textos antes de construir nada, crea en una sola petición el embedding de una pregunta y de unos cuantos pasajes, con la pregunta primero. Pega la respuesta aquí abajo: los pasajes se ordenan por su similitud del coseno con la pregunta, y la herramienta indica si todos los vectores tienen longitud unitaria y las mismas dimensiones.

Pruébalo: Embedding Similarity Calculator

Respuesta de embeddings (JSON)De /api/embed, /v1/embeddings o un array de vectoresEtiquetas, una por línea (opcional)Pega los textos de entrada en el mismo orden

El ejemplo usa vectores inventados, de longitud unitaria y con 4 dimensiones, para que se puedan leer. Los embeddings reales tienen cientos o miles de dimensiones.

Leído como una respuesta de Ollama /api/embed: 4 vectores con 4 dimensiones. Todos los vectores tienen una longitud de 1, así que la similitud del coseno y el producto escalar son iguales.

Comparar con

Clasificación por similitud del coseno

Comparado con #0 How do I keep a model loaded in Ollama?. Cuanto mayor, más similar.

Puesto	Texto	Coseno	Producto escalar	Distancia
1	#1 keep_alive controls how long the model stays in memory	0.9962	0.9962	0.0876
2	#2 Protect Ollama with nginx and a password	0.4037	0.4037	1.0921
3	#3 Tomorrow's weather forecast	0.0100	0.0100	1.4071

Matriz de similitud del coseno

Cada celda compara el vector de la fila con el vector de la columna.

	#0	#1	#2	#3
#0	1.000	0.996	0.404	0.010
#1	0.996	1.000	0.475	-0.005
#2	0.404	0.475	1.000	-0.377
#3	0.010	-0.005	-0.377	1.000

Vectores

Texto	Dimensiones	Longitud (norma L2)	Longitud unitaria
#0 How do I keep a model loaded in Ollama?	4	1.000000	Sí
#1 keep_alive controls how long the model stays in memory	4	1.000000	Sí
#2 Protect Ollama with nginx and a password	4	1.000001	Sí
#3 Tomorrow's weather forecast	4	1.000000	Sí

Basado en la documentación de embeddings y la referencia de la API de Ollama, comprobadas el 2026-11-04. Ollama: Embeddings / Ollama API: Generate embeddings

Todo se calcula en tu navegador. No se envía nada a ninguna parte.

Memoria en un servidor pequeño

Un modelo de embeddings se carga como cualquier otro modelo. Las preguntas frecuentes (FAQ) de Ollama dicen que OLLAMA_MAX_LOADED_MODELS, el número de modelos que pueden estar cargados a la vez si caben en memoria, vale por defecto 3 veces el número de GPU, o 3 para la inferencia en CPU. Así, un modelo de chat y un modelo de embeddings pueden quedar cargados juntos cuando la memoria lo permite.

Nuestro artículo sobre cómo vigilar la memoria de Ollama explica ollama ps, keep_alive y los demás ajustes que deciden qué permanece en memoria.