Cómo integrar LangChain en tu ecommerce para atención al cliente 24/7

Tus clientes preguntan a las 11pm de un domingo: “¿tienen stock?”, “¿cuánto cuesta el envío a Medellín?”, “¿cómo devuelvo un producto?”. Tu equipo de soporte no está. Un chatbot con LangChain + RAG puede responder 24/7 sin que tu equipo pierda horas en preguntas repetitivas.

En este artículo te explico cómo construir un agente de soporte completo con LangChain, LlamaIndex y GPT-5. Con código, arquitectura y caso real.

Si quieres entender los frameworks, lee nuestro pilar LangChain, LlamaIndex y LangGraph: frameworks para orquestar LLMs y la guía de RAG explicado.

Lo que tu chatbot de soporte debe hacer (y lo que no)

Debe hacer:

• Responder preguntas sobre productos (stock, precio, especificaciones)
• Resolver dudas sobre políticas (envíos, devoluciones, garantías)
• Calificar leads (si preguntan por algo avanzado, derivar a humano)
• Escalar a humano cuando no sabe o cuando el cliente lo pide
• Mantener contexto durante la conversación (memoria)
• Aprender de cada interacción (mejora continua)

No debe hacer:

• Inventar precios o políticas (alucinaciones caras)
• Dar consejo legal o médico que no existe en tus docs
• Cerrar ventas sin opción de hablar con humano
• Reemplazar completamente al equipo humano (el 100% de automatización es un error)

Insight: un buen chatbot de soporte resuelve el 70-80% de preguntas repetitivas y escala el 20-30% con contexto completo al humano. No busca reemplazar al humano, busca darle tiempo para lo importante.

Arquitectura completa del agente

┌─────────────────────────────────────────────────────────────┐
│                  FRONTEND (chat widget)                       │
│  Web · WhatsApp · Instagram · Messenger (multi-canal)         │
└────────────────────────────┬────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────┐
│                  FASTAPI BACKEND                              │
│  - Recibe mensaje                                              │
│  - Llama al agente LangChain                                  │
│  - Devuelve respuesta al cliente                              │
└────────────────────────────┬────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────┐
│          AGENTE LANGCHAIN (LangGraph)                          │
│                                                                     │
│  1. Recibe pregunta                                                │
│  2. Llama al LLM para entender intención                           │
│  3. Decide herramienta: RAG, API, escalar humano                   │
│  4. Ejecuta la herramienta                                         │
│  5. Genera respuesta final con contexto                            │
│  6. Guarda en memoria para próximas conversaciones                  │
│                                                                     │
└─────┬───────────────┬────────────────┬──────────────────────┘
      │               │                │
┌─────▼─────┐  ┌──────▼──────┐  ┌──────▼──────┐
│ LlamaIndex │  │ API de       │  │ Escalado   │
│ + RAG      │  │ inventario   │  │ a humano   │
│            │  │ y pedidos    │  │ (Intercom, │
│ Manuales,  │  │              │  │  Zendesk)  │
│ políticas, │  │              │  │            │
│ FAQs       │  │              │  │            │
└────────────┘  └─────────────┘  └────────────┘

Paso 1: Preparar tus datos

Necesitas indexar toda tu información con LlamaIndex. Las fuentes típicas:

• Catálogo de productos (CSV, JSON, base de datos)
• Preguntas frecuentes (Excel, Notion)
• Políticas (envíos, devoluciones, garantías)
• Tickets históricos resueltos (para aprender de casos pasados)
• Manuales de productos

Código para indexar:

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.node_parser import SentenceSplitter
from llama_index.embeddings.openai import OpenAIEmbedding

# Cargar documentos (PDF, Word, CSV, etc.)
documents = SimpleDirectoryReader(
    input_dir="./datos/",
    recursive=True,
    required_exts=[".pdf", ".docx", ".csv", ".md", ".txt"]
).load_data()

# Configurar embeddings
embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# Configurar splitter (chunks de ~500 palabras)
node_parser = SentenceSplitter(chunk_size=1000, chunk_overlap=200)

# Crear índice
index = VectorStoreIndex.from_documents(
    documents,
    embed_model=embed_model,
    transformations=[node_parser],
    show_progress=True
)

# Guardar índice para reutilizar
index.storage_context.persist(persist_dir="./indice/")

Resultado: un índice vectorial que tu agente puede buscar.

Paso 2: Crear las herramientas del agente

El agente LangChain necesita herramientas que sepa usar. Para un chatbot de ecommerce, las típicas son:

from langchain.tools import Tool
from langchain_community.utilities import GoogleSearchAPIWrapper
from langchain.tools import GoogleSearchResults

# Herramienta 1: RAG sobre documentos internos
def buscar_en_documentos(query: str) -> str:
    """Busca información en el catálogo, FAQs y políticas."""
    query_engine = index.as_query_engine(similarity_top_k=3)
    response = query_engine.query(query)
    return f"Información encontrada: {response.response}"

rag_tool = Tool(
    name="buscar_documentos",
    description="Busca información en el catálogo de productos, FAQs y políticas de la empresa. Usar para preguntas sobre productos, precios, envíos o devoluciones.",
    func=buscar_en_documentos
)

# Herramienta 2: API de inventario en tiempo real
def consultar_inventario(sku: str) -> str:
    """Consulta el stock de un producto por SKU."""
    # Aquí llamas a tu API real (WooCommerce, Shopify, propia, etc.)
    response = requests.get(f"https://api.tutienda.com/inventory/{sku}")
    data = response.json()
    if data["stock"] > 0:
        return f"SKU {sku}: {data['stock']} unidades disponibles. Precio: ${data['price']}"
    else:
        return f"SKU {sku}: agotado. Próximo restock: {data['restock_date']}"

inventario_tool = Tool(
    name="consultar_inventario",
    description="Consulta el stock en tiempo real de un producto por su SKU. Usar cuando el cliente pregunta por disponibilidad.",
    func=consultar_inventario
)

# Herramienta 3: escalar a humano
def escalar_a_humano(resumen: str) -> str:
    """Crea un ticket para que un humano atienda al cliente."""
    ticket = intercom.create_ticket(
        subject=f"Cliente escalado desde chatbot",
        body=resumen
    )
    return f"He creado el ticket #{ticket.id}. Un humano te contactará en menos de 2 horas."

humano_tool = Tool(
    name="escalar_a_humano",
    description="Crea un ticket para que un humano atienda al cliente. Usar cuando la pregunta es demasiado específica, el cliente está molesto, o cuando el bot no sabe responder.",
    func=escalar_a_humano
)

tools = [rag_tool, inventario_tool, humano_tool]

Paso 3: Crear el agente LangChain

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain.memory import ConversationBufferWindowMemory

# LLM
llm = ChatOpenAI(
    model="gpt-5-mini",
    temperature=0  # respuestas consistentes
)

# Prompt del sistema
system_prompt = """Eres el asistente de soporte de [Tu Tienda], un ecommerce en Colombia.

Tu objetivo:
1. Responder preguntas sobre productos, precios, envíos y devoluciones
2. Usar 'buscar_documentos' para información general
3. Usar 'consultar_inventario' cuando pregunten por stock
4. Usar 'escalar_a_humano' cuando no sepas responder o el cliente esté molesto

Reglas:
- Sé amable y breve (máximo 3 líneas por mensaje)
- Si no sabes, escala a humano en vez de inventar
- No prometas precios o tiempos que no estén en los documentos
- Tono: cercano pero profesional

Responde SIEMPRE en español colombiano."""

# Memoria (recuerda últimos 5 mensajes)
memory = ConversationBufferWindowMemory(
    k=5,
    memory_key="chat_history",
    return_messages=True
)

# Crear agente
agent = create_react_agent(
    llm=llm,
    tools=tools,
    prompt=system_prompt
)

# Executor (maneja el ciclo de tool calls)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True,  # logs en desarrollo
    max_iterations=5,  # máximo de razonamientos
    handle_parsing_errors=True
)

Paso 4: Crear el backend FastAPI

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI(title="Ecommerce Support Agent")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # ajustar en producción
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

class ChatRequest(BaseModel):
    message: str
    session_id: str  # para mantener memoria por usuario
    user_id: str

class ChatResponse(BaseModel):
    response: str
    escalated: bool = False
    ticket_id: str = None

@app.post("/chat", response_model=ChatResponse)
async def chat(req: ChatRequest):
    try:
        # Configurar memoria por sesión
        memory.chat_memory.clear()
        # Aquí cargarías el historial de la sesión desde tu BD

        # Ejecutar agente
        result = agent_executor.invoke({"input": req.message})

        # Detectar si escaló
        escalated = "escalar_a_humano" in str(result)
        ticket_id = None
        if escalated:
            # Extraer ID del ticket del output
            ticket_id = extract_ticket_id(result["output"])

        return ChatResponse(
            response=result["output"],
            escalated=escalated,
            ticket_id=ticket_id
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
async def health():
    return {"status": "ok"}

Paso 5: Frontend (widget de chat)

<script>
async function sendMessage(message) {
  const response = await fetch('https://api.tutienda.com/chat', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      message,
      session_id: getCookie('session_id'),
      user_id: getCookie('user_id')
    })
  });
  const data = await response.json();
  return data.response;
}
</script>

Caso real: tienda de ropa en Medellín

Cliente: tienda online de ropa femenina, 500 productos, 200 pedidos/mes Problema: equipo de soporte de 2 personas saturado con preguntas repetitivas Implementación:

1. Datos indexados (3 días):

   • Catálogo de productos
   • Políticas de envío, devolución, cambios
   • 100 FAQs históricas
   • Guías de tallas

2. Agente LangChain + LlamaIndex (1 semana):

   • GPT-5 mini como LLM
   • LlamaIndex para RAG sobre los datos
   • API de inventario en tiempo real
   • Escalado a WhatsApp del dueño cuando es complejo

3. Deploy (1 semana):

   • Backend en FastAPI + Docker
   • Frontend: widget en la web + integración WhatsApp
   • LangSmith para observabilidad

Resultados en 3 meses:

Métrica	Antes	Después
Preguntas respondidas por humano	100%	25%
Tiempo de respuesta promedio	4 horas	30 segundos
CSAT (satisfacción)	75%	84%
Leads cualificados capturados	10/mes	35/mes
Costo de soporte mensual	$5M COP	$1.8M COP

ROI: se pagó solo en 2 meses.

Insight clave: el 75% de preguntas eran repetitivas (horarios, tallas, envío a X ciudad). El bot resolvió el 75% en piloto. Los humanos pasaron a enfocarse en el 25% que requiere criterio.

Los 5 errores comunes

❌ No tener memoria de conversación — el bot pregunta lo mismo cada vez. Frustrante para el usuario.

❌ No escalar nunca a humano — el bot intenta responder TODO. Los clientes se van frustrados.

❌ Escalar TODO a humano — anula el propósito del bot. Solo escala cuando no sabes o el cliente lo pide.

❌ No monitorear costos — GPT-5 sin límites puede generar facturas de $1000/día si hay tráfico alto.

❌ No iterar con datos reales — guarda los logs de conversaciones, identifica fallos, ajusta prompts.

Cómo medir si funciona

Métricas que importan:

• Tasa de resolución automática: % de conversaciones resueltas sin humano (objetivo: 70%+)
• CSAT: satisfacción del cliente después de la conversación (objetivo: 80%+)
• Tiempo promedio de respuesta: debería ser < 30 segundos
• Tasa de escalación: % que requieren humano (objetivo: < 30%)
• Costo por conversación: comparar con el costo de un humano

Cómo medir CSAT: botón de 👍 / 👎 al final de cada conversación, más un “¿qué tal la atención?” opcional.

Cuándo NO vale la pena un agente LangChain

• < 50 consultas de soporte/día: prompt simple con FAQ basta
• Catálogo muy pequeño: el RAG no aporta
• No tienes datos para entrenar: sin FAQs, sin políticas, sin catálogo, el bot no sabe nada

Regla práctica: si tienes menos de 100 conversaciones de soporte por mes, no necesitas LangChain. Empieza con un prompt simple + FAQs.

---

Siguiente paso

¿Quieres implementar un agente LangChain para tu ecommerce? En Codify Tech diseñamos e implementamos agentes de soporte 24/7. Hacemos una auditoría + prototipo donde te mostramos:

• Qué herramientas necesita tu agente
• Arquitectura técnica recomendada
• Estimación de costos y ROI
• Plan de implementación en 4-6 semanas

Sin compromiso. Sin venta forzada.

👉 Solicita tu auditoría de agente LangChain o escríbenos a [email protected].

Otros artículos del cluster AI que te van a servir:

• 📌 LangChain, LlamaIndex y LangGraph: frameworks para orquestar LLMs
• ⚖️ LlamaIndex vs LangChain: cuándo usar cada uno para tu proyecto de IA
• 🤖 LLM para SEO: cómo usar GPT-5, Ollama y LM Studio
• 📌 RAG explicado: cómo los chatbots y buscadores modernos realmente saben lo que saben