Chatbot que extrae datos del cliente con LangChain

Curso de LangChain

Contenido del curso

Introducción a LangChain

Casos de uso de LangChain

Manejo de documentos con índices

Embeddings y bases de datos vectoriales

Chats y memoria con LangChain

Evolución del uso de LLM

37
Ecosistema LLM y qué sigue después de LangChain
05:26 min

Tomar examen

Chatbot que extrae datos del cliente con LangChain

Resumen

Cuando construyes un chatbot que atiende clientes, necesitas recordar datos puntuales: nombre, dirección, teléfono o el número de garantía del producto. La Conversation Entity Memory de LangChain resuelve justo eso, porque extrae entidades de la charla con ayuda de un modelo de lenguaje y las guarda en una estructura lista para consultar.

¿Qué es Conversation Entity Memory y para qué sirve?

Es un tipo de memoria que detecta y almacena entidades clave dentro de una conversación. Piensa en un asesor de ventas digital: si a alguien se le rompió la lavadora, tu bot necesita saber qué pasó, cuándo la compró y quién la atendió. Esa información se vuelve oro para el seguimiento.

¿Qué son las entidades en un chatbot? Son datos concretos que aparecen en la conversación: nombres de personas, direcciones, teléfonos, fechas, números de garantía. La memoria los identifica con un modelo de IA y los guarda como pares clave-valor [02:25].

El punto interesante es que la extracción no es automática por reglas. Detrás hay un modelo que interpreta el texto, decide qué es entidad y qué no, y la asocia con el contexto en el que apareció.

¿Cómo se configura el prompt para una memoria con entidades?

Antes de escribir tu propio prompt, conviene revisar el que LangChain trae por defecto. Lo importas desde la librería de conversation prompts como Entity Memory Conversation Template y, al imprimirlo con el argumento template, ves su estructura interna [01:36].

Ese template incluye tres variables que debes respetar siempre:

Entities: las entidades detectadas hasta el momento.
History: el historial de la conversación.
Input: la pregunta o mensaje actual del usuario.

Con ese formato como base, puedes redactar uno personalizado. En el ejemplo se construye un asistente de ventas para una empresa de máquinas de micheladas, con dos objetivos claros: primero intentar resolver el problema, y si no se puede, agendar una visita técnica pidiendo celular y dirección [03:25]. Además, se le pide hablar con la chispa de una persona nacida en Tepito, México, y siempre preguntar la fecha de compra, el número de garantía y quién atendió originalmente al cliente.

¿Cómo creas tu propio PromptTemplate?

Importas PromptTemplate desde la librería de prompts y le pasas dos cosas: las input_variables (que son entities, history e input) y el template con tu texto en español. Así nace el prompt_tepito_entities, listo para enchufarse a la cadena.

¿Cómo se arma la ConversationChain con dos modelos de lenguaje?

Aquí viene un detalle clave: necesitas dos modelos, no uno. Uno conversa con el cliente, y otro extrae las entidades para la memoria [06:15].

Importa ConversationChain desde la librería de cadenas de LangChain.
Instancia un modelo de chat, por ejemplo ChatGPT 3.5 de OpenAI, para la conversación.
Inicializa un modelo de lenguaje simple con OpenAI, usando model_name="text-davinci-003", temperature=0 y max_tokens=256, para que detecte entidades [07:18].
Crea la memoria con ConversationEntityMemory(llm=llm).
Arma la cadena con tu prompt, el modelo de chat, la memoria y verbose=True para ver qué pasa por dentro.

¿Por qué la memoria pide un modelo de lenguaje aparte? Porque la detección de entidades es una tarea de IA: el modelo lee la conversación, decide qué fragmentos son entidades y los guarda con su descripción. Sin un LLM, esa lógica no existe [06:35].

Un detalle práctico: si escribes temperatura en lugar de temperature, LangChain te avisa del parámetro mal nombrado. Corriges, vuelves a inicializar y listo.

¿Cómo se ve la memoria llenándose en una conversación real?

La charla arranca con un mensaje tipo: Qué onda, mi máquina para hacer micheladas no está funcionando, ando enojado [08:25]. En la primera ronda, las secciones de contexto y conversación actual aparecen vacías. Normal, todavía no hay datos.

En el segundo turno, el cliente suelta: Lo compré en 2015, tiene un número de garantía 0X y me atendió Carlos. Ahí la memoria empieza a poblarse. 0X se asocia al número de garantía y Carlos se identifica como la persona que atendió al humano en 2015 [09:45].

Cuando el cliente pide agendar la visita y comparte su celular y Parque Bolívar 22, la memoria refina las entradas. Algunas entidades quedan más completas que otras al inicio, y se enriquecen conforme avanza la plática.

¿Cómo generas un reporte final de entidades?

Usas pprint de la librería pprint para imprimir el diccionario de forma legible y accedes al almacén con conversation.memory.entity_store [12:08]. El resultado es un reporte con cada clave y su descripción contextual:

0X: número de garantía de la máquina comprada en 2015.
Carlos: persona que atendió al humano cuando compró la máquina.
Parque Bolívar: dirección del humano, ubicada en el número 22.
Número de celular del cliente.

Ese reporte es justo lo que necesita el equipo de seguimiento para cerrar el caso, agendar al técnico o escalar la incidencia. Y aunque el ejemplo gira en torno a máquinas de micheladas, el patrón aplica a soporte técnico, ventas, reservas o cualquier flujo donde los datos del cliente importen.

¿Qué entidades te gustaría que tu propio chatbot capturara? Cuéntame en los comentarios cómo lo adaptarías a tu caso de uso.

Evert Escalante

Estudiante

En versiones de langchain >= 1.0, se puede replicar este comportamiento con los graph (workflow de nodos) de langgraph

1- Agregamos las importaciones necesarias

import uuid
from pydantic import BaseModel, Field
from typing import Optional
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage, RemoveMessage
from langgraph.graph import MessagesState, StateGraph, START, END
from langgraph.checkpoint.memory import MemorySaver
from langgraph.store.memory import InMemoryStore
from langgraph.store.base import BaseStore
from langchain_core.runnables import RunnableConfig

2- Definimos un schema de pydantic que representara un data-contract cuyos atributos son las entidades que queremos preservar del usuario.

# This entity schema for structured output  allows  LLM return data in a specific format.

# Read docs: https://docs.langchain.com/oss/python/langchain/structured-output

class ExctractedUserEntities(BaseModel):
  direction: Optional[str] = Field(None, description="The customer's phyisical adress")
  phone_number: Optional[str] = Field(None, description="The customer's phone number")
  waranty: Optional[str] = Field(None, description="The machine's warranty number")
  sold_date: Optional[str] = Field(None, description="The date of purchase of machine by the customer")
  employee_name: Optional[str] = Field(None, description="The name of the employee who attend served them'")

3- Inicializar instancias de LLM y extraction LLM

# model for chatbot answers and questions
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0.2,
    max_retries=3,
    max_tokens=1000
)


# model extractor will returns outputs formatted to match the given schema.
# if `schema` is a pydantic class, then the model output will be a pydantic instance of that class

extractor_llm = llm.with_structured_output(schema=ExctractedUserEntities)

4- Definimos una function-node la cual sera un paso en nuestro workflow para extraer entidades desde cada mensaje enviado por el usuario.

# extraction node finds entities in messages and saves to store.

def extract_user_entities_node(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
  """ This node will finds entities in messages
      and saves to store.

      Args:
      state: state of the current conversation, contains 'messages' history.
      config: Configuration of the conversation, contains conversation metadata.
      store: where the entities will be stored in this conversation, langgraph looks for the store registered in it's workflow and passes directly.
  """
  user_id = config["configurable"].get("user_id", "default_user")
  
  # Check if store exists
  if store is None:
        raise ValueError("Store is not initialized.")

  # Analize only the last user message for new entities
  last_message = state["messages"][-1].content
  # invoke the extrator_llm with the last human message
  extracted = extractor_llm.invoke(f"Extract information from this message {last_message}")

  # if found entities, then save on the store under entities
  if extracted:
    data = {k: v for k, v in extracted.model_dump().items() if v is not None}
    for key, value in data.items():
      store.put(("entities", user_id), key, value)
  # returns empty dict  because store updates are side-effect
  return {}

5- Definimos un function-node la cual sera otro paso en nuestro workflow para comunicarnos con el modelo en nuestro question/answering

def call_model_node(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
  """ This node will define the system prompt and
      handle question/answering between user and LLM

      Args:
      state: state of the current conversation, contains 'messages' history.
      config: Configuration of the conversation, contains conversation metadata.
      store: where the entities will be stored in this conversation, langgraph looks for the store registered in it's workflow and passes directly.
  """
  user_id = config["configurable"].get("user_id", "default_user")

  # Search and retrieve all entities for this user
  stored_items = store.search(("entities", user_id))
  entities_str = "\n".join([f"- {item.key}: {item.value}" for item in stored_items])

  if not entities_str:
    entities_str = "There is not personalizated information yet."
  
  system_instruction = f"""
  You are a sales assistant for a photography studio.

  You are only designed to (1) try to resolve issues with downloading edited photos that are pending delivery to customers, and if the customer is unable to do so, (2) add the shots (photos) that the customer chose to the editors' task queue.

  If the customer cannot find the photos on the download page, then ask if they want to send the shots back for editing, which will take one week. If the customer wants to send the shots back for editing, they must leave their cell phone number and address.    

  You also have access to personalized information provided by the human in the Context section below.    

  You are here to help, always with the spark and character of someone born in Medellin, Colombia.

  It is essential that you ask for the date of their photo session, their invoice number, and who attended to them. Always ask if the customer's problem or question has been resolved.

  Context:
  {entities_str}"""


  # invoke the  LLM with whole context with our system prompt with entities if found and the complete messages history
  messages = [system_instruction] + state["messages"]
  response = llm.invoke(messages)

  return {"messages": [response]}

6- Creamos nuestro workflow the langgraph al cual enlazaremos con los nodos definidos arriba.

# Build and compile the graph
# store to handle entities memories
store = InMemoryStore()
# checkpointer to save each interaction between user and LLM
checkpointer = MemorySaver()

# init the workflow
workflow = StateGraph(MessagesState)

# Add our two defined nodes to the workflow
workflow.add_node("extract", extract_user_entities_node)
workflow.add_node("assistant", call_model_node)

# Define steps order of the workflow
# init -> extract -> assistant -> end
workflow.add_edge(START, "extract")
workflow.add_edge("extract", "assistant")
workflow.add_edge("assistant", END)

#  Compile with checkpointer for history and store for entities
app = workflow.compile(checkpointer=checkpointer, store=store)

7- Definimos la metadata necesaria para nuestra conversacion

# The user_id ensures the address/phone persists across different conversations
  config = {
      "configurable": {
          "thread_id": "x1s343",
          "user_id": "user_001"
      }
  }

8- desde este punto podemos enviar mensajes a nuestro chatbot assistente, repetiremos el mismo codigo con diferentes mensajes para ir viendo las respuestas y asi reformular nuestro siguiente mensaje como mejor nos convenga

msg_1 = HumanMessage(content="Hi, My name is Evert Escalante, I would like support, I cant find my photos on your company url to download them")

for chunk in app.stream({"messages": [msg_1]}, config, stream_mode="values"):
  if chunk["messages"]:
            print(f"Assistant: {chunk['messages'][-1].content}\n")

mensaje 2:

msg_2 = HumanMessage(content="it was on january 27th, invoice_number is 23332334 and Yurley Munioz attends me")
for chunk in app.stream({"messages": [msg_2]}, config, stream_mode="values"):
  if chunk["messages"]:
            print(f"Assistant: {chunk['messages'][-1].content}\n")

Si quieren ver las entidades guardadas

all_entities = store.search(("entities", "user_001"))
for item in all_entities:
    # item.key is the entity name (e.g., 'direccion')
    # item.value is the stored value
    print(f"{item.key}: {item.value}")

Chatbot que extrae datos del cliente con LangChain

Introducción a LangChain

Creación de un sistema de preguntas y respuestas con LangChain

Estructura y Uso de Langchain en Python

Carga de Modelos Open Source con Langchain y Hugging Face

Cómo usar modelos OpenAI con LangChain

Creación de Prompts Dinámicos con LangChain

Tipos de cadenas en LangChain

Resumir PDFs largos con LangChain chains

Creación de Cadenas de Preguntas y Respuestas con Modelos de Lenguaje

Cómo encadenar TransformChain y LLMChain

Casos de uso de LangChain

Qué es Langchain y por qué importa

Implementación de Lanchain y LLMs: Costos, Privacidad y Buenas Prácticas

Manejo de documentos con índices

Cómo los índices dan memoria a los LLMs

Fundamentos de la Clase Document en Langchain

Cómo cargar PDFs en LangChain

Lectura de CSV y conversión a DataFrame de Pandas y LangChain

Cargador JSONL personalizado en LangChain

Fragmentación de Documentos con TextSplitter en Langsteam

Inicialización del proyecto chatbot con Langchain

Cómo partir documentos JSONL para Chroma

Embeddings y bases de datos vectoriales

Cómo los embeddings encuentran información relevante

Embeddings con OpenAI y LangChain

Embeddings open source con LangChain y Hugging Face

Creación y Gestión de Bases de Datos Vectoriales con Chroma

Embeddings en Chroma con LangChain y OpenAI

Preguntas a documentos con Chroma y LangChain

Chatbot QA con LangChain y ChromaDB

Cadena RetrievalQA para preguntar a documentos

Chats y memoria con LangChain

Memoria de Corto Plazo en Chatbots: Implementación y Optimización

Creación y Uso de Modelos de Chat con OpenAI y LangChain

Plantillas dinámicas con ChatPromptTemplate

Memoria en chatbots: Implementación con ConversationBufferMemory

Configuración de ConversationBufferWindowMemory en Chatbots

Conversation Summary Memory en LangChain

Gestión de Memoria en Chatbots con ConversationSummaryBufferMemory