Embeddings con Ollama

Qué cubre este artículo sobre Ollama

• Qué son los embeddings y para qué sirven.
• Qué modelos de embedding ofrece Ollama.
• Cómo generar embeddings a través de la API.
• Cómo usarlos en Python.
• Aplicaciones como RAG y búsqueda semántica.

Introducción: Embeddings con Ollama

Los embeddings son vectores numéricos que representan texto en un espacio multidimensional. Los contenidos con significado similar se encuentran próximos entre sí. Esta propiedad los hace esenciales para RAG, búsqueda semántica, agrupamiento de documentos y sistemas de recomendación. Ollama facilita ejecutar modelos de embedding localmente, sin depender de servicios en la nube.

Este artículo muestra qué modelos de embedding ofrece Ollama, cómo funciona la API y cómo utilizar los vectores en tus propios proyectos.

Términos clave

• Embedding: Vector que representa texto u otros datos.
• Modelo de embedding: Modelo especializado para generar vectores.
• Espacio vectorial: Espacio matemático donde se miden similitudes.
• Similitud coseno: Medida de proximidad entre dos vectores.
• RAG: Retrieval-Augmented Generation, incluir documentos externos en prompts.
• Base de datos vectorial: Almacenamiento para embeddings.

Modelos de embedding en Ollama

Ollama ofrece varios modelos de embedding. El más conocido es:

• nomic-embed-text: 137 millones de parámetros, buen rendimiento, uso libre.
• mxbai-embed-large: Modelo multilingüe más potente.
• bge-m3: Multilingüe, adecuado para documentos más largos.

Los modelos se descargan igual que los modelos de lenguaje:

ollama pull nomic-embed-text
ollama pull mxbai-embed-large

Generar embeddings

A través de la API REST

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Ollama es una herramienta para IA local."
}'

Respuesta:

{
  "model": "nomic-embed-text",
  "embeddings": [[0.12, -0.34, 0.56, ...]]
}

Múltiples textos

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": [
    "Primer texto.",
    "Segundo texto.",
    "Tercer texto."
  ]
}'

Ejemplo en Python

import requests

def embed(texts, model="nomic-embed-text"):
    url = "http://localhost:11434/api/embed"
    payload = {"model": model, "input": texts}
    resp = requests.post(url, json=payload)
    return resp.json()["embeddings"]

vectors = embed(["Hola mundo", "Usar Ollama localmente"])
print(len(vectors), len(vectors[0]))

Calcular similitud

Con numpy puedes calcular la similitud coseno entre dos vectores:

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

v1 = np.array(vectors[0])
v2 = np.array(vectors[1])
print(cosine_similarity(v1, v2))

Comparación con OpenAI

Característica	Ollama local	API OpenAI
Costo	Solo electricidad	Por token
Privacidad	Permanece local	Va a la nube
Velocidad	Depende del hardware	Rápida
Calidad	Buena	Muy buena
Escalabilidad	Limitada por tu hardware	Muy escalable

Para muchas aplicaciones, los embeddings locales de Ollama son suficientes. Si necesitas máxima precisión o volúmenes muy grandes de datos, puedes complementar con modelos en la nube.

Aplicaciones

RAG

En un sistema RAG, los documentos se dividen en fragmentos pequeños, se convierten a embeddings y se guardan en una base de datos vectorial. Cuando haces una pregunta, también se convierte a vector y se buscan los fragmentos de documento más cercanos.

Búsqueda semántica

En lugar de buscar por palabras clave, encuentras contenido similar. Esto funciona incluso entre idiomas diferentes.

Clasificación y agrupamiento

Con embeddings puedes asignar textos a categorías o dividirlos automáticamente en grupos temáticos.

Bases de datos vectoriales

Los embeddings de Ollama funcionan bien combinados con bases de datos vectoriales locales:

• ChromaDB: Fácil de usar, popular en Python.
• Qdrant: Base de datos vectorial rápida y escalable.
• Weaviate: Independiente del modelo, potente para empresas.
• pgvector: Extensión vectorial para PostgreSQL.

Consejos

• Divide los textos en fragmentos significativos.
• Ajusta el tamaño del fragmento y el solapamiento según tu aplicación.
• Elige un modelo de embedding adecuado para el idioma.
• Almacena los embeddings de una vez, no los regeneres en cada solicitud.
• Mide el recall y la precisión con consultas de prueba.

Problemas comunes

• Modelo incorrecto: No todos los modelos sirven para embeddings.
• Texto demasiado largo: Los textos más largos deben dividirse previamente.
• Dimensiones variables: Modelos diferentes generan vectores de distinta longitud.
• Sin normalización: La similitud coseno requiere vectores normalizados.
• URL de API incorrecta: /api/embed es el endpoint de Ollama, no /v1/embeddings.

Enlaces y recursos adicionales

• BotServ.de API REST de Ollama
• BotServ.de Comandos de Ollama
• BotServ.de Base de conocimiento RAG
• BotServ.de Bases de datos vectoriales

Preguntas frecuentes: Embeddings con Ollama

¿Qué modelo de embedding debo usar? nomic-embed-text es un buen punto de partida. mxbai-embed-large es más potente pero más grande.

¿Puedo incrustar documentos completos de una vez? Es mejor dividirlos en fragmentos.

¿Son los embeddings de Ollama conformes con privacidad? Sí, porque todo se procesa localmente.

¿Cómo almaceno embeddings? En una base de datos vectorial como ChromaDB, Qdrant o pgvector.

¿Qué medida de similitud usar? La similitud coseno es el estándar común.

Fuentes y lecturas recomendadas

• Ollama API Docs: https://github.com/ollama/ollama/blob/main/docs/api.md
• nomic-embed-text: https://ollama.com/library/nomic-embed-text
• Sentence Transformers: https://sbert.net/

Resumen: Embeddings con Ollama

Ollama te permite ejecutar modelos de embedding localmente y convertir textos en vectores. Esta es la base para RAG, búsqueda semántica y clasificación. nomic-embed-text es un modelo de entrada popular. Si divides los textos en fragmentos apropiados, almacenas los vectores en una base de datos vectorial local y mides similitudes con la distancia coseno, construirás rápidamente un sistema RAG local potente.