Créer un agent d’IA conversationnelle avec mémoire à long terme en utilisant LangChain et Milvus
Les grands modèles de langage (LLMs) ont changé la donne dans l’intelligence artificielle (IA). Ces modèles avancés peuvent facilement comprendre et générer du texte semblable à celui d’un humain avec une précision impressionnante, rendant les assistants IA et les chatbots beaucoup plus intelligents et utiles. Grâce aux LLMs, nous disposons désormais d’outils d’IA capables de gérer des tâches linguistiques complexes, de la réponse aux questions à la traduction de langues.
Les agents conversationnels sont des programmes logiciels qui discutent avec les utilisateurs en langage naturel, comme si l’on parlait à une vraie personne. Ils alimentent des outils comme les chatbots et les assistants virtuels, nous aidant dans les tâches quotidiennes en comprenant nos questions et commandes et en y répondant.
LangChain est un framework open-source qui facilite la création de ces agents conversationnels. Il fournit des outils et des modèles pratiques pour créer rapidement et efficacement des chatbots intelligents, sensibles au contexte, ainsi que d’autres applications d’IA.
Introduction aux agents LangChain
Les agents LangChain sont des systèmes avancés qui utilisent un LLM pour interagir avec différents outils et sources de données afin d’accomplir des tâches complexes. Ces agents peuvent comprendre les entrées des utilisateurs, prendre des décisions et créer des réponses, en utilisant le LLM pour offrir une prise de décision plus flexible et adaptative que les méthodes traditionnelles.
Un grand avantage des agents LangChain est leur capacité à utiliser des outils et des sources de données externes. Cela signifie qu’ils peuvent collecter des informations, effectuer des calculs et entreprendre des actions au-delà du simple traitement du langage, ce qui les rend plus puissants et efficaces pour diverses applications
Agents LangChain vs. Chains
Les Chains et les agents sont les deux principaux outils utilisés dans LangChain. Les Chains vous permettent de créer une séquence prédéfinie d’utilisation d’outils, ce qui est utile pour les tâches nécessitant un ordre d’opération spécifique.
Fonctionnement des LangChain Chains
En revanche, les agents permettent au grand modèle de langage d’utiliser des outils en boucle, lui permettant de décider combien de fois utiliser les outils. Cette flexibilité est idéale pour les tâches qui nécessitent un traitement itératif ou une prise de décision dynamique.
Fonctionnement des agents LangChain
Créer un agent conversationnel avec LangChain
Construisons un agent conversationnel avec LangChain en Python.
Installer les dépendances
Pour créer un agent LangChain, nous devons installer les dépendances suivantes :
LangChain : LangChain est un framework open-source qui aide les développeurs à créer des applications à l’aide de grands modèles de langage (LLMs).
Langchain OpenAI : Ce package contient les intégrations LangChain pour OpenAI via leur SDK
openai.OpenAI API SDK : La bibliothèque Python OpenAI fournit un accès pratique à l’API REST OpenAI depuis toute application Python 3.7+.
Dotenv : Python-dotenv lit les paires clé-valeur depuis un fichier
.envet peut les définir comme variables d’environnement.Milvus : une base de données vectorielle open-source idéale pour le stockage vectoriel à l’échelle du milliard et la recherche de similarité. C’est également un composant d’infrastructure populaire pour créer des applications de Retrieval Augmented Generation (RAG).
Pymilvus : Le SDK Python pour Milvus. Il intègre de nombreux modèles populaires d’embedding et de reranking, ce qui simplifie la création d’applications RAG.
Tiktoken : un tokeniseur BPE rapide à utiliser avec les modèles d’OpenAI.
Vous pouvez les installer en exécutant la commande suivante :
pip install langchain==0.1.20 langchain-openai openai python-dotenv pymilvus langchain_milvus tiktoken
Veuillez noter que nous utiliserons spécifiquement la version 0.1.20 de LangChain dans cet exemple.
Après avoir installé toutes les dépendances, écrivons le code pour configurer un agent conversationnel simple.
Charger les variables d’environnement
Tout d’abord, nous allons charger les variables d’environnement à l’aide du package dotenv. Ce package aide à sécuriser les informations sensibles comme les clés API.
from dotenv import load_dotenv
load_dotenv()
Assurez-vous d’avoir un fichier .env dans le répertoire de votre projet contenant votre clé API OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Initialiser le LLM OpenAI
Ensuite, nous allons initialiser le LLM OpenAI à l’aide du package langchain_openai.
from langchain_openai import OpenAI
llm = OpenAI()
Créer une chaîne de conversation
Nous utilisons la classe ConversationChain de langchain.chains pour créer un agent de conversation. Cette chaîne gérera le dialogue avec l’utilisateur.
from langchain.chains import ConversationChain
conversation = ConversationChain(
llm=llm,
)
Faire des prédictions
Enfin, nous pouvons faire des prédictions en transmettant l’entrée utilisateur à la chaîne de conversation. Dans cet exemple, nous posons une question simple à l’agent.
answer = conversation.predict(input="What's my name?")
print(answer)
L’exemple de code complet
En combinant toutes les étapes, voici le code complet.
from dotenv import load_dotenv
from langchain_openai import OpenAI
from langchain.chains import ConversationChain
load_dotenv()
llm = OpenAI()
conversation = ConversationChain(
llm=llm,
)
answer = conversation.predict(input="What's my name?")
print(answer)
Exécuter le code
Pour exécuter le code, assurez-vous d’avoir configuré votre fichier .env avec votre clé API OpenAI. Ensuite, exécutez votre script Python. Vous devriez voir une sortie où l’agent répond à la question, illustrant les capacités conversationnelles du framework LangChain.
Après avoir exécuté le script Python, vous devriez obtenir une réponse de ce type :
> Je n’ai pas accès à vos informations personnelles, je ne peux donc pas répondre précisément à cette question. Pourriez-vous me fournir votre nom afin que je puisse m’adresser à vous correctement ?
Félicitations ! Vous avez créé avec succès un agent conversationnel de base à l’aide de LangChain. Cet exemple n’est qu’un début. Avec LangChain, vous pouvez créer des agents IA plus complexes et plus performants, adaptés à vos besoins.
L’importance de la mémoire dans les agents conversationnels
Cependant, lorsque nous avons demandé à notre agent, "What's my name?", il n’a pas pu répondre correctement car il n’avait aucun souvenir des interactions précédentes. Cette absence de mémoire limite l’utilité des agents conversationnels, car ils ne peuvent pas conserver les informations importantes sur l’utilisateur ou le contexte de la conversation. En intégrant de la mémoire, notre agent peut se souvenir des détails clés des interactions passées, rendant les réponses plus précises et personnalisées.
Créer un agent conversationnel avec mémoire à long terme à l’aide de LangChain et Milvus
Milvus est une base de données vectorielle open source haute performance conçue pour stocker et récupérer efficacement des vecteurs à l’échelle du milliard. Elle est largement utilisée pour des cas d’utilisation GenAI comme la recherche sémantique et la génération augmentée par récupération (RAG). C’est également un composant d’infrastructure essentiel pour ajouter des mémoires à long terme aux LLM.
Milvus Lite est une version légère de Milvus qui peut fonctionner sur vos appareils locaux. Dans cet exemple, nous utiliserons Milvus Lite comme magasin vectoriel pour stocker et récupérer mes données privées.
Maintenant, améliorons notre agent conversationnel avec une mémoire à long terme à l’aide de LangChain et Milvus Lite.
Installer les prérequis
Tout d’abord, installez les packages requis si vous ne les avez pas.
pip install langchain==0.1.20 langchain-openai python-dotenv openai pymilvus tiktoken
Maintenant, écrivons le code étape par étape.
Charger les variables d’environnement
Chargez les variables d’environnement à l’aide du package dotenv. Cette étape permet de sécuriser les informations sensibles comme les clés API.
from dotenv import load_dotenv
load_dotenv()
Assurez-vous d’avoir un fichier .env dans le répertoire de votre projet contenant votre clé API OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Initialiser le LLM OpenAI et les embeddings
Initialisez le LLM OpenAI et les embeddings à l’aide du package langchain_openai.
from langchain_openai import OpenAI, OpenAIEmbeddings
llm = OpenAI()
embeddings = OpenAIEmbeddings()
Configurer Milvus comme vector store
Configurez une base de données vectorielle Milvus pour stocker et récupérer vos données.
from langchain_milvus.vectorstores import Milvus
vectordb = Milvus(
embeddings,
connection_args={"uri": "./milvus_demo.db"},
# The easiest way is to use Milvus Lite where everything is stored in a local file.
# If you have a Milvus server you can use the server URI such as "http://localhost:19530".
)
retriever = vectordb.as_retriever( search_kwargs=dict(k=1))
Créer une mémoire pour l’agent
Configurez la mémoire à l’aide du récupérateur vectoriel.
from langchain.memory import VectorStoreRetrieverMemory
memory = VectorStoreRetrieverMemory(retriever=retriever)
Enregistrer le contexte initial
Ajoutez quelques informations initiales à la mémoire.
about_me = [
{"input": "My name is Bob.", "output": "Got it!"},
{"input": "I'm from San Francisco.", "output": "Got it!"},
]
for example in about_me:
memory.save_context({"input": example["input"]}, {"output": example["output"]})
Définir le modèle de prompt
Créez un modèle de prompt qui inclut la mémoire.
from langchain.prompts import PromptTemplate
prompt_template = """The following is a friendly conversation between a user and a chatbot. The chatbot is talkative and provides lots of specific details from its context. If the chatbot 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:
User: {input}
Chatbot:"""
prompt = PromptTemplate(input_variables=["history", "input"], template=prompt_template)
Créer une chaîne de conversation avec mémoire
Configurez la chaîne de conversation pour utiliser le prompt et la mémoire.
from langchain.chains import ConversationChain
conversation_with_memory = ConversationChain(
llm=llm, prompt=prompt, memory=memory, verbose=True
)
Faire des prédictions
Enfin, posez une question à l’agent pour voir comment il utilise sa mémoire.
L’exemple de code complet
En combinant toutes les étapes, voici le code complet.
from dotenv import load_dotenv
from langchain_openai import OpenAIEmbeddings
from langchain_openai import OpenAI
from langchain.memory import VectorStoreRetrieverMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate
from langchain_milvus.vectorstores import Milvus
load_dotenv()
llm = OpenAI()
embeddings = OpenAIEmbeddings()
vectordb = Milvus(
embeddings,
connection_args={"uri": "./milvus_demo.db"},
)
retriever = vectordb.as_retriever(search_kwargs=dict(k=1))
memory = VectorStoreRetrieverMemory(retriever=retriever)
about_me = [
{"input": "My name is Bob.", "output": "Got it!"},
{"input": "I'm from San Francisco.", "output": "Got it!"},
]
for example in about_me:
memory.save_context({"input": example["input"]}, {"output": example["output"]})
prompt_template = """The following is a friendly conversation between a user and a chatbot. The chatbot is talkative and provides lots of specific details from its context. If the chatbot 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:
User: {input}
Chatbot:"""
prompt = PromptTemplate(input_variables=["history", "input"], template=prompt_template)
conversation_with_memory = ConversationChain(
llm=llm, prompt=prompt, memory=memory, verbose=True
)
answer = conversation_with_memory.predict(input="What's my name?")
print(answer)
Exécution du code
Configurez votre fichier .env avec votre clé API OpenAI pour exécuter le code. Ensuite, exécutez votre script Python. Vous devriez voir une sortie où l’agent répond à la question, illustrant les capacités améliorées du framework LangChain avec l’intégration de la mémoire.
Après avoir exécuté le script Python, vous devriez obtenir une réponse dans ce genre :
> Votre nom est Bob. Saviez-vous que le nom Bob est une forme diminutive du nom Robert, qui signifie « renommée brillante » dans les langues germaniques ? C’était un nom populaire au Moyen Âge et il a été porté par de nombreuses personnes célèbres au cours de l’histoire. Connaissez-vous des personnes célèbres nommées Bob ?
Félicitations ! Vous avez réussi à créer un agent conversationnel doté d’une mémoire à long terme en utilisant LangChain et Milvus. Cet exemple démontre comment la mémoire peut améliorer considérablement la capacité des agents à fournir des réponses précises et personnalisées. Avec LangChain et Milvus, vous pouvez créer des agents IA encore plus avancés et performants, adaptés à vos besoins.
Résumé
Dans cet article, nous avons exploré le monde fascinant des agents LangChain et leur potentiel pour transformer l’IA conversationnelle. Nous avons commencé par une introduction de base à LangChain, en comprenant son rôle dans la création d’agents conversationnels avancés et conscients du contexte. Ensuite, nous avons exploré les étapes pratiques de création d’un agent simple à l’aide de LangChain, en soulignant les limites des agents sans mémoire.
Pour remédier à ces limites, nous avons montré comment intégrer une mémoire à long terme à votre agent en utilisant Milvus Lite, illustrant comment cette amélioration permet à l’agent de conserver des informations importantes et de fournir des réponses plus précises et personnalisées.
Encouragement à expérimenter
Maintenant que vous avez une compréhension fondamentale de LangChain et de la façon de créer des agents conversationnels, il est temps d’expérimenter ! Essayez de créer des agents plus complexes, d’intégrer des outils supplémentaires et d’explorer différents cas d’utilisation. La flexibilité et la puissance de LangChain en font un framework fantastique pour repousser les limites de ce que l’IA conversationnelle peut accomplir.
Pour approfondir LangChain et Milvus, consultez leur documentation officielle et les tutoriels recommandés :
En explorant ces ressources, vous acquerrez une compréhension plus complète et serez mieux équipé pour créer des agents conversationnels avancés et intelligents. Bon codage !
Continuer à lire
The AWS Outage Was a Wake-Up Call for Vector Database Cross-Region Disaster Recovery
Zilliz Cloud Had the Answer Before the Crisis. Zilliz Cloud is the world's first vector database with native cross-region disaster recovery.
Vector Databases vs. Object-Relational Databases
Use a vector database for AI-powered similarity search; use an object-relational database for complex data modeling with both relational integrity and object-oriented features.
Vector Databases vs. Document Databases
Use a vector database for similarity search and AI-powered applications; use a document database for flexible schema and JSON-like data storage.