DEV Community

Elizabeth Fuentes L for AWS Español

Posted on • Updated on • Originally published at community.aws

Trabaje con sus datos en tiempo real usando Langchain

🇻🇪🇨🇱 Dev.to Linkedin GitHub Twitter Instagram Youtube
Linktr

✅ Blog original: Working With Your Live Data Using LangChain

Cuando se crean aplicaciones que aprovechan large language models (LLM), proporcionar el contexto completo de la conversación en cada mensaje es crucial para la coherencia y el diálogo natural. En lugar de tratar cada entrada del usuario como una pregunta aislada (figura 1), el modelo debe entender cómo encaja en la conversación en evolución.

Architecture

Almacenar cada nueva entrada y respuesta en el mensaje (figura 2) lo hace más grande y requiere más memoria y procesamiento. Si no se optimiza el almacenamiento del historial de los diálogos utilizando las técnicas adecuadas para equilibrar el rendimiento y la interacción natural, los recursos se estancarían rápidamente.

Architecture

En este blog, te mostraré cómo utilizar técnicas para proporcionar de manera eficiente el contexto de la conversación con LLM empleando LangChain a fin de crear un agente conversacional que pueda entablar un diálogo natural y mantener el contexto de la conversación añadiendo cada respuesta generada al mensaje para informar la siguiente respuesta. Esto nos permite mantener conversaciones prolongadas y coherentes con el agente a lo largo de varios turnos. Al final, tendrás la habilidad de crear tu propia aplicación conversacional basada en los últimos avances de la IA generativa.

Empecemos!

1 - Instala la librería de LangChain

pip install langchain
Enter fullscreen mode Exit fullscreen mode

Una vez instalado, puede incluir todos estos módulos en tu aplicación.

2 - Crea la invocación al LLM

La invocación se realiza mediante Amazon Bedrock, un servicio totalmente gestionado que permite acceder a los modelos base de Amazon y de proveedores de modelos de terceros a través de una API.

El modelo Anthropic Claude V2 100K es usado en este ejemplo.

Para utilizar las capacidades de Amazon Bedrock con LangChain importa:

from langchain.llms.bedrock import Bedrock
Enter fullscreen mode Exit fullscreen mode

Luego crea el cliente de Amazon Bedrock Runtime:

bedrock_client = boto3.client(
    service_name='bedrock-runtime'
)
Enter fullscreen mode Exit fullscreen mode

📚Note: Aprende mas sobre Amazon Bedrock y LangChain here, y del cliente Amazon Bedrock here and here.

Una Chain, herramienta para llamar a los componentes de la aplicación, es necesaria para generar una conversación con el modelo, configurar verbose = True para realizar la depuración y ver los estados internos de la Chain:

from langchain.chains import ConversationChain
model_parameter = {"temperature": 0.0, "top_p": .5, "max_tokens_to_sample": 2000} #parameters define
llm = Bedrock(model_id="anthropic.claude-v2", model_kwargs=model_parameter,client=bedrock_client) #model define
conversation = ConversationChain(
    llm=llm, verbose=True
)
Enter fullscreen mode Exit fullscreen mode

Prueba la Chain con estas lineas:

conversation.predict(input="Hello world!")
Enter fullscreen mode Exit fullscreen mode

Amazon Bedrock Chain

Adicionalmente, puedes invocar la API de Amazon Bedrock API con Invoke Model API:

prompt = "Hello world!"
kwargs = {
  "modelId": "ai21.j2-ultra-v1",
  "contentType": "application/json",
  "accept": "*/*",
  "body": "{\"prompt\":\"Human:"+ prompt +"\\nAssistant:\",\"maxTokens\":200,\"temperature\":0.7,\"topP\":1,\"stopSequences\":[],\"countPenalty\":{\"scale\":0},\"presencePenalty\":{\"scale\":0},\"frequencyPenalty\":{\"scale\":0}}"
}
response = bedrock_client.invoke_model(**kwargs)
response_body = json.loads(response.get("body").read())
completetion = response_body.get("completions")[0].get("data").get("text")
completetion
Enter fullscreen mode Exit fullscreen mode

Amazon Bedrock invoke model

3 - Add Chat Memory To The Chain

Hay diferentes tipos de memoria en LangChain, pero en este blog vamos a revisar lo siguiente:

3.1 ConversationBufferMemory

El uso de esta memoria permite almacenar todos los mensajes de la conversación.

from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory(return_messages=True)
Enter fullscreen mode Exit fullscreen mode

3.2 ConversationBufferWindowMemory

Limita el tamaño del historial de diálogos a las K interacciones más recientes. Las interacciones más antiguas se descartan a medida que se añaden nuevas para mantener el tamaño fijo en K.

from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferMemory(k=1,return_messages=True)
Enter fullscreen mode Exit fullscreen mode

3.3 ConversationSummaryMemory

Utiliza un modelo LLM para crear un resumen de la conversación, útil para conversaciones extensas.

from langchain.memory import ConversationSummaryMemory
memory = ConversationSummaryMemory(llm=llm,return_messages=True)
Enter fullscreen mode Exit fullscreen mode

3.4 ConversationSummaryBufferMemory

Usa tanto el búfer como el resumen, almacena las conversaciones recientes completas en un búfer y también recopila las conversaciones más antiguas en un resumen.

from langchain.memory import ConversationSummaryBufferMemory
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=10,return_messages=True)
Enter fullscreen mode Exit fullscreen mode

3.5 ConversationTokenBufferMemory

Mantiene un búfer de las interacciones recientes en la memoria y utiliza la longitud del token en lugar del número de interacciones para determinar cuándo vaciar las interacciones.

from langchain.memory import ConversationTokenBufferMemory
memory = ConversationTokenBufferMemory(llm=llm, max_token_limit=10,return_messages=True)
Enter fullscreen mode Exit fullscreen mode

📚Note: In all types of memory belong the parameter return_messages=True is present, this to get the history as a list of messages

4 - Try it!

Para probar las diferentes configuraciones de memoria, agréguelas como parámetro en la cadena.


#add the memory to the Chain
conversation = ConversationChain(
    llm=llm, verbose=True, memory=memory
)
Enter fullscreen mode Exit fullscreen mode

Prueba la Chain:

conversation.predict(input="Hi, my name is Elizabeth!")
conversation.predict(input="what's up?")
conversation.predict(input="cool, What is my name?")

memory.load_memory_variables({}) #To print the memory
Enter fullscreen mode Exit fullscreen mode

En el siguiente gif puedes ver un ejemplo de ConversationBufferMemory.

ConversationBufferMemory

Pruebe los diferentes tipos de memoria y compruebe la diferencia.

5 - Guarda la memoria de la conversación en una tabla de Amazon DynamoDB

Para eso emplea la integración de LangChain module con Amazon DynamoDB

Siguiendo las instrucciones de la documentación de LangChain:

  • Crea la tabla de Amazon DynamoDB:
# Get the service resource.
dynamodb = boto3.resource("dynamodb")

# Create the DynamoDB table.
table = dynamodb.create_table(
    TableName="SessionTable",
    KeySchema=[{"AttributeName": "SessionId", "KeyType": "HASH"}],
    AttributeDefinitions=[{"AttributeName": "SessionId", "AttributeType": "S"}],
    BillingMode="PAY_PER_REQUEST",
)
Enter fullscreen mode Exit fullscreen mode
  • Agrega la Moria a la Chain:
from langchain.memory.chat_message_histories import DynamoDBChatMessageHistory
message_history = DynamoDBChatMessageHistory(table_name="SessionTable", session_id="1")
memory = ConversationBufferMemory(
    memory_key="history", chat_memory=message_history, return_messages=True,ai_prefix="A",human_prefix="H"
)
#add the memory to the Chain
conversation = ConversationChain(
    llm=llm, verbose=True, memory=memory
)
Enter fullscreen mode Exit fullscreen mode
  • Pruébalo!
conversation.predict(input="Hi, my name is Elizabeth!")
conversation.predict(input="what's up?")
conversation.predict(input="cool, What is my name?")

# Print the memory
memory.load_memory_variables({}) 

# Print item count
print(table.item_count)
Enter fullscreen mode Exit fullscreen mode

Un registro nuevo en la tabla de DynamoDB:

Architecture

Conclusiones

Gracias por acompañarme en este viaje, donde adquiriste las habilidades necesarias para mantener una conversación coherente con los LLMs y entablar un diálogo natural mediante el módulo de memoria LangChain, empleaste la API de Amazon Bedrock para invocar modelos de LLM y almacenar la memoria: historial de conversaciones, en un Amazon DynamoDB.

Algunos enlaces para que pueda seguir aprendiendo y desarrollando:

Top comments (0)