Búsqueda semántica frente a búsqueda por palabras clave
En esta página
Objetivos
- Comprender las limitaciones de la búsqueda por palabras clave
- Descubrir cómo la búsqueda semántica resuelve estos problemas
- Implementar una búsqueda semántica sencilla
Los límites de la búsqueda por palabras clave
La búsqueda clásica (TF-IDF, BM25, Elasticsearch) se basa en la coincidencia léxica: busca las palabras exactas de la consulta dentro de los documentos. Este mecanismo es rápido, predecible y totalmente fiable siempre que el usuario emplee el mismo vocabulario que los documentos. El problema es que casi nunca lo hacen.
El pequeño corpus comentado que aparece a continuación muestra las cuatro situaciones típicas al enfrentarse a la consulta «how to feed a puppy».
# Búsqueda por palabras clave
query = "how to feed a puppy"
# ✅ Encontrado: contiene las mismas palabras
doc_a = "How to feed a 3-month-old puppy"
# ❌ No encontrado: palabras diferentes, mismo significado
doc_b = "Feeding the young dog"
# ❌ No encontrado: reformulación
doc_c = "Dietary regimen for newborn puppies"
# ⚠️ Falso positivo: mismas palabras, significado diferente
doc_d = "How to feed a startup project like a puppy"
Solo se recupera el primer documento, aunque el segundo y el tercero responden a la pregunta igual de bien. Peor aún, el cuarto ocupa un puesto alto únicamente porque comparte palabras con la consulta, a pesar de tratar sobre gestión empresarial. Sinónimos, reformulaciones y ambigüedad: la búsqueda léxica falla en los tres casos.
Búsqueda semántica
La búsqueda semántica compara el significado de los textos, no sus palabras. Codificas el corpus una sola vez y para siempre, codificas la consulta cuando llega y ordenas los documentos por similitud.
from openai import OpenAI
import numpy as np
client = OpenAI()
def embed(text: str) -> np.ndarray:
response = client.embeddings.create(
input=text,
model="text-embedding-3-large"
)
return np.array(response.data[0].embedding)
# Corpus
documents = [
"How to feed a 3-month-old puppy",
"Feeding the young dog",
"Dietary regimen for newborn puppies",
"How to feed a startup project like a puppy",
"The basics of Italian cuisine",
]
# Indexar el corpus
corpus_embeddings = np.array([embed(doc) for doc in documents])
# Búsqueda
query = "how to feed a puppy"
query_embedding = embed(query)
# Calcular similitudes
similarities = corpus_embeddings @ query_embedding
# Ordenar por relevancia
results = sorted(
enumerate(similarities), key=lambda x: x[1], reverse=True
)
for idx, score in results:
print(f"{score:.4f} | {documents[idx]}")
Resultado esperado:
0.9123 | How to feed a 3-month-old puppy
0.8756 | Dietary regimen for newborn puppies
0.8421 | Feeding the young dog
0.4532 | How to feed a startup project like a puppy
0.1245 | The basics of Italian cuisine
Los tres documentos relevantes ocupan los tres primeros puestos a pesar de tener una redacción completamente diferente, y el falso positivo cae a 0,45, muy por debajo del umbral que lo llevaría a la cima. El modelo ha entendido que «puppy» sirve aquí como comparación, no como sujeto.
Comparación estructurada
| Criterio | Palabras clave (BM25) | Semántica (embeddings) |
|---|---|---|
| Sinónimos | ❌ Falla | ✅ Funciona |
| Reformulación | ❌ Falla | ✅ Funciona |
| Multilingüe | ❌ Imposible | ✅ Posible |
| Errores ortográficos | ❌ Falla | ✅ Los tolera |
| Coincidencia exacta | ✅ Excelente | ⚠️ A veces imprecisa |
| Nombres propios, códigos | ✅ Excelente | ⚠️ Puede confundir |
| Velocidad (corpus grande) | ✅ Muy rápida | ⚠️ Requiere un índice |
| Coste | ✅ Gratis | ⚠️ Llamadas a la API |
¿Cuándo usar cada una?
Al leer la tabla se deduce una regla sencilla: cuanto más se asemeje una consulta a un identificador, más apropiada será la búsqueda léxica. Una referencia de producto como XR-4471-B, una fecha, una categoría exacta o un nombre propio poco frecuente deben buscarse palabra por palabra; un modelo de embeddings tenderá a confundir esa referencia con sus vecinos. Esta es también la opción por defecto cuando el corpus es masivo y el presupuesto para embeddings es cero.
La búsqueda semántica toma la delantera tan pronto como el usuario se expresa en lenguaje natural. Una FAQ, atención al cliente, documentación técnica consultada por no especialistas, un corpus multilingüe donde la pregunta se formula en francés y la respuesta está escrita en inglés, o incluso una consulta vaga y exploratoria: en todos estos casos, la brecha entre el vocabulario del usuario y el de los documentos es precisamente lo que los embeddings saben salvar.
Dado que estos dos perfiles son complementarios y no competitivos, la mejor respuesta suele consistir en combinar ambos enfoques para cubrir todos los casos. De eso trata la Lección 9.
Implementación de una búsqueda semántica completa
En la práctica, encapsulas la indexación y la consulta en una pequeña clase. Esto evita recalcular los vectores del corpus para cada consulta, que es el error más costoso que cometen los principiantes.
class SemanticSearch:
def __init__(self, model: str = "text-embedding-3-large"):
self.client = OpenAI()
self.model = model
self.documents: list[dict] = []
self.embeddings: np.ndarray | None = None
def index(self, documents: list[dict]):
"""Indexa una lista de documentos {id, text, ...}."""
self.documents = documents
texts = [d["text"] for d in documents]
response = self.client.embeddings.create(
input=texts,
model=self.model
)
vectors = sorted(response.data, key=lambda x: x.index)
self.embeddings = np.array(
[v.embedding for v in vectors], dtype=np.float32
)
def search(self, query: str, k: int = 5) -> list[dict]:
"""Busca los k documentos más relevantes."""
query_emb = self.client.embeddings.create(
input=query,
model=self.model
).data[0].embedding
similarities = self.embeddings @ np.array(query_emb)
top_k = np.argsort(similarities)[-k:][::-1]
return [
{**self.documents[i], "score": float(similarities[i])}
for i in top_k
]
# Uso
engine = SemanticSearch()
engine.index([
{"id": 1, "text": "How to install Python on Windows"},
{"id": 2, "text": "Guide to configuring the Python environment"},
{"id": 3, "text": "The basics of the Python language"},
])
results = engine.search("set up Python on my PC")
for r in results:
print(f"[{r['score']:.3f}] {r['text']}")
Prueba este motor con la consulta «set up Python on my PC»: ninguna de estas cinco palabras aparece en el documento 1, que habla de «installing Python on Windows». Sin embargo, debería ocupar el primer puesto. Luego modifica la consulta para hablar de «configuring the environment» y observa cómo la clasificación cambia al documento 2: ya tienes un banco de pruebas mínimo para verificar el comportamiento de tu índice antes de poblarlo en serio.
Resumen
- La búsqueda por palabras clave falla con sinónimos y reformulaciones
- La búsqueda semántica compara el significado mediante embeddings
- Cada enfoque tiene sus puntos fuertes: la búsqueda híbrida combina ambos
- Un motor semántico sencillo puede construirse en unas pocas decenas de líneas