Saltar al contenido principal

Búsqueda Conversacional

El widget soporta un modo de búsqueda conversacional que mantiene contexto entre búsquedas sucesivas, permitiendo refinar resultados de forma natural.

Activación​

La búsqueda conversacional requiere activar el asistente IA:

NeuroonWidget.init({
  container: '#neuroon-search',
  token: 'YOUR_TOKEN',
  features: {
    aiAssistant: true, // Activa el modo conversacional
  },
});
Plan requerido

El asistente IA está disponible en planes Growth y superiores.

Cómo funciona​

Contexto de sesión​

El widget mantiene un historial de la conversación durante la sesión:

Usuario: "zapatillas para correr"
→ Resultados: zapatillas deportivas

Usuario: "que sean de Nike"
→ Contexto: zapatillas + Nike
→ Resultados: zapatillas Nike running

Usuario: "más baratas de 100€"
→ Contexto: zapatillas + Nike + precio < 100€
→ Resultados refinados

Turnos de conversación​

Cada interacción genera un turno con información del usuario y del asistente:

interface ConversationTurn {
  id: string;
  role: 'user' | 'assistant';
  content: string;
  timestamp: Date;
  products?: Product[];          // Productos sugeridos
  suggestedFilters?: SearchFilters; // Filtros inferidos
  confidence?: number;           // 0-1, confianza en la interpretación
}

Interfaz de chat​

Abrir el panel de chat​

widget.openChat();

O mediante el icono de chat en la interfaz del widget.

Enviar mensajes​

// Programáticamente
await widget.sendMessage('Busco un portátil ligero para trabajar');

// El usuario también puede escribir directamente en el chat

Historial de conversación​

// Obtener historial completo
const history = widget.conversationHistory;

history.forEach(turn => {
  console.log(`[${turn.role}] ${turn.content}`);
  if (turn.products?.length) {
    console.log(`  → ${turn.products.length} productos sugeridos`);
  }
});

Limpiar historial​

// Reiniciar la conversación
widget.clearHistory();

Persistencia de sesión​

El historial se persiste en sessionStorage durante la sesión del navegador:

// Se guarda automáticamente con clave:
// neuroon_chat_{shopId}

// El historial se restaura al recargar la página
// Se limpia al cerrar el navegador

Configurar persistencia​

NeuroonWidget.init({
  features: {
    aiAssistant: true,
  },
  // Desactivar persistencia si lo prefieres
  persistence: {
    chat: false, // Por defecto: true
  },
});

Filtros inferidos​

El asistente analiza las consultas y extrae filtros automáticamente:

ConsultaFiltros inferidos
"zapatillas Nike baratas"brands: ['Nike'], priceMax: inferido
"portátil para gaming"categories: ['gaming'], tags: ['gaming']
"vestido rojo talla M"tags: ['rojo'], size: 'M'
"menos de 50 euros"priceMax: 50
// Escuchar filtros inferidos
widget.on('chat:message', ({ turn }) => {
  if (turn.suggestedFilters) {
    console.log('Filtros sugeridos:', turn.suggestedFilters);
    // { brands: ['Nike'], priceMax: 100 }
  }
});

Sugerencias de queries​

El asistente puede sugerir queries refinadas:

widget.on('chat:message', ({ turn }) => {
  if (turn.role === 'assistant' && turn.content.includes('¿Quisiste decir')) {
    // Mostrar sugerencia al usuario
  }
});

Indicador de confianza​

Cada respuesta incluye un nivel de confianza:

widget.on('chat:message', ({ turn }) => {
  if (turn.confidence !== undefined) {
    if (turn.confidence > 0.8) {
      // Alta confianza - aplicar filtros automáticamente
      widget.setFilters(turn.suggestedFilters);
    } else {
      // Baja confianza - mostrar opciones al usuario
      showFilterOptions(turn.suggestedFilters);
    }
  }
});
RangoSignificado
0.9 - 1.0Muy alta - Interpretación clara
0.7 - 0.9Alta - Buena inferencia
0.5 - 0.7Media - Podría necesitar confirmación
0.0 - 0.5Baja - Consulta ambigua

Ejemplos de uso​

Chat integrado con productos​

const widget = NeuroonWidget.init({
  features: { aiAssistant: true },
  callbacks: {
    onSearch: (query) => {
      // El callback se ejecuta también en búsquedas conversacionales
      analytics.track('conversational_search', { query });
    },
  },
});

// Escuchar respuestas del asistente
widget.on('chat:message', ({ turn }) => {
  if (turn.role === 'assistant') {
    // Mostrar respuesta
    displayAssistantMessage(turn.content);

    // Mostrar productos sugeridos
    if (turn.products?.length) {
      displayRecommendedProducts(turn.products);
    }

    // Aplicar filtros sugeridos
    if (turn.suggestedFilters && turn.confidence > 0.7) {
      widget.setFilters(turn.suggestedFilters);
    }
  }
});

Flujo de conversación guiada​

// Iniciar conversación programáticamente
async function startGuidedSearch(category) {
  widget.openChat();

  await widget.sendMessage(`Busco productos de ${category}`);

  // El asistente responderá con preguntas de refinamiento
  // "¿Qué rango de precio tienes en mente?"
  // "¿Alguna marca en particular?"
}

// Llamar desde tu UI
document.getElementById('category-laptops').addEventListener('click', () => {
  startGuidedSearch('portátiles');
});

Sincronización con UI externa​

// Tu componente de chat personalizado
class CustomChat {
  constructor(widget) {
    this.widget = widget;
    this.container = document.getElementById('my-chat');

    // Sincronizar mensajes
    widget.on('chat:message', ({ turn }) => {
      this.renderMessage(turn);
    });
  }

  async sendMessage(text) {
    this.renderMessage({ role: 'user', content: text });
    await this.widget.sendMessage(text);
  }

  renderMessage(turn) {
    const el = document.createElement('div');
    el.className = `message ${turn.role}`;
    el.textContent = turn.content;
    this.container.appendChild(el);
  }
}

const widget = NeuroonWidget.init({ features: { aiAssistant: true } });
const chat = new CustomChat(widget);

Eventos de chat​

EventoPayloadDescripción
chat:open{}Panel de chat abierto
chat:close{}Panel de chat cerrado
chat:message{ turn }Nuevo mensaje (usuario o asistente)
chat:typing{ isTyping }Indicador de escritura
chat:error{ error }Error en el chat
widget.on('chat:typing', ({ isTyping }) => {
  if (isTyping) {
    showTypingIndicator();
  } else {
    hideTypingIndicator();
  }
});

Buenas prácticas​

  1. Contexto limitado: El historial se limita a las últimas 10 interacciones para mantener relevancia
  2. Limpieza periódica: Considera limpiar el historial al cambiar de sección o categoría
  3. Fallback: Si el asistente no entiende, ofrece opciones de filtro manual
  4. Indicadores visuales: Muestra cuando el asistente está "pensando"
  5. Persistencia opcional: Desactívala si el contexto no debe persistir entre recargas

Próximos pasos​