De Búsqueda por Keywords a RAG: Cómo le Enseñé a Mi Blog a Entender Preguntas
Este artículo técnico describe cómo se implementó un motor de búsqueda semántica para un blog personal, superando las limitaciones de la búsqueda por keywords tradicional. Se explica el concepto de embeddings, la similitud coseno y la transición de un modelo local (SBERT) a Vertex AI `text-embedding-005`. El lector aprenderá sobre el pipeline de indexación, la justificación para usar `pickle` en lugar de `pgvector` y los desafíos de convertir texto en representaciones numéricas significativas para mejorar la experiencia de búsqueda.

El Problema: Buscar No es Entender
Mi blog tenía 24 artículos sobre series de tiempo, econometría y ciencia de datos. La búsqueda funcionaba así:
# Vista de búsqueda original
Post.objects.filter(
Q(title__icontains=query) |
Q(content__icontains=query) |
Q(tags__name__icontains=query)
)[:10]
Si el usuario buscaba "series de tiempo", encontraba los artículos con esas palabras exactas. ¿Pero qué pasaba si buscaba "pronósticos temporales"? O "¿cómo predecir el futuro con datos históricos?"? Nada. Cero resultados. Porque la búsqueda por keywords no entiende significado, solo coincidencia textual.
Esto me frustraba como economista. En mi trabajo diario uso modelos que entienden el contexto semántico de las preguntas. ¿Por qué mi blog no podía hacer lo mismo?
Así nació el motor de búsqueda semántica, y eventualmente, el chatbot RAG completo.
Embeddings: Convirtiendo Texto en Geometría
La Intuición
Imagina que pudieras representar cada oración como un punto en el espacio. Oraciones similares estarían cerca, oraciones diferentes estarían lejos:
"Python es un lenguaje de programación" → punto en (2.1, 3.4, -1.2, ...)
"JavaScript es un lenguaje de código" → punto en (2.0, 3.3, -1.1, ...) ← CERCA
"La inflación subió en enero" → punto en (-0.5, 1.8, 4.2, ...) ← LEJOS
Esa representación numérica se llama embedding. Un modelo de lenguaje pre-entrenado toma texto y produce un vector de N dimensiones que captura su significado semántico.
La Matemática: Cosine Similarity
Para medir "cercanía" entre dos vectores, usamos la similitud coseno:
\text{cosine_similarity}(\vec{A}, \vec{B}) = \frac{\vec{A} \cdot \vec{B}}{||\vec{A}|| \cdot ||\vec{B}||}
El resultado es un número entre -1 y 1: - 1.0: Vectores idénticos (mismo significado) - 0.0: Sin relación - -1.0: Significados opuestos
En la práctica, textos relacionados suelen tener scores entre 0.5 y 0.95. Textos no relacionados suelen estar entre 0.0 y 0.3.
La Implementación Inicial: SBERT Local
El commit c9b3f3c implementó la primera versión usando SBERT (Sentence-BERT), un modelo que corre completamente en tu máquina:
```python blog_backend/search/engine.py (versión inicial, deprecada) from sentence_transformers import SentenceTransformer
model = SentenceTransformer('all-MiniLM-L6-v2')
Generar embedding de un texto
embedding = model.encode("¿Qué es machine learning?")
→ numpy array de shape (384,)
> **Estado actual — SBERT deprecado:** Esta implementación fue reemplazada en febrero de 2026 por **Vertex AI `text-embedding-005`** (768 dimensiones). El código de SBERT/Ollama vive en `blog_backend/deprecated/` como referencia histórica. La razón principal fue la necesidad de un único proveedor en producción compatible con Cloud Run.
`all-MiniLM-L6-v2` es un modelo ligero (~90 MB en RAM) que produce vectores de 384 dimensiones. Fue entrenado para que oraciones con el mismo significado produzcan vectores cercanos, usando una técnica llamada *contrastive learning* sobre millones de pares de oraciones.
**¿Por qué 384 dimensiones?** Es un trade-off entre expresividad y eficiencia. 384 dimensiones son suficientes para capturar matices semánticos complejos, pero lo suficientemente compactas para que la búsqueda sea rápida. Modelos más grandes (como `text-embedding-005` de Google con 768 dimensiones) capturan más detalle pero consumen más memoria y CPU.
---
## El Pipeline de Indexación
Antes de poder buscar, necesitas pre-calcular el embedding de cada post. Implementé un comando de Django:
```python blog_backend/search/management/commands/index_posts.py
class Command(BaseCommand):
def handle(self, *args, **options):
for post in Post.objects.filter(is_published=True, is_internal=False):
# Concatenar título + excerpt + contenido
text = f"{post.title} {post.excerpt} {post.content}"
# Generar embedding vía Vertex AI (text-embedding-005)
embedding = RAGEngine.get_embedding(text)
# Guardar en la base de datos
PostEmbedding.objects.update_or_create(
post=post,
defaults={'embedding_data': pickle.dumps(embedding)}
)
Nota: La versión actual del comando soporta la bandera
--forcepara borrar todos los embeddings y re-indexar desde cero. Esto es necesario cuando se cambia el modelo de embeddings (por ejemplo, al migrar de SBERT atext-embedding-005).
¿Por Qué Pickle y No pgvector?
PostgreSQL tiene una extensión llamada pgvector que permite almacenar vectores directamente y hacer búsquedas con operadores SQL (<=> para cosine distance). Era la opción "correcta" desde un punto de vista arquitectónico. Pero decidí usar pickle + BinaryField por dos razones:
1. Compatibilidad con SQLite. En desarrollo local uso SQLite, que no soporta pgvector. Con BinaryField, el mismo código funciona en ambas bases de datos.
2. Independencia de dimensiones. Si cambio de modelo de embeddings (de 384 a 768 dimensiones, por ejemplo), no necesito alterar el schema de la base de datos. El BinaryField acepta cualquier array numpy, sin importar su tamaño.
```python blog_backend/search/models.py class PostEmbedding(models.Model): post = models.OneToOneField(Post, on_delete=models.CASCADE) embedding_data = models.BinaryField(null=True) updated_at = models.DateTimeField(auto_now=True)
def set_embedding(self, embedding_array):
self.embedding_data = pickle.dumps(embedding_array)
def get_embedding(self):
return pickle.loads(self.embedding_data) if self.embedding_data else None
**El trade-off:** No puedes hacer búsquedas vectoriales directamente en SQL. Tienes que cargar todos los vectores en memoria y comparar en Python. Para 24 posts esto es instantáneo. Para 1,000 posts, sigue siendo <10ms. Para 1,000,000 posts, necesitarías pgvector con índices HNSW. Pero no estoy planeando escribir un millón de artículos.
---
## La Búsqueda Semántica en Acción
```python
@classmethod
def search(cls, query, top_k=5):
# 1. Generar embedding de la query del usuario
query_embedding = model.encode(query)
# 2. Cargar todos los embeddings pre-calculados
all_embeddings = PostEmbedding.objects.all()
# 3. Calcular similitud con cada post
results = []
for pe in all_embeddings:
post_vec = pe.get_embedding()
score = cosine_similarity(
query_embedding.reshape(1, -1),
post_vec.reshape(1, -1)
)[0][0]
results.append((pe.post, float(score)))
# 4. Ordenar por score y retornar top K
results.sort(key=lambda x: x[1], reverse=True)
return [(post, score) for post, score in results[:top_k] if score > 0.2]
Ejemplo real de resultados:
Query: "¿Cómo predecir valores futuros?"
Post: "Modelos ARIMA para Series de Tiempo" → Score: 0.72 ✓
Post: "Introducción a Machine Learning" → Score: 0.65 ✓
Post: "Análisis Estacional con Descomposición" → Score: 0.58 ✓
Post: "Django REST Framework en 30 Minutos" → Score: 0.12 ✗ (filtrado)
La búsqueda keyword hubiera retornado ningún resultado para esa query (no contiene las palabras "ARIMA", "series de tiempo" ni "machine learning"). La búsqueda semántica entiende que "predecir valores futuros" está conceptualmente relacionado con forecasting y time series.
Lazy Loading: No Cargar 90 MB al Arrancar
El commit f644e4f resolvió un problema de rendimiento. El modelo SBERT pesa ~90 MB en RAM. Si lo cargo al iniciar Django, cada proceso de Gunicorn consume esa memoria desde el arranque, incluso si nadie usa la búsqueda:
class SearchEngine:
_model = None # Singleton pattern
@classmethod
def get_model(cls):
if cls._model is None:
from sentence_transformers import SentenceTransformer
cls._model = SentenceTransformer('all-MiniLM-L6-v2')
return cls._model
Con lazy loading, el modelo se carga solo la primera vez que alguien hace una búsqueda. Las requests siguientes reutilizan la instancia existente (patrón Singleton a nivel de clase).
El impacto: - Sin lazy loading: 4 workers × 90 MB = 360 MB consumidos al arrancar - Con lazy loading: 0 MB al arrancar, 90 MB solo cuando se necesita (compartido entre requests del mismo worker)
Búsqueda Dual: Semántica para Autenticados, Keywords para Anónimos
El commit 4cdc446 introdujo una estrategia que me pareció elegante: dos motores de búsqueda según el tipo de usuario.
class SearchView(APIView):
def get(self, request):
query = request.query_params.get('q', '')
if request.user.is_authenticated:
# Búsqueda semántica (más cara pero mejor)
results = SearchEngine.search(query)
else:
# Búsqueda por keywords (gratis pero básica)
results = Post.objects.filter(
Q(title__icontains=query) |
Q(content__icontains=query)
)[:10]
return Response(PostSerializer(results, many=True).data)
La lógica económica: Generar un embedding cuesta recursos (CPU local o API cloud). Los usuarios anónimos (bots, crawlers, visitantes casuales) no necesitan la precisión de la búsqueda semántica. Los usuarios autenticados son los que realmente se benefician de ella.
La lógica técnica: Si un bot de Google crawlea mi blog y lanza 100 búsquedas, no quiero que cada una genere un embedding y compute similitudes. La búsqueda keyword es una simple query SQL que PostgreSQL resuelve en <1ms.
El Nacimiento del RAG: Cuando el Blog Aprendió a Conversar
Los commits del 8 de diciembre (354e0e1 y 443629d) transformaron el blog de una herramienta de búsqueda a un chatbot con personalidad.
¿Qué es RAG?
RAG (Retrieval-Augmented Generation) combina dos capacidades:
- Retrieval: Usar la búsqueda semántica para encontrar los posts más relevantes a la pregunta.
- Generation: Usar un LLM (Large Language Model) para generar una respuesta en lenguaje natural basada en esos posts.
Sin RAG, un LLM como Gemini no sabe qué he escrito en mi blog. Si le preguntas "¿Qué opina Héctor sobre ARIMA?", inventará una respuesta (alucinación). Con RAG:
1. Usuario pregunta: "¿Qué opina Héctor sobre ARIMA?"
2. Búsqueda semántica encuentra: post sobre Modelos ARIMA (score 0.85)
3. Se inyecta el contenido del post como contexto al LLM
4. El LLM genera una respuesta BASADA en el post real
5. La respuesta incluye citas y links a las fuentes
El Prompt de Personalidad
Quería que el chatbot hablara como yo, no como un asistente genérico. Diseñé un system prompt con mi biografía, estilo de escritura e instrucciones claras:
PERSONALITY_PROMPT = """
Tú ERES Héctor Garrido Henríquez. Un economista y científico de datos chileno.
Hablas en PRIMERA PERSONA, como si fueras el autor del blog.
INSTRUCCIONES:
- Responde basándote SOLO en los fragmentos de artículos proporcionados.
- Si la pregunta no se relaciona con tu experiencia o los artículos, dilo honestamente.
- Usa un tono académico pero accesible, como en una conversación entre colegas.
- Incluye referencias a los artículos relevantes cuando sea posible.
TU BIOGRAFÍA:
- Magíster en Matemática (Estadística)
- +8 años de docencia universitaria (Econometría, Estadística)
- Analista de Estudios en ChileCompra (politica pública y datos)
- Stack: R (Tidyverse), Python (Django, Pandas), SQL, Vertex AI
"""
La Arquitectura del Pipeline RAG
@classmethod
def generate_answer(cls, query):
# 1. Generar embedding de la pregunta
query_embedding = cls.get_embedding(query)
# 2. Buscar posts relevantes (score > 0.35, hasta top_k=10)
top_posts = EmbeddingIndex.search(query_embedding, top_k=10)
# 3. Construir el prompt con fragmentos de los posts
context = ""
sources = []
for post, score in top_posts:
context += f"\n---\nArtículo: {post.title}\n{post.content[:1500]}\n"
sources.append({'title': post.title, 'slug': post.slug, 'score': score})
# 4. Construir prompt completo
full_prompt = f"{PERSONALITY_PROMPT}\n\nCONTEXTO:\n{context}\n\nPREGUNTA: {query}"
# 5. Enviar al LLM y obtener respuesta
answer = cls._generate_with_vertex(full_prompt)
# 6. Retornar respuesta + fuentes
return {'answer': answer, 'sources': sources, 'cached': False}
Limitación de Contexto: 1500 Caracteres por Post
¿Por qué solo 1500 caracteres y no el artículo completo? Por dos razones:
1. Límite de tokens del LLM. Si un artículo tiene 5,000 palabras y envío 3 artículos completos, el prompt tendría ~15,000 palabras + el system prompt. Esto puede exceder el contexto del modelo o ser tan largo que la respuesta pierda foco.
2. Costo por tokens. Más tokens = más caro. En Vertex AI, se cobra por token procesado. Enviar 1,500 caracteres × 3 posts es ~2,000 tokens. Enviar artículos completos sería ~15,000 tokens. El costo se multiplica por 7x sin una mejora proporcional en calidad.
3. Señal vs. ruido. Los primeros 1,500 caracteres de un artículo suelen contener la introducción y la tesis principal. El resto suele ser desarrollo, ejemplos y conclusión. Para responder una pregunta general, los primeros párrafos son suficientes.
El Frontend del Chatbot: Typewriter Effect
El commit d7724dc (más tarde) agregó una interfaz conversacional con efecto de máquina de escribir. Cuando el chatbot "escribe" su respuesta, los caracteres aparecen uno por uno, simulando que está pensando en tiempo real:
function useTypewriter(text, speed = 20) {
const [displayedText, setDisplayedText] = useState('');
const [isTyping, setIsTyping] = useState(false);
const startTyping = useCallback(() => {
setIsTyping(true);
setDisplayedText('');
let i = 0;
const interval = setInterval(() => {
if (i < text.length) {
setDisplayedText(prev => prev + text[i]);
i++;
} else {
clearInterval(interval);
setIsTyping(false);
}
}, speed);
return () => clearInterval(interval);
}, [text, speed]);
return { displayedText, isTyping, startTyping };
}
El efecto es sutil pero poderoso: transforma una respuesta de API (que llega completa en ~3 segundos) en una experiencia que se siente como una conversación en tiempo real. Psicológicamente, el usuario percibe que el chatbot está "pensando" y la respuesta parece más deliberada.
Preguntas Sugeridas: UX que Invita a Explorar
Agregué 15 preguntas sugeridas como chips interactivos:
const suggestedQuestions = [
"¿Quién eres y a qué te dedicas?",
"¿Qué herramientas usas para analizar datos?",
"¿Qué es una serie de tiempo?",
"¿Qué lenguaje de programación recomiendas para empezar?",
"¿Qué es RAG y cómo funciona?",
// ... 10 más
];
Esto resuelve el problema del "blank page anxiety": cuando un usuario ve un campo de texto vacío, no sabe qué preguntar. Las sugerencias le muestran las capacidades del chatbot y le dan permiso para explorar.
LaTeX: Ecuaciones Matemáticas en el Blog
El commit 354e0e1 agregó soporte para KaTeX, un renderizador de ecuaciones matemáticas:
En el backend (Markdown → HTML):
extensions = [
'codehilite', # Syntax highlighting
'mdx_math', # Convierte $...$ a tags de KaTeX
'fenced_code', # Bloques de código con ```
'tables', # Tablas Markdown
]
En el frontend (HTML → Renderizado visual):
import 'katex/dist/katex.min.css';
import renderMathInElement from 'katex/dist/contrib/auto-render';
// Después de montar el componente con el HTML del post
useEffect(() => {
renderMathInElement(contentRef.current, {
delimiters: [
{ left: '$$', right: '$$', display: true },
{ left: '$', right: '$', display: false },
{ left: '\\[', right: '\\]', display: true },
{ left: '\\(', right: '\\)', display: false },
],
});
}, [post.content_html]);
Ahora puedo escribir en Markdown:
La distribución normal se define como:
$$f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2}\left(\frac{x-\mu}{\sigma}\right)^2}$$
donde $\mu$ es la media y $\sigma$ la desviación estándar.
Y se renderiza con tipografía matemática profesional, como en un paper LaTeX. Para un blog de econometría, esto es esencial.
Reflexión: La Búsqueda Semántica como Primer Paso Hacia la IA
Al final de estos commits, mi blog ya no era solo un repositorio de artículos. Era un sistema que entiende su propio contenido:
Antes (keywords): "series de tiempo" → 5 resultados
"predecir el futuro" → 0 resultados
Después (semántico): "series de tiempo" → 5 resultados
"predecir el futuro" → 3 resultados relevantes ✓
"¿Qué opinas de ARIMA?" → respuesta conversacional ✓
Las decisiones técnicas clave de esta fase:
1. SBERT local como MVP de bajo costo (deprecado en feb. 2026 por Vertex AI text-embedding-005).
2. Pickle + BinaryField por flexibilidad, sacrificando la elegancia de pgvector.
3. Búsqueda dual para optimizar costos y rendimiento según el tipo de usuario.
4. RAG con personalidad para que el chatbot no sea un ChatGPT genérico sino "yo".
Estado actual del motor: La implementación productiva usa
text-embedding-005(768-dim) de Vertex AI ygemini-2.5-flashpara generación. El umbral de relevancia esscore > 0.35con hasta 10 fuentes dinámicas. Los errores de Vertex AI no se cachean. Ver Post 06 y Post 09 para la evolución completa.
En el siguiente artículo: el viaje terrorífico de desplegar todo esto en Google Cloud Platform, donde cada fix fue un commit de desesperación.
Anterior: Cómo Construí Mi Blog Personal con Django y React desde Cero
Siguiente: Desplegar en Google Cloud: Crónica de 4 Pull Requests y Muchos Errores
Este artículo es parte de la serie "Construyendo un Blog con IA". El código fuente completo está en GitHub.