Memoria de Resumen de Conversaciones con Chat GPT-3.5

Clase 33 de 37 • 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
Creación de Chatbots con Modelos de Lenguaje y Bases de Datos Vectoriales
05:27 min

Tomar examen

Resumen

¿Qué es la memoria Conversation Summary Memory?

La memoria Conversation Summary Memory permite la creación de un resumen de todas las interacciones mantenidas en una conversación. A diferencia de guardar cada interacción individualmente, este enfoque guarda un resumen que encapsula el contenido de la conversación. Esta técnica es ideal para conversaciones extensas, permitiendo mantener una visión general sin recopilar cada mensaje por separado.

¿Cómo se configuran las bibliotecas necesarias?

Para implementar este tipo de memoria, es esencial contar con algunas bibliotecas clave:

Memory en Chains: Importa ConversationSummaryMemory para gestionar las interacciones.
OpenAI desde LangChain: Utiliza los modelados de lenguaje de OpenAI para procesar las conversaciones.
Chains, Conversation Chain: Crea cadenas de conversación basadas en modelos AI.

from langchain.memory import ConversationSummaryMemory
from langchain.llms import OpenAI
from langchain.chains import ConversationChain

¿Cómo se instancian modelo y memoria?

Creación del modelo

Primero, instanciamos un modelo de chat de OpenAI. En este caso, el modelo específico es GPT-3.5 Turbo.

chat_model = OpenAI.ChatCompletion(model="gpt-3.5-turbo")

Configuración de la memoria

Creamos la memoria, denominada SummaryMemory, definiendo el modelo que se encargará de gestionar el resumen de las interacciones:

summary_memory = ConversationSummaryMemory(model=chat_model)

¿Cómo se realiza una conversación simulada?

Una vez configurada la instancia del modelo y la memoria, podemos proceder a generar una cadena de conversación.

Instanciación y seguimiento

Creamos un objeto de ConversationChain, utilizando chat_model, con la opción verbose=True para seguir el flujo detallado:

conversation = ConversationChain(
    model=chat_model,
    verbose=True,
    memory_type=summary_memory
)

Ejemplos de interacción

Iniciamos la conversación: Se observa cómo verbose=True brinda contexto sobre las interacciones. Aquí, el papel de la inteligencia artificial y el ser humano se define claramente.
Primer intercambio: Omar, el interlocutor humano, se presenta de manera coloquial, y la inteligencia artificial responde de manera cordial y amistosa.
Más interacción: Se continúan las preguntas y respuestas, donde se puede consultar temas complejos como la historia latinoamericana y la opresión indígena. El resumen se llena con las interacciones, destacando preguntas importantes y el estilo de comunicación coloquial de Omar.

Ventajas de usar Conversation Summary Memory

Contexto en conversaciones largas: Ideal para mantener una visión general de interacciones extensas sin perder detalles críticos.
Memoria eficiente: Guarda el contexto necesario para construir respuestas informadas sin sobrecargar la memoria.
Acceso a resúmenes: Posibilidad de imprimir y revisar el resumen de la conversación, simplificando el seguimiento de temas tratados.

Esta herramienta ofrece una manera efectiva de manejar conversaciones complejas en aplicaciones donde el contexto y la memoria de las interacciones son esenciales.

Evert Escalante

student•

A dia de hoy se puede usar langgraph para crear manejar la memoria a corto plazo y mantener algo similar a ConversationSummaryMemory utilizando las siguientes funcionalidades de la libreria langmem:

SummarizationNode, RunningSummary
pip install langgrahp lamgmem

1- Comenzamos importando las librerias necesarias e instanciando nuestro modelo de chat:

from langchain_core.messages import HumanMessage, AnyMessage, SystemMessage, AIMessage
from langchain_core.messages.utils import trim_messages, count_tokens_approximately
from langgraph.graph import START, StateGraph, MessagesState
from langgraph.checkpoint.memory import InMemorySaver
from langmem.short_term import SummarizationNode, RunningSummary
from typing import TypedDict, Any
from langchain_core.runnables import RunnableLambda
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0.2,
    max_retries=3,
    max_tokens=1000
)

2- definimos las interfaces de datos para controlar nuestra conversacion y el resumen optimizado de la misma

class State(MessagesState):
  """ Will store the wole conversation messages"""
  context: dict[str, Any]

class LLMInputState(TypedDict):
  """
    Private state for filtering inputs to call_model node.
    
    This state schema ensures call_model receives ONLY the optimized
    conversation context (summarized_messages), not the full history.
  `"""
  summarized_messages: list[AnyMessage]
  context: dict[str, Any]

3- Vamos a crear nuestra instancia de modelo que se encargara de hacer los resumenes. En este caso tambien creamos una funcion que nos permita inyectarle un prompt system:

# Create summarization model with custom system prompt
summarization_system_prompt = """You are a conversation summarizer. Your goal is to create concise but complete summaries."""

# Create a wrapper that injects system message 
def create_summarization_model_with_prompt(base_model, system_prompt: str):
    """Wrapper that injects system prompt into summarization calls"""
    
    def summarize_with_context(messages):
        # Inject system prompt before the messages to summarize
        enhanced_messages = [
            SystemMessage(content=system_prompt)
        ] + messages
        
        return base_model.invoke(enhanced_messages)
    
    return RunnableLambda(summarize_with_context)

# Create the summarization model with our custom prompt
summarization_model = create_summarization_model_with_prompt(
    # attach this to our original chat model
    base_model=llm.bind(max_tokens=700, temperature=0.3),
    system_prompt=summarization_system_prompt
)

4- Vamos a crear nuestro nodo se summarization, este se encargara de recibir la lista de mensajes y crear un resumen del mismo cuando sea necesario

# Summarization Node Configuration
# 
# This node automatically monitors conversation length and creates summaries
# when the token count exceeds the threshold to manage context and costs.
#
# Kepp in mind that if provided max_tokens... atributes values are short for example 256 tokens
# it meeans that is possibly a message tokens is greather than that and summarization can be done
# for that reason we pass values like 2000 tokens but often will need be greathers.

# How it works:
# 1. Counts tokens in current conversation using token_counter
# 2. If count > max_tokens_before_summary: triggers summarization
# 3. Creates summary of old messages (max: max_summary_tokens)
# 4. Keeps recent messages that fit in remaining budget
# 5. Returns combined result: [summary] + [recent messages]
#
# Return format:
# - If summarization triggered:
#   {
#     "summarized_messages": [summary, recent_msg1, recent_msg2, ...],
#     "context": {"summary": summary}
#   }
# - If no summarization needed:
#   {
#     "summarized_messages": [all_messages],
#     "context": {}
#   }
summarization_node = SummarizationNode(
    # Function to count tokens in message list
    token_counter = count_tokens_approximately,
    # LLM used to generate summaries (limited to 700 tokens output)
    model = summarization_model,
    # Target budget: How much total context (summary + recent messages) to keep after summarization
    max_tokens=2000,
    # Trigger threshold: Start summarization when conversation exceeds this token count
    max_tokens_before_summary=2000,
    # Maximum tokens for the summary itself (NOT including recent messages)
    max_summary_tokens=700

)

5- Creamos nuestro nodo para llamar al modelo, este nodo se encargara de recivir el contexto de la conversacion y recibir respuestas. Esta funcion esta optimizada para debugging asi sabremos lo que sucede en cada interaccion

def call_model(state: LLMInputState):
    print("\n" + "="*70)
    print("📤 LLM INPUT ANALYSIS")
    print("="*70)
    
    # Debug state structure
    print(f"🔍 State keys: {list(state.keys())}")
    print(f"🔍 Context exists: {('context' in state)}")
    print(f"🔍 Context value: {state.get('context')}")
    
    # Check for summary
    context = state.get("context") or {}
    has_summary = "running_summary" in context and context["running_summary"] is not None
    
    print(f"🔍 Has summary: {has_summary}")
    
    if has_summary:
        running_summary = context["running_summary"]
        print("\n✅ SUMMARIZATION ACTIVE")
        print(f"   📋 Summary length: {len(running_summary.summary)} chars")
        print(f"   📋 Summary tokens: ~{count_tokens_approximately([running_summary.summary])}")
        print(f"   📝 Summary preview: {running_summary.summary}...")
    else:
        print("\n NO SUMMARIZATION FOUND")
    
    print(f"\n💬 Message breakdown:")
    for i, msg in enumerate(state["summarized_messages"], 1):
        msg_type = "🧑 Human" if msg.type == "human" else "🤖 AI" if msg.type == "ai" else "⚙️ System"
        content_preview = msg.content[:60] + "..." if len(msg.content) > 60 else msg.content
        tokens = count_tokens_approximately([msg])
        print(f"   {i}. {msg_type} ({tokens} tokens): {content_preview}")
    
    total_tokens = count_tokens_approximately(state["summarized_messages"])
    print(f"\n🔢 TOTAL TOKENS SENT: {total_tokens}")
    print("="*70 + "\n")
    
    response = llm.invoke(state["summarized_messages"])
    return {"messages": [response]}

6- Construimos nuestro graph con memoria en Ram para usarlo en nuestra conversacion:

# Create and add nodes to the graph
graph_builder = StateGraph(State)
graph_builder.add_node(call_model)
graph_builder.add_node("summarize", summarization_node)
# define the order of the execution pipeline of the graph
graph_builder.add_edge(START, "summarize")
graph_builder.add_edge("summarize", "call_model")

# add and compile the graph with memory on RAM
checkpointer = InMemorySaver()
graph = graph_builder.compile(checkpointer=checkpointer)

7- Creamos nuestra conversacion simulada:

config = {"configurable": {"thread_id": "123"}}

conversation_messages = [
    HumanMessage("Hola, soy Pablo"),
    HumanMessage("Que hace un product engineer en una start up, alguien que desarrolla software"),
    HumanMessage("Que se habilidades tecnicas se necesitan para ser product engineer y desarrollar productos 'from zero to hero'"),
    HumanMessage("Tengo experiencia como backend engineer es de ayuda para esto?"),
    HumanMessage("Como puedo desarrollar productos desde cero en orden de aprender en la practica"),
    HumanMessage("Puedes generar un road map para aprender habilidades tecnicas requeridas"),
    HumanMessage("Como se puede gestionar el tiempo de manera efectiva para seguir este road map"),
]

8- Corremos nuestra conversacion, podremos tener un buen debuggin gracias al nodo call_model

for msg in conversation_messages:
  response = graph.invoke({"messages": [msg]}, config)

  # Pretty print the last two messages human and the AI's response
  response["messages"][-2].pretty_print()
  response["messages"][-1].pretty_print()

Memoria de Resumen de Conversaciones con Chat GPT-3.5

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

Uso de Modelos OpenAI con LangChain: Guía Práctica para Principiantes

Creación de Prompts Dinámicos con LangChain

Uso de Cadenas en Modelos de Lenguaje con Language Chain

Procesamiento de PDFs y creación de resúmenes con LangChain

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

Creación de cadenas secuenciales en Python para procesamiento de texto

Casos de uso de LangChain

Aplicaciones y Beneficios de Lancheng en el Manejo de LLMs

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

Manejo de documentos con índices

Carga de Documentos en Langchain para Creación de Índices

Fundamentos de la Clase Document en Langchain

Carga y Transformación de Documentos No Estructurados con Landship

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

Creación de un Cargador de JSON-Lines Personalizado en Python

Fragmentación de Documentos con TextSplitter en Langsteam

Creación de un Chatbot con Documentación de Hugging Face

Creación de Índice Vectorial con Langchain y Embeddings

Embeddings y bases de datos vectoriales

Creación de Índices con Embeddings y Bases de Datos Vectoriales

Creación y uso de embeddings con OpenAI y Lanchain

Modelos de Embeddings Open Source en Español con Sentence Transformers

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

Creación y manejo de bases de datos vectoriales con OpenAI Embeddings

Creación y Uso de un Retriever en Chroma para Consultas Avanzadas

Modelo de Chat para Preguntas y Respuestas con LangChain y Chroma

Creación de un Chatbot para Preguntas con Bases de Datos Vectoriales

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

Creación de Plantillas Dinámicas para Prompts de Chat en Langstead

Memoria en chatbots: Implementación con ConversationBufferMemory

Configuración de ConversationBufferWindowMemory en Chatbots

Memoria de Resumen de Conversaciones con Chat GPT-3.5

Gestión de Memoria en Chatbots con ConversationSummaryBufferMemory

Memoria de Entidades en Chatbots para Soporte de Ventas

Implementación de Chatbot con Memoria en Python usando Langchain

Evolución del uso de LLM

Creación de Chatbots con Modelos de Lenguaje y Bases de Datos Vectoriales