Construindo um Agente de IA Conversacional com Memória de Longo Prazo Usando LangChain e Milvus
Grandes modelos de linguagem (LLMs) mudaram o jogo na inteligência artificial (IA). Esses modelos avançados conseguem entender e gerar facilmente textos semelhantes aos humanos com precisão impressionante, tornando assistentes de IA e chatbots muito mais inteligentes e úteis. Graças aos LLMs, agora temos ferramentas de IA que conseguem lidar com tarefas linguísticas complexas, desde responder a perguntas até traduzir idiomas.
Agentes conversacionais são programas de software que conversam com usuários em linguagem natural, assim como falar com uma pessoa real. Eles impulsionam coisas como chatbots e assistentes virtuais, ajudando-nos com tarefas cotidianas ao entender e responder às nossas perguntas e comandos.
LangChain é um framework de código aberto que facilita a criação desses agentes conversacionais. Ele fornece ferramentas e modelos práticos para criar chatbots inteligentes e cientes do contexto e outras aplicações de IA de forma rápida e eficiente.
Introdução aos agentes LangChain
Agentes LangChain são sistemas avançados que usam um LLM para interagir com diferentes ferramentas e fontes de dados para concluir tarefas complexas. Esses agentes conseguem entender entradas de usuários, tomar decisões e criar respostas, usando o LLM para oferecer uma tomada de decisão mais flexível e adaptativa do que os métodos tradicionais.
Uma grande vantagem dos agentes LangChain é sua capacidade de usar ferramentas e fontes de dados externas. Isso significa que eles podem coletar informações, realizar cálculos e executar ações além de apenas processar linguagem, tornando-os mais poderosos e eficazes para várias aplicações
Agentes LangChain vs. Chains
Chains e agentes são as duas principais ferramentas usadas no LangChain. Chains permitem criar uma sequência predefinida de uso de ferramentas, o que é útil para tarefas que exigem uma ordem específica de operação.
Como LangChain Chains funcionam
Por outro lado, Agents permitem que o grande modelo de linguagem use ferramentas em um loop, permitindo que ele decida quantas vezes usar ferramentas. Essa flexibilidade é ideal para tarefas que exigem processamento iterativo ou tomada de decisão dinâmica.
Como LangChain Agents funcionam
Crie um agente conversacional usando LangChain
Vamos criar um agente conversacional usando LangChain em Python.
Instale as dependências
Para criar um agente LangChain, precisamos instalar as seguintes dependências:
LangChain: LangChain é um framework de código aberto que ajuda desenvolvedores a criar aplicações usando grandes modelos de linguagem (LLMs).
Langchain OpenAI: Este pacote contém as integrações do LangChain para OpenAI por meio do SDK
openaideles.OpenAI API SDK: A biblioteca Python da OpenAI fornece acesso conveniente à API REST da OpenAI a partir de qualquer aplicação Python 3.7+.
Dotenv: Python-dotenv lê pares chave-valor de um arquivo
.enve pode defini-los como variáveis de ambiente.Milvus: um banco de dados vetorial de código aberto ideal para armazenamento vetorial em escala de bilhões e busca por similaridade. Ele também é um componente de infraestrutura popular para criar aplicações de Retrieval Augmented Generation (RAG).
Pymilvus: O SDK Python para Milvus. Ele integra muitos modelos populares de embedding e reranking, o que simplifica a criação de aplicações RAG.
Tiktoken: um BPE tokeniser rápido para uso com os modelos da OpenAI.
Você pode instalá-los executando o seguinte comando:
pip install langchain==0.1.20 langchain-openai openai python-dotenv pymilvus langchain_milvus tiktoken
Observe que usaremos especificamente a versão 0.1.20 do LangChain neste exemplo.
Depois de instalarmos todas as dependências, vamos escrever o código para configurar um agente conversacional simples.
Carregar Variáveis de Ambiente
Primeiro, carregaremos as variáveis de ambiente usando o pacote dotenv. Este pacote ajuda a proteger informações sensíveis, como chaves de API.
from dotenv import load_dotenv
load_dotenv()
Certifique-se de ter um arquivo .env no diretório do seu projeto contendo sua chave de API da OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Inicializar o LLM da OpenAI
Em seguida, inicializaremos o LLM da OpenAI usando o pacote langchain_openai.
from langchain_openai import OpenAI
llm = OpenAI()
Criar uma Cadeia de Conversação
Usamos a classe ConversationChain de langchain.chains para criar um agente de conversação. Esta cadeia lidará com o diálogo com o usuário.
from langchain.chains import ConversationChain
conversation = ConversationChain(
llm=llm,
)
Fazer Previsões
Por fim, podemos fazer previsões passando a entrada do usuário para a cadeia de conversação. Neste exemplo, fazemos uma pergunta simples ao agente.
answer = conversation.predict(input="What's my name?")
print(answer)
O Exemplo de Código Completo
Combinando todas as etapas, aqui está o código 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)
Executando o Código
Para executar o código, certifique-se de ter configurado seu arquivo .env com sua chave de API da OpenAI. Em seguida, execute seu script Python. Você deverá ver uma saída em que o agente responde à pergunta, demonstrando as capacidades conversacionais do framework LangChain.
Depois de executar o script Python, você deverá obter uma resposta parecida com esta:
> Não tenho acesso às suas informações pessoais, portanto não consigo responder a essa pergunta com precisão. Você poderia me fornecer seu nome para que eu possa me dirigir a você corretamente?
Parabéns! Você construiu com sucesso um agente conversacional básico usando LangChain. Este exemplo é apenas o começo. Com o LangChain, você pode criar agentes de IA mais complexos e capazes, adaptados às suas necessidades.
A Importância da Memória em Agentes Conversacionais
No entanto, quando perguntamos ao nosso agente, "Qual é o meu nome?" ele não conseguiu responder corretamente porque não tinha memória de interações anteriores. Essa falta de memória limita a utilidade dos agentes conversacionais, pois eles não conseguem reter informações importantes sobre o usuário ou o contexto da conversa. Ao integrar memória, nosso agente pode lembrar detalhes importantes de interações passadas, tornando as respostas mais precisas e personalizadas.
Construir um Agente Conversacional com Memória de Longo Prazo usando LangChain e Milvus
Milvus é um banco de dados vetorial open-source de alto desempenho, criado para armazenar e recuperar com eficiência vetores em escala de bilhões. Ele é amplamente usado em casos de uso de GenAI, como busca semântica e Geração Aumentada por Recuperação (RAG). Ele também é um componente de infraestrutura vital para adicionar memórias de longo prazo a LLMs.
Milvus Lite é uma versão leve do Milvus que pode ser executada em seus dispositivos locais. Neste exemplo, usaremos o Milvus Lite como o armazenamento vetorial para armazenar e recuperar meus dados privados.
Agora, vamos aprimorar nosso agente conversacional com memória de longo prazo usando LangChain e Milvus Lite.
Instalar Requisitos
Primeiro, instale os pacotes necessários se você não os tiver.
pip install langchain==0.1.20 langchain-openai python-dotenv openai pymilvus tiktoken
Agora, vamos escrever o código passo a passo.
Carregar Variáveis de Ambiente
Carregue as variáveis de ambiente usando o pacote dotenv. Esta etapa ajuda a proteger informações sensíveis, como chaves de API.
from dotenv import load_dotenv
load_dotenv()
Certifique-se de ter um arquivo .env no diretório do seu projeto contendo sua chave de API da OpenAI.
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Inicializar o LLM e os Embeddings da OpenAI
Inicialize o LLM e os embeddings da OpenAI usando o pacote langchain_openai.
from langchain_openai import OpenAI, OpenAIEmbeddings
llm = OpenAI()
embeddings = OpenAIEmbeddings()
Configurar o Milvus como o armazenamento vetorial
Configure um banco de dados vetorial Milvus para armazenar e recuperar seus dados.
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))
Criar Memória para o Agente
Configure a memória usando o recuperador vetorial.
from langchain.memory import VectorStoreRetrieverMemory
memory = VectorStoreRetrieverMemory(retriever=retriever)
Salvar Contexto Inicial
Adicione algumas informações iniciais à memória.
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"]})
Definir o Modelo de Prompt
Crie um modelo de prompt que inclua memória.
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)
Criar uma Cadeia de Conversação com Memória
Configure a cadeia de conversação para usar o prompt e a memória.
from langchain.chains import ConversationChain
conversation_with_memory = ConversationChain(
llm=llm, prompt=prompt, memory=memory, verbose=True
)
Fazer Previsões
Por fim, faça uma pergunta ao agente para ver como ele usa sua memória.
O Exemplo de Código Completo
Combinando todas as etapas, aqui está o código 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)
Executando o Código
Configure seu arquivo .env com sua chave de API da OpenAI para executar o código. Em seguida, execute seu script Python. Você deverá ver uma saída em que o agente responde à pergunta, demonstrando os recursos aprimorados do framework LangChain com integração de memória.
Depois de executar o script Python, você deverá obter uma resposta semelhante a esta:
> Your name is Bob. Did you know that the name Bob is a diminutive form of the name Robert, which means "bright fame" in Germanic languages? It was a popular name during the Middle Ages and has been used by many famous people throughout history. Do you know any famous people named Bob?
Parabéns! Você construiu com sucesso um agente conversacional com memória de longo prazo usando LangChain e Milvus. Este exemplo demonstra como a memória pode aprimorar significativamente a capacidade dos agentes de fornecer respostas precisas e personalizadas. Com LangChain e Milvus, você pode criar agentes de IA ainda mais avançados e capazes, adaptados às suas necessidades.
Resumo
Neste artigo, exploramos o fascinante mundo dos agentes LangChain e seu potencial para transformar a IA conversacional. Começamos com uma introdução básica ao LangChain, entendendo seu papel na construção de agentes conversacionais avançados e conscientes do contexto. Em seguida, exploramos as etapas práticas para criar um agente simples usando LangChain, destacando as limitações dos agentes sem memória.
Para abordar essas limitações, demonstramos como integrar memória de longo prazo ao seu agente usando Milvus Lite, mostrando como esse aprimoramento permite que o agente retenha informações importantes e forneça respostas mais precisas e personalizadas.
Incentivo à Experimentação
Agora que você tem uma compreensão fundamental do LangChain e de como criar agentes conversacionais, é hora de experimentar! Tente criar agentes mais complexos, integrar ferramentas adicionais e explorar diferentes casos de uso. A flexibilidade e o poder do LangChain fazem dele um framework fantástico para ampliar os limites do que a IA conversacional pode alcançar.
Para um mergulho mais aprofundado em LangChain e Milvus, confira a documentação oficial e os tutoriais recomendados:
Ao explorar esses recursos, você obterá uma compreensão mais abrangente e estará mais bem preparado para criar agentes conversacionais avançados e inteligentes. Boa programação!
Continue lendo
A Developer's Guide to Exploring Milvus 2.6 Features on Zilliz Cloud
Milvus 2.6 marks a shift from “vector search + glue code” to a more advanced retrieval engine, and it is now Generally Available (GA) on Zilliz Cloud (a managed Milvus service).
Balancing Precision and Performance: How Zilliz Cloud's New Parameters Help You Optimize Vector Search
Optimize vector search with Zilliz Cloud’s level and recall features to tune accuracy, balance performance, and power AI applications.
Introducing DeepSearcher: A Local Open Source Deep Research
In contrast to OpenAI’s Deep Research, this example ran locally, using only open-source models and tools like Milvus and LangChain.