Mémoire conversationnelle dans LangChain

LangChain est un cadre robuste pour la construction d'applications LLM. Cependant, cette puissance s'accompagne d'une certaine complexité. LangChain propose de nombreuses façons d'inviter un LLM et des fonctions essentielles telles que la mémoire conversationnelle. La mémoire conversationnelle offre un contexte permettant au LLM de se souvenir de votre conversation.

Dans ce billet, nous verrons comment utiliser la mémoire conversationnelle avec LangChain et Milvus. Pour suivre, vous devez pip installer quatre bibliothèques et une clé API OpenAI. Les quatre bibliothèques dont vous avez besoin peuvent être installées en exécutant pip install langchain milvus pymilvus python-dotenv. Ou en exécutant le premier bloc dans le CoLab Notebook pour cet article.

Dans cet article, nous allons apprendre à :

• La mémoire conversationnelle avec LangChain
• Configurer le contexte de la conversation
• L'incitation à la mémoire conversationnelle avec LangChain
• Résumé de la mémoire conversationnelle avec LangChain

La mémoire conversationnelle avec LangChain

Dans l'état par défaut, vous interagissez avec un LLM par le biais d'invites uniques. L'ajout d'une mémoire contextuelle, ou "mémoire conversationnelle", signifie que vous n'avez plus besoin de tout envoyer par le biais d'une seule invite. LangChain offre la possibilité de stocker la conversation que vous avez déjà eue avec un LLM afin de récupérer ces informations ultérieurement.

Pour mettre en place une mémoire conversationnelle persistante avec un magasin de vecteurs, nous avons besoin de six modules de LangChain. Tout d'abord, nous devons obtenir les modules OpenAIEmbeddings et OpenAI. Nous avons également besoin de VectorStoreRetrieverMemory et de la version LangChain de Milvus pour utiliser une mémoire vectorielle. Ensuite, nous avons besoin de ConversationChain et PromptTemplate pour sauvegarder notre conversation et l'interroger.

Les bibliothèques os, dotenv et openai sont principalement utilisées à des fins opérationnelles. Nous les utilisons pour charger et utiliser la clé API OpenAI. La dernière étape de configuration consiste à lancer une instance locale de Milvus Lite. Nous le faisons en utilisant le site default_server du paquetage Milvus Python.

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from langchain.vectorstores import Milvus
embeddings = OpenAIEmbeddings()


import os
from dotenv import load_dotenv
import openai
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")


from milvus import default_server
default_server.start()

Configuration du contexte de conversation

Maintenant que toutes les conditions préalables sont réunies, nous pouvons procéder à la création de notre mémoire conversationnelle. Notre première étape consiste à créer une connexion au serveur Milvus à l'aide de LangChain. Ensuite, nous utilisons un dictionnaire vide pour créer notre collection LangChain Milvus. En outre, nous transmettons les embeddings que nous avons créés ci-dessus et les détails de la connexion au serveur Milvus Lite.

Pour utiliser la base de données vectorielle pour la mémoire conversationnelle, nous devons l'instancier en tant que récupérateur. Dans ce cas, nous ne récupérons que le premier résultat, en définissant k=1. La dernière étape de la configuration de la mémoire conversationnelle consiste à utiliser l'objet VectorStoreRetrieverMemory comme mémoire conversationnelle par le biais du récupérateur et de la connexion à la base de données vectorielle que nous venons de mettre en place.

Pour utiliser notre mémoire conversationnelle, il faut qu'elle ait un certain contexte. Donnons donc à la mémoire un certain contexte. Pour cet exemple, nous donnons cinq informations. Stockons mon en-cas préféré (chocolat), mon sport préféré (natation), ma bière préférée (Guinness), mon dessert préféré (cheesecake) et ma musicienne préférée (Taylor Swift). Chaque entrée est enregistrée dans la mémoire à l'aide de la fonction save_context.

vectordb = Milvus.from_documents(
   {},
   embeddings,
   connection_args={"host": "127.0.0.1", "port": default_server.listen_port})
retriever = Milvus.as_retriever(vectordb, search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever)
about_me = [
   {"input": "My favorite snack is chocolate",
    "output": "Nice"},
   {"input": "My favorite sport is swimming",
    "output": "Cool"},
   {"input": "My favorite beer is Guinness",
    "output": "Great"},
   {"input": "My favorite dessert is cheesecake",
    "output": "Good to know"},
   {"input": "My favorite musician is Taylor Swift",
    "output": "Same"}
]
for example in about_me:
   memory.save_context({"input": example["input"]}, {"output": example["output"]})

Promouvoir la mémoire conversationnelle avec LangChain

Il est temps de voir comment nous pouvons utiliser notre mémoire conversationnelle. Commençons par nous connecter au LLM d'OpenAI via LangChain. Nous utilisons une température de 0 pour indiquer que nous ne voulons pas que notre LLM soit créatif.

Ensuite, nous créons un modèle. Nous indiquons au LLM qu'il est engagé dans une conversation amicale avec un humain et insérons deux variables. La variable history fournit le contexte de la mémoire conversationnelle. La variable input fournit l'entrée actuelle. Nous utilisons l'objet PromptTemplate pour insérer ces variables.

Nous utilisons l'objet ConversationChain pour combiner notre invite, notre LLM et notre mémoire. Nous sommes maintenant prêts à vérifier la mémoire de notre conversation en lui donnant quelques invites. Nous commençons par dire au LLM que nous nous appelons Gary, le principal rival de la série Pokemon (tout le reste de la mémoire conversationnelle est un fait me concernant).

llm = OpenAI(temperature=0) # Can be any valid LLM
_DEFAULT_TEMPLATE = """The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.


Relevant pieces of previous conversation:
{history}


(You do not need to use these pieces of information if not relevant)


Current conversation:
Human: {input}
AI:"""
PROMPT = PromptTemplate(
   input_variables=["history", "input"], template=_DEFAULT_TEMPLATE
)
conversation_with_summary = ConversationChain(
   llm=llm,
   prompt=PROMPT,
   memory=memory,
   verbose=True
)
conversation_with_summary.predict(input="Hi, my name is Gary, what's up?")

L'image ci-dessous montre à quoi pourrait ressembler une réponse attendue du LLM. Dans cet exemple, il a répondu en disant qu'il s'appelait "AI".

Testons maintenant la mémoire jusqu'à présent. Nous utilisons l'objet ConversationChain que nous avons créé plus tôt et nous recherchons mon musicien préféré.

conversation_with_summary.predict(input="who is my favorite musician?")

L'image ci-dessous montre une réponse attendue de la chaîne de conversation. Comme nous avons utilisé l'option verbose, la conversation correspondante est également affichée. Nous pouvons voir qu'il retourne que mon artiste préféré est Taylor Swift, comme prévu.

Ensuite, recherchons mon dessert préféré, le cheesecake.

conversation_with_summary.predict(input="Whats my favorite dessert?")

Lorsque nous demandons mon dessert préféré, nous pouvons voir que la chaîne de conversation sélectionne une fois de plus les informations correctes de Milvus. Elle trouve que mon dessert préféré est le gâteau au fromage, comme je le lui ai dit plus tôt.

Maintenant que nous avons confirmé que nous pouvons demander les informations que nous avons fournies plus tôt, vérifions une autre chose : les informations que nous avons fournies au début de notre conversation. Nous avons commencé notre conversation en disant à l'IA que nous nous appelions Gary.

conversation_with_summary.predict(input="What's my name?")

Notre dernière vérification montre que la chaîne de conversation a stocké la partie concernant notre nom dans notre mémoire conversationnelle vectorielle. Elle renvoie que nous avons dit que notre nom était Gary.

Résumé de la mémoire conversationnelle LangChain

Dans ce tutoriel, nous avons appris à utiliser la mémoire conversationnelle dans LangChain. LangChain offre un accès aux backends de stockage vectoriel comme Milvus pour la mémoire conversationnelle persistante. Nous pouvons utiliser la mémoire conversationnelle en injectant un historique dans nos invites et en sauvegardant le contexte historique dans l'objet ConversationChain.

Pour cet exemple de tutoriel, nous avons donné à la chaîne de conversation cinq informations sur moi et nous avons prétendu être le principal rival de Pokemon, Gary. Ensuite, nous avons posé à la chaîne de conversation des questions sur les connaissances a priori que nous avons stockées - mon musicien et mon dessert préférés. La chaîne a répondu correctement à ces deux questions et a fait apparaître les entrées correspondantes. Enfin, nous l'avons interrogée sur le nom que nous avions donné au début de la conversation, et elle a répondu correctement que nous avions dit que notre nom était "Gary".