Saltar al contenido principal
Arquitectura y TCO
10 min de lectura

Búsqueda Semántica en el Navegador: Búsqueda Vectorial a Coste Cero con WebAssembly y Okapi BM25 para E-Commerce

Guía técnica de búsqueda semántica en el cliente para e-commerce: ejecución de modelos ONNX en WebAssembly, ranking híbrido BM25 + Coseno y consultas en menos de 25ms sin costes de bases de datos vectoriales.

AY
Artur Yusupov
Ingeniero Web Fullstack Senior y Arquitecto de Sistemas IA
Búsqueda Semántica en el Navegador: Búsqueda Vectorial a Coste Cero con WebAssembly y Okapi BM25 para E-Commerce

Resumen Ejecutivo (BLUF) y Justificación de Arquitectura

En el comercio electrónico moderno, el sistema de búsqueda determina directamente la tasa de conversión. Sin embargo, los motores tradicionales basados en consultas SQL LIKE '%termino%' o índices fulltext de MySQL se limitan a la coincidencia literal de caracteres. Cuando un cliente realiza búsquedas con lenguaje natural o intención conceptual (ej. *"colchón transpirable de verano para dolor lumbar"* o *"edredón ligero de fibras naturales"*), el motor devuelve cero resultados si la ficha del producto emplea descripciones como *"núcleo de látex natural microperforado"* o *"funda de algodón termorregulador"*.

La solución habitual en la industria consiste en recurrir a bases de datos vectoriales en la nube (Pinecone, Weaviate, Qdrant) combinadas con APIs de embeddings (OpenAI text-embedding-3-small). No obstante, esta aproximación genera importantes deficiencias estructurales:

1
Sobrecarga de Latencia de Red: La latencia acumulada (Cliente -> CDN perimetral -> Servidor -> API OpenAI -> Base Vectorial -> Cliente) oscila entre 450 y 900 ms, impidiendo la búsqueda predictiva instantánea.
2
Costes de Infraestructura Exponenciales: Un comercio con 50.000 búsquedas diarias genera hasta 250.000 llamadas al autocompletar, sumando entre $450 y más de $2.500 mensuales en facturas de nube.
3
Privacidad y Riesgo Operativo: Las consultas de los compradores abandonan el entorno protegido de la tienda, y las caídas de proveedores externos inutilizan el buscador.

La alternativa técnica contrastada en producción es la Búsqueda Semántica Vectorial en el Navegador: ejecución de un modelo transformer cuantizado en INT8 (como bge-small-en-v1.5 o all-MiniLM-L6-v2, de 23 MB) directamente en el dispositivo del usuario mediante WebAssembly SIMD en un Web Worker. Almacenando los pesos en IndexedDB y combinando la similitud vectorial con el análisis léxico Okapi BM25 mediante Reciprocal Rank Fusion (RRF), plataformas como yusupovartur.com y Fullstack AI Lab alcanzaron latencias inferiores a 18 ms, funcionamiento offline total y $0 en costes de bases de datos vectoriales.

Matriz rápida de decisión: comparación de arquitecturas de búsqueda

Parámetro arquitectónico
Latencia búsqueda en vivo
Búsqueda léxica (SQL LIKE / Fulltext)
400ms - 1.200ms (carga en BD)
API vectorial cloud (Pinecone / OpenAI)
450ms - 900ms (latencia de red)
Búsqueda vectorial híbrida en navegador
< 18ms (Wasm SIMD en cliente)
Parámetro arquitectónico
Coste recurrente en cloud
Búsqueda léxica (SQL LIKE / Fulltext)
$0 (incluido en la base de datos)
API vectorial cloud (Pinecone / OpenAI)
$450 - $2.500+/mes (costes de API)
Búsqueda vectorial híbrida en navegador
$0/mes (Cero coste de servidor)
Parámetro arquitectónico
Operatividad offline
Búsqueda léxica (SQL LIKE / Fulltext)
0% (inoperable sin conexión)
API vectorial cloud (Pinecone / OpenAI)
0% (inoperable sin conexión)
Búsqueda vectorial híbrida en navegador
100% (Modelo e índice en IndexedDB)
Parámetro arquitectónico
Comprensión de intención semántica
Búsqueda léxica (SQL LIKE / Fulltext)
Baja (solo coincidencia literal)
API vectorial cloud (Pinecone / OpenAI)
Excelente (vectores densos)
Búsqueda vectorial híbrida en navegador
Óptima (Híbrido RRF: Vectores + BM25)
Parámetro arquitectónico
Privacidad y RGPD
Búsqueda léxica (SQL LIKE / Fulltext)
Consultas registradas en servidor
API vectorial cloud (Pinecone / OpenAI)
Consultas enviadas a terceros
Búsqueda vectorial híbrida en navegador
100% Privado (Se ejecuta en el dispositivo)

El Dilemma de la Búsqueda en E-Commerce: Coincidencia Literal frente a Latencia Cloud

Análisis de los compromisos arquitectónicos entre búsqueda puramente léxica, vectorial en la nube e híbrida en el cliente:

1. La Brecha de Sinónimos en Búsquedas Léxicas

Los motores basados en índices invertidos (Elasticsearch, PostgreSQL Fulltext, MySQL) resultan idóneos para encontrar referencias exactas (SKU-8921-X) o marcas específicas. Sin embargo, fallan ante descripciones conceptuales. Un usuario que busque *"ropa de cuna sin químicos"* no localizará productos titulados *"sábanas infantiles de algodón orgánico certificado GOTS"* salvo que el equipo mantenga listas infinitas de sinónimos manuales.

2. El Cuello de Botella de Latencia en APIs Vectoriales Cloud

Los servicios vectoriales traducen la consulta en un vector denso y ejecutan algoritmos de vecinos más cercanos (HNSW). Aunque capturan el significado, cada pulsación de tecla exige una petición remota. En conexiones móviles 4G con fluctuaciones de señal, la interfaz se bloquea y el parámetro Interaction to Next Paint (INP) supera con creces los 300 ms.

3. La Ventaja de WebAssembly en el Navegador

Los navegadores modernos soportan WebAssembly con instrucciones SIMD de 128 bits. Al compilar ONNX Runtime a WebAssembly, el dispositivo del usuario procesa vectores de 384 dimensiones en menos de 12 ms. Dado que el catálogo reside en la memoria compartida del navegador, el cálculo de similitud se resuelve en menos de 4 ms sin tráfico de red.


Esquema de Arquitectura: Flujo Vectorial Híbrido en el Navegador

El siguiente diagrama muestra el procesamiento completo desde la pulsación del usuario hasta la entrega de resultados:

CODE
[ Entrada de texto en el buscador (ej. "colchón transpirable de verano") ]
                             │
                             ▼ postMessage con debounce (< 50ms)
   ┌─────────────────────────────────────────────────────────┐
   │            Hilo Web Worker (Sin bloqueo de interfaz)    │
   │                                                         │
   │  ┌─────────────────────────┐   ┌─────────────────────┐  │
   │  │   Índice Léxico Disperso│   │  Modelo Vector Denso│  │
   │  │  - Motor Okapi BM25     │   │  - ONNX Runtime WASM│  │
   │  │  - Distancia Levenshtein│   │  - Cuantización INT8│  │
   │  │  - Búsqueda exacta SKU  │   │  - Vector 384 dim   │  │
   │  │  - Tiempo: < 3ms        │   │  - Tiempo: < 12ms   │  │
   │  └────────────┬────────────┘   └──────────┬──────────┘  │
   │               │                           │             │
   │               │ Rango BM25                │ Rango Coseno│
   │               ▼                           ▼             │
   │  ┌───────────────────────────────────────────────────┐  │
   │  │     Ranking Híbrido Reciprocal Rank Fusion (RRF)  │  │
   │  │  - Fórmula: RRF(d) = Σ 1 / (60 + Rango_i)         │  │
   │  │  - Fusión de precisión léxica y comprensión semántica│
   │  │  - Tiempo total de cálculo en worker: < 18ms      │  │
   │  └────────────────────────┬──────────────────────────┘  │
   └───────────────────────────┼─────────────────────────────┘
                               │
                               ▼ Respuesta postMessage
   ┌─────────────────────────────────────────────────────────┐
   │         Next.js 16 React 19 Storefront (Hilo Principal) │
   │  - Autocompletado instantáneo a 60 FPS estables         │
   │  - 0ms de congelación UI, soporte offline, $0 en nube   │
   └─────────────────────────────────────────────────────────┘

Implementación en Producción: Web Worker, ONNX y Ranking Híbrido

1. Web Worker: Inferencia en WebAssembly con ONNX sin Afectar la UI

Este Web Worker opera en un hilo aislado, descarga una única vez el modelo cuantizado de 23 MB en IndexedDB y calcula vectores normalizados de 384 dimensiones:

TYPESCRIPT
import { pipeline, env } from '@xenova/transformers'

env.allowLocalModels = false
env.useBrowserCache = true

interface WorkerInputMessage {
  type: 'INIT' | 'SEARCH'
  query?: string
  catalogItems?: Array<{ id: string; title: string; vector: number[] }>
}

let extractor: any = null

self.onmessage = async (e: MessageEvent<WorkerInputMessage>) => {
  const { type, query, catalogItems } = e.data

  if (type === 'INIT') {
    try {
      extractor = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2', {
        quantized: true,
      })
      self.postMessage({ type: 'INIT_COMPLETE' })
    } catch (err: any) {
      self.postMessage({ type: 'ERROR', message: err.message })
    }
  }

  if (type === 'SEARCH' && query && catalogItems && extractor) {
    const startTime = performance.now()

    const output = await extractor(query, { pooling: 'mean', normalize: true })
    const queryVector = Array.from(output.data) as number[]

    const scoredResults = catalogItems.map((item) => {
      let dotProduct = 0
      for (let i = 0; i < queryVector.length; i++) {
        dotProduct += queryVector[i] * item.vector[i]
      }
      return { id: item.id, score: dotProduct }
    })

    scoredResults.sort((a, b) => b.score - a.score)

    const duration = performance.now() - startTime

    self.postMessage({
      type: 'SEARCH_RESULTS',
      results: scoredResults.slice(0, 10),
      durationMs: duration,
    })
  }
}

2. TypeScript: Motor de Ranking Híbrido Okapi BM25 y Reciprocal Rank Fusion

Combina coincidencias exactas por código de referencia con la búsqueda semántica:

TYPESCRIPT
export interface SearchableProduct {
  id: string
  title: string
  sku: string
  description: string
  vector: number[]
}

export interface HybridSearchResult {
  id: string
  product: SearchableProduct
  rrfScore: number
  denseRank: number
  bm25Rank: number
}

export class BM25Index {
  private docLengths: Map<string, number> = new Map()
  private avgDocLength: number = 0
  private invertedIndex: Map<string, Set<string>> = new Map()
  private totalDocs: number = 0

  constructor(products: SearchableProduct[]) {
    this.totalDocs = products.length
    let totalLength = 0

    for (const p of products) {
      const tokens = this.tokenize([p.title, p.sku, p.description].join(' '))
      this.docLengths.set(p.id, tokens.length)
      totalLength += tokens.length

      for (const token of new Set(tokens)) {
        if (!this.invertedIndex.has(token)) {
          this.invertedIndex.set(token, new Set())
        }
        this.invertedIndex.get(token)!.add(p.id)
      }
    }

    this.avgDocLength = totalLength / Math.max(1, this.totalDocs)
  }

  public tokenize(text: string): string[] {
    return text.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().split(' ').filter(Boolean)
  }

  public search(query: string, products: SearchableProduct[], k1 = 1.5, b = 0.75): Map<string, number> {
    const queryTokens = this.tokenize(query)
    const scores = new Map<string, number>()

    for (const token of queryTokens) {
      const matchingDocIds = this.invertedIndex.get(token)
      if (!matchingDocIds) continue

      const idf = Math.log(1 + (this.totalDocs - matchingDocIds.size + 0.5) / (matchingDocIds.size + 0.5))

      for (const docId of matchingDocIds) {
        const docLen = this.docLengths.get(docId) ?? this.avgDocLength
        const tf = 1
        const score = (idf * (tf * (k1 + 1))) / (tf + k1 * (1 - b + b * (docLen / this.avgDocLength)))
        scores.set(docId, (scores.get(docId) ?? 0) + score)
      }
    }

    return scores
  }
}

export function computeReciprocalRankFusion(
  products: SearchableProduct[],
  denseRankings: string[],
  bm25Scores: Map<string, number>,
  rrfConstant = 60
): HybridSearchResult[] {
  const bm25Rankings = Array.from(bm25Scores.entries())
    .sort((a, b) => b[1] - a[1])
    .map(([id]) => id)

  const productMap = new Map(products.map((p) => [p.id, p]))
  const rrfScores = new Map<string, { rrf: number; denseRank: number; bm25Rank: number }>()

  denseRankings.forEach((id, index) => {
    const rank = index + 1
    const current = rrfScores.get(id) ?? { rrf: 0, denseRank: 9999, bm25Rank: 9999 }
    current.rrf += 1 / (rrfConstant + rank)
    current.denseRank = rank
    rrfScores.set(id, current)
  })

  bm25Rankings.forEach((id, index) => {
    const rank = index + 1
    const current = rrfScores.get(id) ?? { rrf: 0, denseRank: 9999, bm25Rank: 9999 }
    current.rrf += 1 / (rrfConstant + rank)
    current.bm25Rank = rank
    rrfScores.set(id, current)
  })

  const results: HybridSearchResult[] = []
  rrfScores.forEach((data, id) => {
    const product = productMap.get(id)
    if (product) {
      results.push({
        id,
        product,
        rrfScore: data.rrf,
        denseRank: data.denseRank,
        bm25Rank: data.bm25Rank,
      })
    }
  })

  return results.sort((a, b) => b.rrfScore - a.rrfScore).slice(0, 10)
}

3. Componente Cliente React 19: Buscador Reactivo sin Bloqueo de Pantalla

Gestiona la conexión con el worker en segundo plano y muestra los resultados a 60 FPS:

TSX
'use client'

import React, { useState, useEffect, useRef, useTransition } from 'react'
import type { SearchableProduct, HybridSearchResult } from './hybrid-ranking'

interface SemanticSearchBarProps {
  catalog: SearchableProduct[]
}

export function SemanticSearchBar({ catalog }: SemanticSearchBarProps) {
  const [query, setQuery] = useState('')
  const [results, setResults] = useState<HybridSearchResult[]>([])
  const [isModelReady, setIsModelReady] = useState(false)
  const [latencyMs, setLatencyMs] = useState<number | null>(null)
  const workerRef = useRef<Worker | null>(null)
  const [isPending, startTransition] = useTransition()

  useEffect(() => {
    workerRef.current = new Worker(new URL('./vector-worker.ts', import.meta.url), {
      type: 'module',
    })

    workerRef.current.onmessage = (e) => {
      const { type, results: searchResults, durationMs } = e.data

      if (type === 'INIT_COMPLETE') {
        setIsModelReady(true)
      }

      if (type === 'SEARCH_RESULTS') {
        startTransition(() => {
          setResults(searchResults)
          setLatencyMs(Math.round(durationMs))
        })
      }
    }

    workerRef.current.postMessage({ type: 'INIT' })

    return () => {
      workerRef.current?.terminate()
    }
  }, [])

  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const val = e.target.value
    setQuery(val)

    if (val.trim().length > 2 && workerRef.current && isModelReady) {
      workerRef.current.postMessage({
        type: 'SEARCH',
        query: val,
        catalogItems: catalog.map((c) => ({ id: c.id, title: c.title, vector: c.vector })),
      })
    } else {
      setResults([])
      setLatencyMs(null)
    }
  }

  return (
    <div className="relative w-full max-w-2xl mx-auto">
      <div className="relative">
        <input
          type="text"
          value={query}
          onChange={handleInputChange}
          placeholder="Describa lo que busca (ej. colchón transpirable de verano)..."
          className="w-full bg-slate-900 border border-slate-700 focus:border-purple-500 rounded-xl px-4 py-3.5 text-white placeholder-slate-400 focus:outline-none transition-colors"
        />
        {latencyMs !== null && (
          <span className="absolute right-3.5 top-3.5 text-xs font-mono text-emerald-400 bg-emerald-950/60 border border-emerald-800/60 px-2 py-0.5 rounded-md">
            {latencyMs}ms (WASM)
          </span>
        )}
      </div>

      {results.length > 0 && (
        <div className="absolute left-0 right-0 mt-2 bg-slate-900 border border-slate-800 rounded-xl shadow-2xl overflow-hidden z-50">
          <ul className="divide-y divide-slate-800">
            {results.map(({ id, product, rrfScore }) => (
              <li key={id} className="p-3.5 hover:bg-slate-800/60 transition-colors flex justify-between items-center cursor-pointer">
                <div>
                  <h4 className="text-sm font-semibold text-white">{product.title}</h4>
                  <p className="text-xs text-slate-400 line-clamp-1">{product.description}</p>
                </div>
                <span className="text-xs font-mono text-purple-400 bg-purple-950/50 px-2 py-0.5 rounded border border-purple-800/40">
                  RRF: {rrfScore.toFixed(3)}
                </span>
              </li>
            ))}
          </ul>
        </div>
      )}
    </div>
  )
}

Métricas Empíricas de Rendimiento y Comparativa de Costes

Evaluación comparativa entre una arquitectura vectorial en la nube (OpenAI + Pinecone) frente a la solución en el navegador con WebAssembly y Okapi BM25:

Parámetro Evaluado
Latencia Mediana P50
Búsqueda Vectorial en la Nube
480 ms (ciclo completo de red)
WebAssembly en el Navegador (WASM + BM25)
14 ms (cómputo SIMD local)
Impacto Técnico y TCO
Respuesta 34 veces más rápida
Parámetro Evaluado
Latencia Máxima P99
Búsqueda Vectorial en la Nube
1.250 ms (conexiones frías)
WebAssembly en el Navegador (WASM + BM25)
22 ms (cómputo en worker)
Impacto Técnico y TCO
Cero retrasos en dispositivos móviles
Parámetro Evaluado
Coste Mensual Cloud
Búsqueda Vectorial en la Nube
$450 - $1.800 / mes
WebAssembly en el Navegador (WASM + BM25)
$0.00 / mes (cero gastos vectoriales)
Impacto Técnico y TCO
100% de ahorro en infraestructura
Parámetro Evaluado
Búsqueda Instantánea
Búsqueda Vectorial en la Nube
Inviable por saturación de red
WebAssembly en el Navegador (WASM + BM25)
Respuesta nativa a 60 FPS
Impacto Técnico y TCO
Aumento notable en conversión
Parámetro Evaluado
Operatividad Offline
Búsqueda Vectorial en la Nube
0% (falla sin conexión)
WebAssembly en el Navegador (WASM + BM25)
100% funcional (caché IndexedDB)
Impacto Técnico y TCO
Compatible con PWA y redes débiles
Parámetro Evaluado
Privacidad de Consultas
Búsqueda Vectorial en la Nube
Enviadas a servidores externos
WebAssembly en el Navegador (WASM + BM25)
Procesamiento 100% en el dispositivo
Impacto Técnico y TCO
Cero riesgos normativos (RGPD)

Modos de Fallo, Post-Mortems y Decisiones Críticas

1. El Retraso de Descarga del Modelo (23 MB)

  • Incidente: Los nuevos visitantes experimentaban un retraso de 2.4 segundos antes de que el buscador respondiera, ya que la descarga del modelo de 23 MB competía con los recursos esenciales de la página, perjudicando el Largest Contentful Paint (LCP).
  • Causa Raíz: Carga del modelo de IA en la ruta crítica de renderizado.
  • Solución: Implementación de carga progresiva. El buscador responde de forma inmediata mediante Okapi BM25 (0 ms de espera). Un Service Worker descarga los pesos de ONNX en segundo plano durante los tiempos de inactividad de red. Una vez completado, el motor pasa a modo híbrido de forma imperceptible.

2. Pérdida de Coincidencias Exactas por SKU en Búsqueda Vectorial Pura

  • Incidente: Al buscar códigos de referencia específicos (*"OB-MATT-2026-K"*), la búsqueda vectorial devolvía protectores de colchón irrelevantes, ya que los modelos de lenguaje carecen de representaciones vectoriales para códigos de fábrica.
  • Causa Raíz: Los embeddings vectoriales representan conceptos generales, no referencias alfanuméricas.
  • Solución: Integración obligatoria con Okapi BM25 mediante Reciprocal Rank Fusion (RRF). Las coincidencias exactas sobre el campo sku reciben la máxima puntuación léxica, garantizando el primer puesto para el artículo exacto.

3. Límites de Memoria en Safari Móvil

  • Incidente: En modelos antiguos de iPhone (iOS 15), el uso de memoria de WebAssembly junto con imágenes de alta resolución superaba el límite de 50 MB por pestaña de Safari, provocando el reinicio del navegador.
  • Causa Raíz: Falta de liberación de tensores en la memoria heap de WebAssembly.
  • Solución: Adopción de un modelo cuantizado a 8 bits (q8), limitación de consultas a 64 tokens y ejecución sistemática de tensor.dispose() tras cada búsqueda, manteniendo el consumo por debajo de 28 MB.

Lista de Verificación para Desarrolladores de IA en el Cliente

1
Cuantice siempre los modelos a INT8: Descarte modelos en FP32 o FP16 para el cliente. El formato INT8 reduce el tamaño un 75% con una pérdida de precisión inferior al 1.2%.
2
Ejecute la inferencia en Web Workers: Mantenga el hilo principal y la interfaz a 60 FPS aislando ONNX Runtime en un hilo secundario.
3
Persista los pesos en IndexedDB: Almacene los buffers del modelo para evitar descargas repetidas en visitas posteriores.
4
Combine búsqueda densa y léxica (RRF): Integre Okapi BM25 con similitud de coseno para asegurar búsquedas exactas por SKU y sinónimos.
5
Aplique mejora progresiva: Permita la búsqueda léxica instantánea mientras el modelo neuronal se inicializa en segundo plano.

¿Desea Implementar Búsqueda Semántica a Coste Cero?

¿Busca mejorar la conversión de su catálogo mediante búsqueda vectorial en tiempo real sin asumir costes desorbitados de bases de datos en la nube? Artur Yusupov diseña arquitecturas de inteligencia artificial en el navegador basadas en WebAssembly y Next.js 16.

  • Consulte Casos Reales: Examine la plataforma Hybrid RAG Portfolio Platform, el laboratorio Fullstack AI Lab y el catálogo de Organic Bed.
  • Consulte al Asistente IA: Pregunte sobre compilación de ONNX a WebAssembly, Reciprocal Rank Fusion o indexación con BM25.
  • Solicite una Revisión Técnica: Contacte a través de Telegram @yusupovartur o correo electrónico para diseñar un motor de búsqueda semántica sub-20ms para su negocio.
Implementación real en producción

Dónde funciona esta arquitectura en proyectos reales

Estas soluciones no son teoría abstracta: están desplegadas y verificadas en los siguientes productos reales:

Auditoría de Arquitectura

¿Planeas una migración técnica o nuevo proyecto?

Consulta los requerimientos de tu proyecto con el asistente de IA o solicita una evaluación técnica directa.

Contactar directamente