Al terminar este artículo tendrás un RAG que cabe en un solo archivo de Python: Qdrant guarda los vectores, bge-m3 convierte el texto en vectores y un modelo de 7B responde con lo que vuelve. También tendrás una forma de comprobarlo con números y no a ojo. Debería caber en un portátil de 16 GB, aunque no lo medimos en uno; nosotros lo medimos en dos DGX Spark.
Qué necesitas
- Docker, para Qdrant.
- Ollama con dos modelos:
ollama pull bge-m3yollama pull qwen2.5:7b-instruct. - Python 3 con
requests. Sin framework y sin clave de API. - Una carpeta de archivos Markdown o de texto. Nosotros usamos 50 de nuestros artículos publicados en español.
Si ya montaste nuestro tutorial con n8n, esto es la misma idea sin el editor de flujos, para que veas cada paso.
Paso 1: arranca Qdrant
docker run -d --name qdrant -p 6333:6333 -v qdrant_data:/qdrant/storage qdrant/qdrant
curl -s localhost:6333/collections
# {"result":{"collections":[]},"status":"ok",...}Si el puerto está ocupado, usa otro (-p 6334:6333) y cambia QDRANT en el script.
Paso 2: todo el pipeline en un archivo
Guárdalo como rag_local.py. Corta cada archivo en fragmentos por palabras, los convierte en vectores con bge-m3, los guarda en Qdrant y responde con el modelo de 7B a través del endpoint compatible con OpenAI de Ollama.
import sys, uuid, pathlib, requests
OLLAMA = "http://localhost:11434"
QDRANT = "http://localhost:6333"
LLM = "http://localhost:11434/v1" # endpoint compatible con OpenAI de Ollama (vLLM: :8000/v1)
LLM_MODEL = "qwen2.5:7b-instruct"
COLL, SIZE = "docs", 1000 # tamaño del fragmento en caracteres
def chunks(text, size=SIZE, overlap=150):
words, out, i = text.split(), [], 0
while i < len(words):
start, cur, n = i, [], 0
while i < len(words) and (not cur or n + len(words[i]) < size):
cur.append(words[i]); n += len(words[i]) + 1; i += 1
out.append(" ".join(cur))
if i >= len(words): break
back = 0
while back < overlap and i > start + 1:
i -= 1; back += len(words[i]) + 1
return out
def embed(texts):
r = requests.post(f"{OLLAMA}/api/embed", json={"model": "bge-m3", "input": texts})
return r.json()["embeddings"]
def ingest(folder):
pts = []
for f in sorted(pathlib.Path(folder).glob("*.md")):
parts = chunks(f.read_text())
for vec, part in zip(embed(parts), parts):
pts.append({"id": str(uuid.uuid4()), "vector": vec, "payload": {"doc": f.stem, "text": part}})
requests.delete(f"{QDRANT}/collections/{COLL}") # vuelve a indexar desde cero
requests.put(f"{QDRANT}/collections/{COLL}", json={"vectors": {"size": len(pts[0]["vector"]), "distance": "Cosine"}})
requests.put(f"{QDRANT}/collections/{COLL}/points?wait=true", json={"points": pts})
print(len(pts), "chunks")
def ask(question, k=5):
hits = requests.post(f"{QDRANT}/collections/{COLL}/points/query",
json={"query": embed([question])[0], "limit": k, "with_payload": True}).json()
ctx = "\n\n".join(f"[{p['payload']['doc']}] {p['payload']['text']}" for p in hits["result"]["points"])
msgs = [{"role": "system", "content": "Responde solo con el contexto. Si no está, di: No lo sé."},
{"role": "user", "content": f"Contexto:\n{ctx}\n\nPregunta: {question}"}]
r = requests.post(f"{LLM}/chat/completions", json={"model": LLM_MODEL, "messages": msgs, "temperature": 0})
print(r.json()["choices"][0]["message"]["content"])
if __name__ == "__main__":
ingest(sys.argv[2]) if sys.argv[1] == "ingest" else ask(sys.argv[2])Con una carpeta muy grande, envía los puntos a Qdrant en lotes de unos cientos en lugar de en una sola petición.
Paso 3: indexa y pregunta
python3 rag_local.py ingest ./mis-documentos
# 34 chunks
python3 rag_local.py ask "¿Cuánto daba el Kit Digital a una microempresa?"
# El Kit Digital proporcionaba un bono de 6.000 EUR a una microempresa, ...Esa salida es de nuestra prueba con tres artículos, el 2-11-2026. El 3-11-2026 volvimos a ejecutar el script sin cambios con qwen2.5:7b-instruct en Ollama (la versión de 4 bits, Q4_K_M) sobre seis artículos: indexó 70 fragmentos y respondió “6.000 EUR” a la misma pregunta. Cada fragmento llega al modelo con el nombre de su documento, así que puedes abrir la fuente y comprobarla.
Paso 4: mídelo antes de fiarte
Un RAG que “parece que va bien” falla en la pregunta que nadie probó. Escribe preguntas como las haría tu equipo y, para cada una, anota qué documento la responde. Eso es el patrón de referencia. Después puntúa el recuperador por separado:
- hit@5: parte de las preguntas cuyo documento correcto aparece entre los cinco primeros.
- MRR: la media de 1 / (posición del primer documento correcto). La posición 1 vale 1, la 2 vale 0,5 y un fallo vale 0.
Escribimos a mano 60 preguntas sobre 50 artículos y las congelamos en rag-embeddings-es-questions-2026-11-02.json. Ningún modelo escribió una pregunta ni eligió un documento correcto. Si quieres practicar antes el paso de ordenar, nuestro ejercicio de recuperación top-k corre en el navegador. Para el método completo, lee Evaluaciones de IA: prueba tu RAG antes de producción.
Qué medimos
Medido el 2-11-2026. Embeddings: bge-m3 en Ollama 0.34.0, en nuestra segunda DGX Spark (GB10, 128 GB). Qdrant 1.18.2 y el reranker (BAAI/bge-reranker-v2-m3) en la primera. Respuestas: Qwen2.5-7B-Instruct en BF16 sobre vLLM, temperatura 0, los cinco mejores fragmentos. El script del paso 2 usa en cambio la versión de 4 bits de Ollama; las tablas de abajo no se midieron con ella. Corpus: 50 artículos en español, 501.917 caracteres. Los fragmentos se solapan un 15 %. Archivo bruto: rag-embeddings-es-2026-11-02.json.
python3 scripts/bench/rag_embeddings_es.py --ollama http://<second-box>:11434 \
--qdrant http://localhost:6333 --reranker http://localhost:8201 --llm http://localhost:8200/v1 \
--out docs/measurements/rag-embeddings-es-2026-11-02.jsonRecuperación, 60 preguntas (cada documento cuenta una vez, en su mejor fragmento; el reranker vuelve a puntuar los 40 primeros fragmentos):
| Tamaño del fragmento | Fragmentos | hit@1 | hit@5 | MRR | hit@5 + reranker | MRR + reranker |
|---|---|---|---|---|---|---|
| 500 caracteres | 1.229 | 81,7 % | 96,7 % | 0,885 | 100 % | 0,908 |
| 1.000 caracteres | 610 | 78,3 % | 96,7 % | 0,862 | 100 % | 0,928 |
| 2.000 caracteres | 310 | 83,3 % | 100 % | 0,895 | 100 % | 0,947 |
Lo que le costó al modelo de 7B (medianas de 60 respuestas, tras el reranker):
| Tamaño del fragmento | Tokens del prompt | Tiempo de respuesta | Anclaje | ”No lo sé” |
|---|---|---|---|---|
| 500 caracteres | 839 | 3,6 s | 0,87 | 4 de 60 |
| 1.000 caracteres | 1.637 | 4,0 s | 0,93 | 3 de 60 |
| 2.000 caracteres | 3.178 | 5,2 s | 0,94 | 2 de 60 |
El anclaje es la parte de las frases de la respuesta que el reranker puntúa con 0,35 o más frente a los cinco fragmentos (media de todas las respuestas). Es una comprobación automática, no humana.
Tres cosas que dicen las tablas.
Con 60 preguntas, las diferencias pequeñas son ruido. El margen del 95 % sobre un hit@5 del 96,7 % es de unos ±4,5 puntos. Los tres tamaños se separan por una o dos preguntas; con la primera tabla sola no elegiríamos ganador.
El reranker pesó más. Puso todos los documentos correctos entre los cinco primeros con los tres tamaños y subió el MRR entre 0,02 y 0,07. Un cross-encoder lee la pregunta y el fragmento juntos: es más lento por fragmento, pero solo trabaja sobre 40.
El fragmento grande lo paga el modelo, no el recuperador. Pasar de 1.000 a 2.000 caracteres casi duplicó el prompt (de 1.637 a 3.178 tokens) y sumó unos 1,3 segundos por respuesta. En una máquina pequeña con una ventana de contexto corta, ese es el número que decide.
Lo que no te dice la ficha técnica
- Acertar el documento no es responder. Incluso con el documento correcto entre los cinco primeros, el 7B dijo “No lo sé” de dos a cuatro veces de 60. El modelo lee cinco fragmentos, no cinco documentos, así que un documento puede salir arriba y quedarse fuera su fragmento útil.
- Lo que está en una tabla cuesta encontrarlo. Una de las dos preguntas que más fallaron en las 11 ejecuciones con los tres modelos de embeddings (6 de 11 la dejaron fuera de los cinco primeros) fue “¿qué equipo me compro con 1.000 euros?”: la respuesta está en una fila de una tabla de hardware. Nuestra lectura es que un fragmento de filas de tabla se parece poco a una pregunta; no lo probamos más.
- La comprobación de anclaje tiene puntos ciegos. Una respuesta que citaba su fuente casi palabra por palabra sacó 0. Úsala para saber qué respuestas leer, no para ponerles nota.
- Nuestro conjunto es más fácil que tu carpeta. 50 artículos limpios y preguntas escritas por quien los leyó. Una unidad compartida con PDF escaneados y cinco versiones del mismo contrato puntuará más bajo. Mide la tuya.
Veredicto
- Empieza con 1.000 a 2.000 caracteres y un 15 % de solape, y mide con tus propias preguntas.
- Añade un reranker antes de tocar nada más. Fue la mejora más barata que medimos.
- Guarda el archivo de preguntas. Veinte preguntas con su documento bastan para detectar un retroceso cuando cambies un modelo o un ajuste.
Cuándo no hacerlo
Si tus documentos caben en el contexto del modelo (un puñado de políticas, un manual), sáltate la recuperación y pégalos. Si necesitas un flujo visual que otras personas vayan a editar, la versión con n8n se entrega mejor. Y si nadie va a mantener el índice cuando cambien los documentos, el RAG se queda viejo sin avisar; decide quién vuelve a lanzar la ingesta.
Próximos pasos
- Elige el modelo de embeddings con las mismas 60 preguntas: el mejor modelo de embeddings local para español, medido.
- Pon las respuestas delante de tu oficina: Open WebUI para una oficina de 10.
- Saca los campos de tus documentos en JSON antes de indexarlos: salida JSON estructurada con Ollama, medido.
- Deja que un agente use tu RAG como herramienta: n8n + MCP, o empieza por tus primeros 3 agentes en local.
Trabaja con nosotros
Podemos hacer este análisis con tus documentos reales antes de recomendar hardware. 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.