Creazione di un agente AI conversazionale con memoria a lungo termine usando LangChain e Milvus
I modelli linguistici di grandi dimensioni (LLM) hanno cambiato le regole del gioco nell’intelligenza artificiale (AI). Questi modelli avanzati possono comprendere e generare facilmente testo simile a quello umano con una precisione impressionante, rendendo gli assistenti AI e i chatbot molto più intelligenti e utili. Grazie agli LLM, ora disponiamo di strumenti AI in grado di gestire attività linguistiche complesse, dal rispondere alle domande alla traduzione delle lingue.
Gli agenti conversazionali sono programmi software che conversano con gli utenti in linguaggio naturale, proprio come parlare con una persona reale. Alimentano elementi come chatbot e assistenti virtuali, aiutandoci nelle attività quotidiane comprendendo e rispondendo alle nostre domande e ai nostri comandi.
LangChain è un framework open-source che rende più facile creare questi agenti conversazionali. Fornisce strumenti e modelli pratici per creare rapidamente ed efficientemente chatbot intelligenti, consapevoli del contesto, e altre applicazioni AI.
Introduzione agli agenti LangChain
Gli agenti LangChain sono sistemi avanzati che utilizzano un LLM per interagire con diversi strumenti e fonti di dati al fine di completare attività complesse. Questi agenti possono comprendere gli input degli utenti, prendere decisioni e creare risposte, utilizzando l’LLM per offrire un processo decisionale più flessibile e adattivo rispetto ai metodi tradizionali.
Un grande vantaggio degli agenti LangChain è la loro capacità di utilizzare strumenti e fonti di dati esterni. Ciò significa che possono raccogliere informazioni, eseguire calcoli e compiere azioni oltre alla semplice elaborazione del linguaggio, rendendoli più potenti ed efficaci per varie applicazioni
Agenti LangChain vs. Chains
Chains e agenti sono i due strumenti principali utilizzati in LangChain. Le Chains consentono di creare una sequenza predefinita di utilizzo degli strumenti, utile per attività che richiedono un ordine specifico di operazioni.
Come funzionano le LangChain Chains
D’altra parte, gli agenti consentono al modello linguistico di grandi dimensioni di utilizzare strumenti in un ciclo, permettendogli di decidere quante volte utilizzare gli strumenti. Questa flessibilità è ideale per attività che richiedono elaborazione iterativa o processi decisionali dinamici.
Come funzionano gli agenti LangChain
Creare un agente conversazionale usando LangChain
Creiamo un agente conversazionale usando LangChain in Python.
Installare le dipendenze
Per creare un agente LangChain, dobbiamo installare le seguenti dipendenze:
LangChain: LangChain è un framework open-source che aiuta gli sviluppatori a creare applicazioni usando modelli linguistici di grandi dimensioni (LLM).
Langchain OpenAI: Questo pacchetto contiene le integrazioni LangChain per OpenAI tramite il loro SDK
openai.OpenAI API SDK: La libreria Python di OpenAI fornisce un accesso pratico all’API REST di OpenAI da qualsiasi applicazione Python 3.7+.
Dotenv: Python-dotenv legge coppie chiave-valore da un file
.enve può impostarle come variabili d’ambiente.Milvus: un database vettoriale open-source ideale per l’archiviazione vettoriale su scala di miliardi e la ricerca di similarità. È anche un componente infrastrutturale popolare per creare applicazioni di Retrieval Augmented Generation (RAG).
Pymilvus: L’SDK Python per Milvus. Integra molti modelli popolari di embedding e reranking, semplificando la creazione di applicazioni RAG.
Tiktoken: un veloce tokenizzatore BPE da usare con i modelli di OpenAI.
Puoi installarli eseguendo il seguente comando:
pip install langchain==0.1.20 langchain-openai openai python-dotenv pymilvus langchain_milvus tiktoken
Nota che in questo esempio useremo specificamente la versione 0.1.20 di LangChain.
Dopo aver installato tutte le dipendenze, scriviamo il codice per configurare un semplice agente conversazionale.
Caricare le variabili d'ambiente
Per prima cosa, caricheremo le variabili d'ambiente usando il pacchetto dotenv. Questo pacchetto aiuta a proteggere informazioni sensibili come le chiavi API.
from dotenv import load_dotenv
load_dotenv()
Assicurati di avere un file .env nella directory del tuo progetto contenente la tua chiave API OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Inizializzare l'LLM OpenAI
Successivamente, inizializzeremo l'LLM OpenAI usando il pacchetto langchain_openai.
from langchain_openai import OpenAI
llm = OpenAI()
Creare una catena di conversazione
Usiamo la classe ConversationChain da langchain.chains per creare un agente conversazionale. Questa catena gestirà il dialogo con l'utente.
from langchain.chains import ConversationChain
conversation = ConversationChain(
llm=llm,
)
Effettuare previsioni
Infine, possiamo effettuare previsioni passando l'input dell'utente alla catena di conversazione. In questo esempio, poniamo all'agente una semplice domanda.
answer = conversation.predict(input="What's my name?")
print(answer)
L'esempio di codice completo
Combinando tutti i passaggi, ecco il codice completo.
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)
Eseguire il codice
Per eseguire il codice, assicurati di aver configurato il tuo file .env con la tua chiave API OpenAI. Quindi, esegui il tuo script Python. Dovresti vedere un output in cui l'agente risponde alla domanda, mostrando le capacità conversazionali del framework LangChain.
Dopo aver eseguito lo script Python, dovresti ottenere una risposta simile a questa:
> Non ho accesso alle tue informazioni personali, quindi non sono in grado di rispondere a questa domanda con precisione. Potresti fornirmi il tuo nome così posso rivolgermi a te correttamente?
Congratulazioni! Hai creato con successo un agente conversazionale di base usando LangChain. Questo esempio è solo l'inizio. Con LangChain, puoi creare agenti AI più complessi e capaci, personalizzati in base alle tue esigenze.
L'importanza della memoria negli agenti conversazionali
Tuttavia, quando abbiamo chiesto al nostro agente, "Come mi chiamo?" non ha saputo rispondere correttamente perché non aveva memoria delle interazioni precedenti. Questa mancanza di memoria limita l'utilità degli agenti conversazionali, poiché non possono conservare informazioni importanti sull'utente o sul contesto della conversazione. Integrando la memoria, il nostro agente può ricordare dettagli chiave dalle interazioni passate, rendendo le risposte più accurate e personalizzate.
Creare un agente conversazionale con memoria a lungo termine usando LangChain e Milvus
Milvus è un database vettoriale open-source ad alte prestazioni, progettato per archiviare e recuperare in modo efficiente vettori su scala di miliardi. È ampiamente usato per casi d'uso GenAI come la ricerca semantica e la Retrieval Augmented Generation (RAG). È anche un componente infrastrutturale vitale per aggiungere memorie a lungo termine agli LLM.
Milvus Lite è una versione leggera di Milvus che può essere eseguita sui tuoi dispositivi locali. In questo esempio, useremo Milvus Lite come vector store per archiviare e recuperare i miei dati privati.
Ora, miglioriamo il nostro agente conversazionale con memoria a lungo termine usando LangChain e Milvus Lite.
Installare i requisiti
Per prima cosa, installa i pacchetti richiesti se non li hai.
pip install langchain==0.1.20 langchain-openai python-dotenv openai pymilvus tiktoken
Ora, scriviamo il codice passo dopo passo.
Caricare le variabili d'ambiente
Carica le variabili d'ambiente usando il pacchetto dotenv. Questo passaggio aiuta a proteggere informazioni sensibili come le chiavi API.
from dotenv import load_dotenv
load_dotenv()
Assicurati di avere un file .env nella directory del tuo progetto contenente la tua chiave API OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Inizializzare l'LLM e gli embedding di OpenAI
Inizializza l'LLM e gli embedding di OpenAI usando il pacchetto langchain_openai.
from langchain_openai import OpenAI, OpenAIEmbeddings
llm = OpenAI()
embeddings = OpenAIEmbeddings()
Configurare Milvus come vector store
Configura un database vettoriale Milvus per archiviare e recuperare i tuoi dati.
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))
Creare la memoria per l'agente
Configura la memoria usando il retriever vettoriale.
from langchain.memory import VectorStoreRetrieverMemory
memory = VectorStoreRetrieverMemory(retriever=retriever)
Salvare il contesto iniziale
Aggiungi alcune informazioni iniziali alla memoria.
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"]})
Definire il template del prompt
Crea un template di prompt che includa la memoria.
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)
Creare una Conversation Chain con memoria
Configura la conversation chain per usare il prompt e la memoria.
from langchain.chains import ConversationChain
conversation_with_memory = ConversationChain(
llm=llm, prompt=prompt, memory=memory, verbose=True
)
Fare previsioni
Infine, poni una domanda all'agente per vedere come usa la sua memoria.
L'esempio di codice completo
Combinando tutti i passaggi, ecco il codice completo.
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)
Esecuzione del codice
Configura il tuo file .env con la tua chiave API OpenAI per eseguire il codice. Quindi, esegui il tuo script Python. Dovresti vedere un output in cui l'agente risponde alla domanda, mostrando le capacità migliorate del framework LangChain con l'integrazione della memoria.
Dopo aver eseguito lo script Python, dovresti ottenere una risposta simile a questa:
> Il tuo nome è Bob. Sapevi che il nome Bob è una forma diminutiva del nome Robert, che significa "fama luminosa" nelle lingue germaniche? Era un nome popolare durante il Medioevo ed è stato usato da molte persone famose nel corso della storia. Conosci qualche persona famosa di nome Bob?
Congratulazioni! Hai creato con successo un agente conversazionale con memoria a lungo termine utilizzando LangChain e Milvus. Questo esempio dimostra come la memoria possa migliorare significativamente la capacità degli agenti di fornire risposte accurate e personalizzate. Con LangChain e Milvus, puoi creare agenti IA ancora più avanzati e capaci, su misura per le tue esigenze.
Riepilogo
In questo articolo, abbiamo esplorato l'affascinante mondo degli agenti LangChain e il loro potenziale per trasformare l'IA conversazionale. Abbiamo iniziato con un'introduzione di base a LangChain, comprendendo il suo ruolo nella creazione di agenti conversazionali avanzati e consapevoli del contesto. Poi, abbiamo esplorato i passaggi pratici per creare un semplice agente utilizzando LangChain, evidenziando i limiti degli agenti senza memoria.
Per affrontare queste limitazioni, abbiamo dimostrato come integrare la memoria a lungo termine nel tuo agente utilizzando Milvus Lite, mostrando come questo miglioramento consenta all'agente di conservare informazioni importanti e fornire risposte più accurate e personalizzate.
Invito a sperimentare
Ora che hai una comprensione di base di LangChain e di come creare agenti conversazionali, è il momento di sperimentare! Prova a creare agenti più complessi, integrare strumenti aggiuntivi ed esplorare diversi casi d'uso. La flessibilità e la potenza di LangChain lo rendono un framework fantastico per spingere oltre i limiti di ciò che l'IA conversazionale può realizzare.
Per un approfondimento su LangChain e Milvus, consulta la loro documentazione ufficiale e i tutorial consigliati:
Esplorando queste risorse, acquisirai una comprensione più completa e sarai meglio equipaggiato per creare agenti conversazionali avanzati e intelligenti. Buona programmazione!
Continua a leggere
Why and How to Migrate from Self-Hosted Milvus to Zilliz Cloud
A simple, step-by-step guide to migrating from Milvus to Zilliz Cloud. Learn both endpoint and backup methods for a smooth, scalable vector database migration.
Why Not All VectorDBs Are Agent-Ready
Explore why choosing the right vector database is critical for scaling AI agents, and why traditional solutions fall short in production.
AI Integration in Video Surveillance Tools: Transforming the Industry with Vector Databases
Discover how AI and vector databases are revolutionizing video surveillance with real-time analysis, faster threat detection, and intelligent search capabilities for enhanced security.