NUCBA - Formación profesional digital

El problema real de las búsquedas por keywords

Tu usuario tipea "zapatillas para correr cómodas" y tu buscador devuelve cualquier producto que contenga esas palabras exactas. El resultado: una mezcla caótica de zapatillas de vestir, plantillas ortopédicas y hasta calcetines deportivos.

Esto pasa porque las búsquedas tradicionales funcionan como un ctrl+F glorificado. Buscan coincidencias exactas de texto, sin entender qué quiere realmente el usuario.

Los embeddings cambian esto completamente. En lugar de buscar palabras exactas, entienden el significado y la intención detrás de la búsqueda.

Qué son los embeddings y por qué importan

Un embedding es una representación numérica de texto que captura su significado semántico. Imaginate que cada palabra o frase se convierte en una coordenada en un espacio multidimensional, donde conceptos similares quedan cerca unos de otros.

Por ejemplo:

"auto" y "coche" tendrán embeddings muy similares
"zapatillas running" y "calzado deportivo" también
"problema" y "issue" quedarán próximos

Esto permite que tu búsqueda entienda sinónimos, conceptos relacionados y hasta errores de tipeo.

Implementación práctica paso a paso

1. Generá embeddings de tu catálogo

Primero necesitás convertir las descripciones de tus productos en embeddings. Podés usar la API de OpenAI:

import openai
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def generate_embedding(text, model="text-embedding-3-small"):
    text = text.replace("\n", " ")
    return openai.embeddings.create(input=[text], model=model).data[0].embedding

# Ejemplo con productos
products = [
    {"id": 1, "title": "Zapatillas Nike Air Max", "description": "Calzado deportivo para running y entrenamiento"},
    {"id": 2, "title": "Remera Adidas Climacool", "description": "Camiseta técnica para deportes con tecnología de ventilación"},
    # más productos...
]

# Generá embeddings para cada producto
for product in products:
    full_text = f"{product['title']} {product['description']}"
    product['embedding'] = generate_embedding(full_text)

2. Procesá las búsquedas de usuarios

Cuando un usuario busca algo, convertís su query en embedding y lo comparás con tu catálogo:

def semantic_search(query, products, top_k=10):
    # Generá embedding de la búsqueda
    query_embedding = generate_embedding(query)
    
    # Calculá similitud con todos los productos
    similarities = []
    for product in products:
        similarity = cosine_similarity(
            [query_embedding], 
            [product['embedding']]
        )[0][0]
        similarities.append((product, similarity))
    
    # Ordená por similitud y devolvé los mejores
    similarities.sort(key=lambda x: x[1], reverse=True)
    return [item[0] for item in similarities[:top_k]]

# Ejemplo de uso
query = "zapatillas para correr cómodas"
results = semantic_search(query, products)

3. Combiná búsqueda semántica con filtros tradicionales

No abandones completamente las búsquedas por keywords. Combiná ambos enfoques:

def hybrid_search(query, products, filters=None, semantic_weight=0.7):
    # Búsqueda semántica
    semantic_results = semantic_search(query, products)
    
    # Búsqueda por keywords (tradicional)
    keyword_results = keyword_search(query, products)
    
    # Combiná resultados con pesos
    combined_scores = {}
    
    for i, product in enumerate(semantic_results):
        combined_scores[product['id']] = semantic_weight * (1 - i/len(semantic_results))
    
    for i, product in enumerate(keyword_results):
        product_id = product['id']
        keyword_score = (1 - semantic_weight) * (1 - i/len(keyword_results))
        combined_scores[product_id] = combined_scores.get(product_id, 0) + keyword_score
    
    # Aplicá filtros adicionales (precio, categoría, etc.)
    if filters:
        filtered_products = apply_filters(products, filters)
    
    return sorted_results_by_score(combined_scores)

Casos de uso donde brillan los embeddings

Búsquedas con sinónimos: Un usuario busca "notebook" y encuentra "laptop" y "computadora portátil".

Búsquedas conceptuales: Busca "algo para el frío" y encuentra camperas, bufandas y calefactores.

Errores de tipeo: "zapatilals" sigue funcionando porque el embedding captura la intención.

Búsquedas en otros idiomas: Si tu catálogo está en español pero alguien busca en inglés, los embeddings pueden hacer la conexión.

Descripciones largas: Un usuario describe lo que necesita en una oración completa y tu sistema entiende la necesidad específica.

Optimización y consideraciones técnicas

Storage y performance

Los embeddings ocupan espacio. Un embedding de OpenAI tiene 1536 dimensiones (números float). Para 10,000 productos necesitás aproximadamente 60MB de storage.

Para mejorar performance:

Usá índices vectoriales como Pinecone, Weaviate o Chroma
Caché embeddings - no los regeneres en cada búsqueda
Batch processing para generar embeddings de productos nuevos

Actualización de embeddings

def update_product_embeddings(new_products):
    """Actualiza embeddings solo para productos nuevos o modificados"""
    for product in new_products:
        if product.get('embedding_generated_at') < product.get('updated_at'):
            full_text = f"{product['title']} {product['description']}"
            product['embedding'] = generate_embedding(full_text)
            product['embedding_generated_at'] = datetime.now()

Métricas para medir el éxito

Click-through rate (CTR): ¿Los usuarios hacen clic en los primeros resultados?

Tiempo en página de resultados: Si bajan rápido, encontraron lo que buscaban.

Conversión por búsqueda: ¿Cuántos usuarios que buscan terminan comprando?

Búsquedas sin resultados: Deberían bajar drásticamente con búsqueda semántica.

Refinamiento de búsquedas: Si los usuarios reformulan menos sus búsquedas, tu sistema está funcionando.

Implementación incremental

No necesitás cambiar todo tu sistema de una vez:

Fase 1: Implementá búsqueda semántica para una categoría específica
Fase 2: Agregá como opción "búsqueda avanzada" junto a la tradicional
Fase 3: Hacé A/B testing entre ambos sistemas
Fase 4: Migrá completamente si los resultados son mejores

Preguntas frecuentes

¿Es muy caro usar embeddings? La API de OpenAI cobra por token procesado. Para un e-commerce mediano, el costo mensual ronda los $50-200 USD. Considerá que es una inversión que mejora directamente las ventas.

¿Funciona en español? Sí, los modelos actuales manejan muy bien español y otros idiomas. Los embeddings capturan significado independientemente del idioma.

¿Qué pasa con productos muy técnicos? Los embeddings funcionan especialmente bien con terminología técnica porque entienden relaciones entre conceptos especializados que las búsquedas por keywords no capturan.

Tu búsqueda devuelve resultados irrelevantes a los usuarios