Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
Atlaschevron-right

Criação de um agente de IA com memória usando MongoDB, Fireworks AI e LangChain

Richmond Alake20 min read • Published Aug 12, 2024 • Updated Aug 12, 2024
IAPandasPythonAtlas
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Este tutorial fornece um guia passo a passo sobre como criar um agente assistente de pesquisa de IA que usa o MongoDB como provedor de memória, o Fireworks AI para chamadas de funções e o LangChain para integrar e gerenciar componentes conversacionais.
Esse agente pode ajudar os pesquisadores, permitindo que eles pesquisem trabalhos de pesquisa com semelhança semântica e pesquisa vetorial, usando o MongoDB como uma base de conhecimento estruturada e um armazenamento de dados para histórico de conversação.
Este repositório contém todas as etapas para implementar o agente neste tutorial, incluindo trechos de código e explicações para configurar a memória do agente, integrar ferramentas e configurar o modelo de linguagem para interagir efetivamente com humanos e outros sistemas.
O que esperar deste tutorial:
  • Definições e conceitos fundamentais de um agente
  • Competência detalhada dos componentes do agente
  • Guia passo a passo de implementação para construir um agente de assistência à pesquisa
  • Insights sobre como equipar os agentes com sistemas de memória e gerenciamento de conhecimento eficazes

O que é um agente?

Um agente é uma entidade computacional artificial com consciência de seu ambiente. Ele é equipado com faculdades que permitem a percepção por meio de entrada, ação por meio do uso de ferramentas e habilidades cognitivas por meio de modelos básicos apoiados por memória de longo e curto prazo. Na AI, os agentes são entidades artificiais que podem tomar decisões inteligentes seguidas de ações baseadas na percepção do ambiente, possibilitadas por grandes modelos de linguagem.
Um diagrama mostrando um agente artificial com conexões com seus três componentes: Percepção (ícone do olho da câmera), Cérebro (ícone do cérebro) e Ferramentas (ícone de engrenagem e chave inglesa)
Antes de discutir a pilha e a implementação de um agente, é útil entender os componentes e as características do novo formato dos aplicativos de AI. Esta seção explora os principais aspectos dos agentes.

Os principais componentes de um agente

Um agente é uma entidade computacional composta de vários componentes integrados, incluindo o encéfalo, a percepção e a ação. Esses componentes trabalham de forma coesa para permitir que o agente atinja seus objetivos e metas.
  • Cérebre: esse componente é crucial para as funções1 do agente, como argumento, planejamento e tomada de decisão. Isso é implementado com um LLM. O encéfalo consiste em vários módulos: memória, analisador e conhecimento. O módulo de memória armazena interações passadas, permitindo que o agente utilize dados históricos para planejamento e ações futuras. O módulo de perfil adapta o comportamento do agente para se ajustar a funções definidas, enquanto o módulo de conhecimento armazena e recupera informações específicas do domínio que ajudam no planejamento e na ação.
  • Ação: o componente de ação permite que o agente React ao seu ambiente e a novas informações. Inclui módulos que ajudam o agente a gerar respostas e interagir com outros sistemas. Usando os processos do memória, um agente baseado em LLM pode decompor tarefas em etapas, cada uma associada a ferramentas específicas do inventário do agente, permitindo a utilização eficaz em momentos apropriados.
  • Perceção: este componente lida com a captura e o processamento de entradas do ambiente geradas por humanos e outros agentes. As entradas são principalmente Auditivas, textuais e visuais, que o agente processa para informar ações e decisões.
O agente implementado neste tutorial terá todos os três componentes principais descritos acima, incluindo acesso a ferramentas para ajudar o agente a atingir um objetivo definido.

As principais características dos agentes

Os agentes baseados em LLM demonstram comportamentos e capacidades que lhes permitem executar tarefas complexas de forma autônoma. Cada características dota os agentes de capacidades únicas, desde a tomada de decisões e a resolução de problemas até a interação dinâmica com o ambiente e outras entidades.
Abaixo está um resumo das principais características dos agentes:
  • Os agentes são autônomos e independentes.
  • Os agentes são introspectivos e proativos.
  • Os agentes são reativos.
  • Os agentes são interativos.
Os agentes são autônomos e independentes, com suas ações e decisões orientadas por um objetivo bem definido, normalmente definido por humanos. No entanto, suas instruções não especificam as ferramentas a serem usadas ou as etapas a serem executadas, exigindo que os agentes planejem e raciocinam de forma independente. Os agentes de idioma, aprimorados por grandes modelos de idioma, são particularmente hábeis no uso de habilidades avançadas de planejamento e argumentos.
Os agentes baseados em LLM são introspectivos e proativos. Eles podem responder a gatilhos usando metodologias como o ReAct e a cadeia de ideias, que os ajudam a resolver problemas e planejar ações de forma eficaz. Esses agentes também são reativos, usando o uso de ferramentas e capacidades de consumo de entradas para agir com base em observações internas e externas sem influencia externa. Isso inclui o processamento de várias formas de entrada, como dados de texto, visuais e auditórios.
Além disso, os agentes são altamente interativos e, muitas vezes, precisam se comunicar com outros agentes ou humanos em seus sistemas. Eles podem entender o feedback e gerar respostas, o que os ajuda a adaptar suas ações de acordo com as necessidades. Em ambientes com vários agentes, sua capacidade de assumir funções e imitar comportamentos sociais facilita a colaboração e cumpre objetivos abrangentes.

Como criar um agente: ferramentas, bibliotecas e soluções

Esta seção aborda as ferramentas e bibliotecas usadas para criar o agente projetado para o caso de uso específico de um assistente de pesquisa AI.
As habilidades do assistente de pesquisa AI são as seguintes:
  • Fornecer uma lista de artigos de pesquisa relacionados a tópicos e assuntos de consultas de usuários.
  • Forneça resumos de artigos de pesquisa mediante solicitação.
  • Utilize sua base de conhecimento para recuperar metadados em documentos de pesquisa armazenados.
  • Use essas informações para atender às consultas dos usuários e atingir seus objetivos de forma eficaz.
O FireFunction V1 do Fireworks AI permite que o cerebra do agente responda às queries do usuário, decida quando usar as ferramentas e gere entradas estruturadas para as ferramentas disponíveis. A percepção do agente sobre seu ambiente é habilitada somente por meio da entrada de texto. Este componente lida com as entradas de texto bruto dos usuários.
Os LLMs são capazes de usar ferramentas, e o agente neste tutorial está focado na recuperação de informações por meio de vários métodos. Retriever e Arxiv Document Loader da LangChain implementam ferramentas para recuperar informações. O agente usa o Retriever para pesquisar e buscar informações relevantes em um armazenamento de dados e o Arxiv Document Loader para acessar e recuperar documentos científicos conforme necessário.
MongoDB como provedor de memória vinculado a bancos de dados para memória de longo prazo, cache semântica, analisador e base de conhecimento em um contexto de AI
O MongoDB é o provedor de memória do agente e fornece armazenamento e gerenciamento de dados de longo prazo para histórico de conversação, um banco de dados vetorial para armazenar e recuperar dados de incorporação vetorial e armazenamento de dados para os dados operacionais do agente. Os recursos de pesquisa vetorial do MongoDB permitem a recuperação de informações com base em semelhanças semânticas entre consultas de usuários e itens no banco de dados vetorial, que simula o conhecimento inerente do agente.

Etapa 1: instalar bibliotecas

A primeira etapa no processo de implementação é instalar as bibliotecas necessárias para acessar classes, métodos e funcionalidades necessárias para implementar vários componentes do sistema do agente.
  • langchain: Fornece ferramentas e funcionalidades para a integração de vários componentes de aplicativos LLM, como modelos, fontes de dados e soluções de banco de dados. Também fornece métodos para a construção de sistemas de bate-papo, agentes e modelos de prompt usando vários formatos e estruturando entradas para LLMs.
  • langchain-openai: pacote Python para usar modelos OpenAI com LangChain.
  • langchain-fireworks: estende a biblioteca LangChain fornecendo soluções específicas para o provedor de modelos FireworksAI.
  • langchain-mongodb: pacote Python para usar o MongoDB como armazenamento de vetores, cache semântico, armazenamento de histórico de chat etc. em LangChain.
  • arxiv: Biblioteca Python para baixar documentos do repositório arXiv.
  • pyducf: ativa o que permite a extração de texto, imagens e metadados de arquivos PDF.
  • datasets: biblioteca Python para obter acesso a conjuntos de dados disponíveis no Hugging Face Hub.
  • PyMongo: fornece métodos e funcionalidades para se conectar ao cluster de MongoDB database e executar operações em collections mantidas em bancos de dados.
O trecho de código abaixo instala todas as bibliotecas necessárias para as etapas de implementação subsequentes.
1!pip install langchain langchain_openai langchain-fireworks langchain-mongodb arxiv pymupdf datasets `pymongo`

Etapa 2: definir variáveis de ambiente

Esta etapa abrange a configuração e a recuperação de variáveis de ambiente. Para este tutorial, as variáveis de ambiente são chaves de API e identificadores exclusivos de modelos e provedores de soluções de banco de dados. Essas informações são atribuídas a variáveis acessadas no ambiente de desenvolvimento.
1 import os
2
3 # Be sure to have all the API keys in your local environment as shown below
4 # Do not publish environment keys in production
5 # os.environ["OPENAI_API_KEY"] = "sk"
6 # os.environ["FIREWORKS_API_KEY"] = ""
7 # os.environ["MONGO_URI"] = ""
8
9 FIREWORKS_API_KEY = os.environ.get("FIREWORKS_API_KEY")
10 OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
11 MONGO_URI = os.environ.get("MONGO_URI")
O trecho de código acima faz o seguinte:
  1. Recuperando as variáveis de ambiente: oos.environ.get() permite recuperar o valor atribuído a uma variável de ambiente por referência de nome.

Etapa 3: ingestão de dados no banco de dados vetorial MongoDB

Este tutorial usa um subconjunto especializado do conjunto de dados arXiv hospedado no MongoDB, derivado da extensiva coleção original na plataforma Hugging Face. Essa versão de subconjunto engloba mais 50,000 artigos específicos obtidos diretamente do arXiv. Cada registro no conjunto de dados do subconjunto tem um campo de incorporação, que encapsula uma representação -dimensional 256do texto derivado da combinação dos nomes dos autores, dos resumos e do título de cada documento.
Esses embeddings são gerados usando otext-embedding-3-small modelda OpenAI , que foi selecionado principalmente devido ao seu tamanho mínimo de dimensão que ocupa menos espaço de armazenamento. Leia o tutorial, que explora maneiras de selecionar modelos de incorporação apropriados para vários casos de uso.
Esse conjunto de dados atuará como a base de conhecimento do agente. O objetivo é que, antes de usar qualquer ferramenta do Atlas Search da Internet, o agente tente inicialmente responder a uma pergunta usando sua base de conhecimento ou memória de longo prazo que, neste caso, são os registros arXiv armazenados no banco de dados vetorial do MongoDB .
A etapa seguinte desta seção carrega o conjunto de dados, cria uma conexão com o banco de dados e ingere os registros no banco de dados.
O código abaixo é a etapa de implementação para obter o subconjunto do conjunto de dados arXiv usando a bibliotecadatasets do Hugging Face. Antes de executar o trecho de código abaixo, certifique-se de que um HF_TOKEN esteja presente em seu ambiente de desenvolvimento; este é o token de acesso do usuário necessário para acesso autorizado aos recursos do Hugging Face. Siga as instruções para obter o token associado à sua conta.
1 import pandas as pd
2 from datasets import load_dataset
3
4 data = load_dataset("MongoDB/subset_arxiv_papers_with_embeddings")
5 dataset_df = pd.DataFrame(data["train"])
  1. Importe a biblioteca de Pandas utilizando o namespace pd para referenciar a biblioteca e acessar funcionalidades.
  2. Importe a biblioteca de conjuntos de dados para usar o métodoload_dataset, que permite acesso a conjuntos de dados hospedados na plataforma Hugging Face fazendo referência ao seu caminho.
  3. Atribua o conjunto de dados carregado aos dados variáveis.
  4. Converta o subconjunto de treinamento do conjunto de dados para um DataFrame de Pandas e atribua o resultado à variável dataset_df.
Antes de executar as operações no seguinte bloco de código abaixo, certifique-se de ter criado um banco de MongoDB database com uma coleção e obter a string URI para o cluster de MongoDB database . A criação de um banco de dados e de uma collection no MongoDB é simplificada com MongoDB Atlas. Registre uma conta Atlas gratuita ou entre na sua conta Atlas existente. Siga as instruções (selecione Atlas UI como o procedimento) para implantar seu primeiro cluster.
O banco de dados para este tutorial é chamado agent_demo, e a collection que manterá os registros dos metadados dos artigos Científicos do ArXiv e suas incorporações é chamada knowledge.
Para habilitar os recursos de pesquisa vetorial do MongoDB, uma definição de índice vetorial deve ser definida para o campo que contém as incorporações. Siga as instruções aqui para criar um índice de busca vetorial. Certifique-se de que o nome do seu índice de pesquisa vetorial seja vector_index.
A definição do seu índice de pesquisa de vetores deve ser semelhante ao que é mostrado abaixo:
1     {
2       "fields": [
3         {
4           "numDimensions": 256,
5           "path": "embedding",
6           "similarity": "cosine",
7           "type": "vector"
8         }
9       ]
10     }
Depois que o banco de dados, a collection e o índice de pesquisa vetorial estiverem totalmente configurados, conecte-se ao banco de dados e execute tarefas de ingestão de dados com apenas algumas linhas de código com o PyMongo.
1 from pymongo import MongoClient
2
3 # Initialize MongoDB python client
4 client = MongoClient(MONGO_URI)
5
6 DB_NAME = "agent_demo"
7 COLLECTION_NAME = "knowledge"
8 ATLAS_VECTOR_SEARCH_INDEX_NAME = "vector_index"
9 collection = client.get_database(DB_NAME).get_collection(COLLECTION_NAME)
  1. Importe a classeMongoClientda biblioteca PyMongo para habilitar as conexões do MongoDB em seu aplicativo Python.
  2. Utilize o MongoClient com seu MONGO_URI para estabelecer uma conexão com seu MongoDB database. Substitua MONGO_URI pela sua string de conexão real.
  3. Defina o nome do banco de dados como agent_demo, atribuindo-o à variável DB_NAME.
  4. Defina o nome da sua collection como knowledge atribuindo-o à variável COLLECTION_NAME.
  5. Acesse a coleção de conhecimento dentro do banco de dados doagent_demo utilizando oclient.get_database(DB_NAME).get_collection(COLLECTION_NAME) e atribuindo-o a uma variável para fácil referência.
  6. Defina o nome do índice da pesquisa vetorial como vector_index atribuindo-o à variável ATLAS_VECTOR_SEARCH_INDEX_NAME, preparação para possíveis operações de pesquisa baseadas em vetores em sua collection.
O trecho de código abaixo descreve o processo de ingestão. Primeiro, a coleção é esvaziada para garantir que o tutorial seja concluído com uma coleção limpa. A próxima etapa é converter o DataFrame do pandas em uma lista de dicionários e, por fim, o processo de ingestão é executado usando o métodoinsert_many()disponível no objeto de coleção do PyMongo.
1 # Delete any existing records in the collection
2 collection.delete_many({})
3
4 # Data Ingestion
5 records = dataset_df.to_dict('records')
6 collection.insert_many(records)
7
8 print("Data ingestion into MongoDB completed")

Etapa 4: criar um retriever LangChain com MongoDB

A biblioteca de código aberto LangChain tem uma implementação de interface que se comunica entre a query do usuário e um armazenamento de dados. Essa interface é chamada de retriever.
Um retriever é uma interface simples e leve dentro do ecossistema do LangChain que usa uma string de query como entrada e retorna uma lista de documentos ou registros que correspondem à query com base em alguma medida de similaridade e limite de pontuação.
O armazenamento de dados para o backend do recuperador para este tutorial será um armazenamento de vetor habilitado pelo MongoDB database. O trecho de código abaixo mostra a implementação necessária para inicializar um armazenamento de vetores MongoDB usando a string de conexão MongoDB e especificando outros argumentos. A operação final usa a instância do armazenamento de vetores como recuperador.
1 from langchain_openai import OpenAIEmbeddings
2 from langchain_mongodb import MongoDBAtlasVectorSearch
3
4 embedding_model = OpenAIEmbeddings(model="text-embedding-3-small", dimensions=256)
5
6 # Vector Store Creation
7 vector_store = MongoDBAtlasVectorSearch.from_connection_string(
8     connection_string=MONGO_URI,
9     namespace=DB_NAME + "." + COLLECTION_NAME,
10     embedding= embedding_model,
11     index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME,
12     text_key="abstract"
13 )
14
15`retriever` = vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 5})
  1. Comece importando OpenAIEmbeddings de langchain_openai e MongoDBAtlasVectorSearch de langchain_mongodb. Essas importações permitirão a você gerar incorporações de texto e interface com o MongoDB Atlas para operações de pesquisa vetorial.
  2. Instancie um objetoOpenAIEmbeddingsespecificando o parâmetro do modelo como "text-embedding-3-small" e as dimensões como 256. Essa etapa prepara o modelo para gerar 256-dimensional vector embeddings a partir da consulta passada para o recuperador.
  3. Utilize o métodoMongoDBAtlasVectorSearch.from_connection_string para configurar a conexão com seu banco de dados MongoDB Atlas. Os parâmetros para esta função são os seguintes:
    • connection_stringEsta é a string de conexão do MongoDB.
    • namespace: Concatene seu nome de banco de dados (DB_NAME) e nome da coleção (COLLECTION_NAME) para formar o namespace onde os registros são armazenados.
    • embedding: Passe o embedding_model inicializado anteriormente como parâmetro de incorporação. Certifique-se de que o modelo de incorporação especificado neste parâmetro seja o mesmo usado para codificar o campo de incorporação nos registros da collection de banco de dados.
    • index_name: Indique o nome do seu índice de pesquisa vetorial. Esse índice facilita operações de pesquisa eficientes no banco de dados.
    • text_key: especifique "abstract" como o parâmetro text_key. Isso indica que o campo abstrato em seus documentos será o foco para gerar e pesquisar incorporações.
  4. Crie um retriever a partir do seu vector_store usando o métodoas_retriever, personalizado para pesquisas de similaridade semântica. Essa configuração permite a recuperação dos cinco documentos principais que mais se aproximam da consulta do usuário com base na similaridade vetorial, usando os recursos de pesquisa vetorial do MongoDB para a recuperação eficiente de documentos de sua collection.

Etapa 5: configurar o LLM usando o Fireworks AI

O agente para este tutorial requer um LLM como seu fornecedor de conhecimento paramétrico e de argumentos. O fornecedor do modelo do agente é o Fireworks AI. Mais especificamente, o modelo FireFunction V1 , que é o modelo de chamada de função do Fireworks AI, tem uma janela de contexto de 32,768 tokens.
O que é chamada de função?
A chamada de função refere-se à capacidade dos modelos de linguagem grandes (LLMs) de selecionar e usar as ferramentas disponíveis para concluir tarefas específicas. Primeiro, o LLM escolhe uma ferramenta por uma referência de nome que, neste contexto, é uma função. Em seguida, ele constrói a entrada estruturada apropriada para essa função, normalmente no JSON schema que contém campos e valores correspondentes aos argumentos da função esperada e seus valores. Esse processo envolve a invocação de uma função selecionada ou uma API com a entrada preparada pelo LLM. O resultado desta invocação de função pode então ser usado como entrada para processamento posterior pelo LLM. 
A chamada de função transforma a natureza probabilística condicional dos LLMs em um modelo previsível e explicável, principalmente porque as funções acessíveis pelos LLMs são construídas, determinísticas e implementadas com restrições de entrada e saída.
O modelo de função de disparo do Fireworks AI é baseado no Mixtral e é de código aberto. Ele se integra à biblioteca LangChain, que abstrai alguns dos detalhes de implementação da chamada de funções com LLMs com recursos de chamada de ferramentas. A biblioteca LangChain fornece uma interface fácil para integrar e interagir com o modelo de chamada de função do Fireworks AI.
O trecho de código abaixo inicializa o modelo de idioma com recursos de chamada de função. A classeFireworks é instanciada com um modelo específico, "accounts/fireworks/models/firefunction-v1 ", e configurada para usar um máximo de 256 tokens.
1 import os
2 from langchain_fireworks import Fireworks
3
4 llm = Fireworks(
5     model="accounts/fireworks/models/firefunction-v1",
6     max_tokens=256)
Isso é tudo para configurar um LLM para o agente LangChain usando o Fireworks AI. O agente poderá selecionar uma função em uma lista de funções fornecidas para concluir uma tarefa. Ele gera entrada de função como um JSON schema estruturado, que pode ser invocado e a saída processada.

Etapa 6: criar ferramentas para o agente

Neste ponto, fizemos o seguinte:
  • Dados ingeridos em nossa base de conhecimento, que é mantida em um banco de dados vetorial MongoDB
  • Criou um objeto retriever para fazer a interface entre as consultas e o banco de dados de vetores
  • Configurou o LLM para o agente
Essa etapa se concentra na especificação das ferramentas que o agente pode usar ao tentar executar operações para atingir o objetivo especificado. A biblioteca LangChain tem vários métodos para especificar e configurar ferramentas para um agente. Neste tutorial, dois métodos são usados:
  1. Definição de ferramenta personalizada com o decorador@tool
  2. Criador de ferramentas incorporadas ao LangChain usando a interfaceTool
A LangChain tem uma collection de ferramentas integradas para fornecer aos seus agentes. Um agente pode aproveitar várias ferramentas especificadas durante sua implementação. Ao implementar ferramentas para agentes usando o LangChain, é essencial configurar o nome e a descrição do modelo. O nome e a descrição da ferramenta permitem que o LLM saiba quando e como aproveitá-la. Outra observação importante é que as ferramentas LangChain geralmente esperam uma entrada de string única.
O trecho de código abaixo importa as classes e os métodos necessários para a configuração da ferramenta de vários módulos da estrutura LangChain.
1 from langchain.agents import tool
2 from langchain.tools.retriever import create_retriever_tool
3 from langchain_community.document_loaders import ArxivLoader
  • Importe o construtor tool do langchain.agents. Eles são usados para definir e instanciar ferramentas personalizadas dentro da estrutura LangChain, que permite a criação de componentes de ferramentas modulares e reutilizáveis.
  • Por último, create_retriever_tool de langchain.tools.retriever é importado. Este método fornece a capacidade de usar recuperadores configurados como ferramentas para um agente. 
  • Importar ArxivLoader de langchain_community.document_loaders. Essa classe fornece um carregador de documentos projetado especificamente para buscar e carregar documentos do repositório arXiv.
Depois que todas as classes e métodos necessários para criar uma ferramenta forem importados para o ambiente de desenvolvimento, a próxima etapa é criar as ferramentas.
O trecho de código abaixo descreve a criação de uma ferramenta usando o decorador de ferramentas LangChain. O principal objetivo dessa ferramenta é receber uma consulta do usuário, que pode ser um termo de pesquisa ou, para o nosso caso de uso específico, um termo para a base de exploração de pesquisa e, em seguida, usar o ArxivLoader para extrair pelo menos 10 documentos que correspondam a artigos do arXiv que correspondam à consulta de pesquisa.
 
O get_metadata_information_from_arxiv retorna uma lista contendo os metadados de cada documento retornado pelo Atlas Search. Os metadados incluem informações suficientes para o LLM iniciar a Exploração de Pesquisa ou utilizar ferramentas adicionais para uma Exploração mais detalhada de um documento específico.
1 @tool
2 def get_metadata_information_from_arxiv(word: str) -> list:
3   """
4   Fetches and returns metadata for a maximum of ten documents from arXiv matching the given query word.
5
6   Args:
7     word (str): The search query to find relevant documents on arXiv.
8
9   Returns:
10     list: Metadata about the documents matching the query.
11   """
12   docs = ArxivLoader(query=word, load_max_docs=10).load()
13   # Extract just the metadata from each document
14   metadata_list = [doc.metadata for doc in docs]
15   return metadata_list
Para obter mais informações sobre um papel específico, a ferramentaget_information_from_arxivcriada com o decoradortoolretorna o documento completo de um único papel usando a ID do papel, inserida como entrada na ferramenta como consulta para o carregador de documentosArxivLoader. O trecho de código abaixo fornece as etapas de implementação para criar a ferramentaget_information_from_arxiv.
1 @tool
2 def get_information_from_arxiv(word: str) -> list:
3   """
4   Fetches and returns metadata for a single research paper from arXiv matching the given query word, which is the ID of the paper, for example: 704.0001.
5
6   Args:
7     word (str): The search query to find the relevant paper on arXiv using the ID.
8
9   Returns:
10     list: Data about the paper matching the query.
11   """
12   doc = ArxivLoader(query=word, load_max_docs=1).load()
13   return doc
A ferramenta final para o agente neste tutorial é a ferramenta de recuperação. Essa ferramenta encapsula a capacidade do agente de usar alguma forma de base de conhecimento para responder às queries inicialmente. Isso é análogo aos humanos que usam informações obtidas anteriormente para responder a perguntas antes de realizar alguma pesquisa na Internet ou em fontes de informação alternativas.
O create_retriever_tool recebe três argumentos:
  • retriever: esse argumento deve ser uma instância de uma classe derivada de BaseRetriever, responsável pela lógica por trás da recuperação de documentos. Nesse caso de uso, este é o recuperador configurado anteriormente que usa o recurso de banco de dados vetorial do MongoDB.
  • name: Esse é um nome exclusivo e descritivo dado à ferramenta retriever. O LLM usa esse nome para identificar a ferramenta, o que também indica seu uso na busca de uma base de conhecimento.
  • description (descrição): O terceiro parâmetro fornece uma descrição detalhada da finalidade da ferramenta. Para este tutorial e nosso caso de uso, a ferramenta atua como fonte de conhecimento fundamental para o agente e contém registros de trabalhos de pesquisa do arXiv.
1 retriever_tool = create_retriever_tool(
2     retriever=retriever,
3     name="knowledge_base",
4     description="This serves as the base knowledge source of the agent and contains some records of research papers from Arxiv. This tool is used as the first step for exploration and research efforts." 
5 )
Os agentes LangChain exigem a especificação das ferramentas disponíveis para uso como uma lista Python. O trecho de código abaixo cria uma lista chamada tools que consiste nas três ferramentas criadas nas etapas de implementação anteriores.
1tools = [get_metadata_information_from_arxiv, get_information_from_arxiv, retriever_tool]

Etapa 7: solicitando ao agente

Esta etapa do tutorial especifica a instrução recebida para instruir o agente usando prompts definidos. O conteúdo passado para o prompt estabelece o fluxo e o objetivo de execução do agente, tornando a solicitação do agente uma etapa crucial para garantir que o comportamento e a saída do agente sejam os esperados.
A construção de prompts para condicionar LLMs e modelos de chat é genuinamente uma forma de arte. Vários métodos imediatos surgiram nos últimos anos, como o ReACT e a estruturação rápida da cadeia de pensamento, para amplificar a capacidade dos LLMs de decompor um problema e agir de acordo. A biblioteca LangChain transforma o que poderia ser um processo de exploração problemático de engenharia imediata em um processo sistemático e programático.
O LangChain oferece o método de classeChatPromptTemplate.from_message() para construir prompts básicos com funções predefinidas como "sistema", "Humano" e "ai". Cada função corresponde a um tipo de orador diferente no chat, permitindo diálogos estruturados. Os espaços reservados nos modelos de mensagem (como {name} ou {user_input}) são substituídos por valores reais passados para o métodoinvoke(), que usa um dicionário de variáveis para ser substituído no modelo.
O modelo de prompt inclui uma variável para fazer referência ao histórico de bate-papo ou à conversa anterior que o agente teve com outras entidades, sejam elas humanas ou sistemas. A classeMessagesPlaceholderoferece uma maneira flexível de adicionar e gerenciar mensagens de bate-papo históricas ou contextuais em prompts de bate-papo estruturados.
Neste tutorial, a função " system " divide o modelo de bate-papo na função especificada de um assistente de pesquisa útil; o modelo de bate-papo, nesse caso, é FireFunction V1 do Fireworks AI. O trecho de código abaixo descreve as etapas para implementar um modelo de prompt estruturado com funções e variáveis definidas para as entradas do usuário e alguma forma de registro do histórico de conversação.
1 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
2 agent_purpose = "You are a helpful research assistant"
3 prompt = ChatPromptTemplate.from_messages(
4     [
5         ("system", agent_purpose),
6         ("human", "{input}"),
7         MessagesPlaceholder("agent_scratchpad")
8     ]
9 )
O {agent_scratchpad} representa o mecanismo de memória de curto prazo do agente. Esse é um componente essencial do agente especificado no modelo de prompt. O scratchpad do agente é responsável por anexar as etapas intermediárias das operações, pensamentos e ações do agente ao componente de pensamento do prompt. A vantagem desse mecanismo de memória de curto prazo é a manutenção do contexto e da coerência ao longo de uma interação, incluindo a capacidade de revisitar e revisar decisões com base em novas informações.

Etapa 8: criar a memória de longo prazo do agente usando o MongoDB

A integração do LangChain e do MongoDB torna a incorporação de memória de longo prazo para os agentes um processo de implementação simples. O trecho de código abaixo demonstra como o MongoDB pode armazenar e recuperar o histórico de chat em um sistema de agente.
O LangChain fornece a interfaceConversationBufferMemory para armazenar interações entre um LLM e o usuário dentro de um armazenamento de dados especificado, o MongoDB, que é usado para este tutorial. Essa interface também fornece métodos para extrair interações anteriores e formatar a conversa armazenada como uma lista de mensagens. O ConversationBufferMemory é o componente de memória de longo prazo do agente.
A principal vantagem da memória de longo prazo em um sistema agêntico é ter alguma forma de armazenamento persistente que atue como um estado, aumentando a relevância das respostas e da execução da tarefa usando interações anteriores. Embora seja útil usar o scratchpad de um agente, que atua como um mecanismo de memória de curto prazo, esse estado temporário é removido quando a conversa termina ou outra sessão é iniciada com o agente. 
Um mecanismo de memória de longo prazo fornece um extenso registro de interação que pode ser recuperado em várias interações que ocorrem em vários momentos. Portanto, sempre que o agente é invocado para executar uma tarefa, ele também recebe uma lembrança de interações anteriores.
1 from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
2 from langchain.memory import ConversationBufferMemory
3
4 def get_session_history(session_id: str) -> MongoDBChatMessageHistory:
5     return MongoDBChatMessageHistory(MONGO_URI, session_id, database_name=DB_NAME, collection_name="history")
6
7 memory = ConversationBufferMemory(
8     memory_key="chat_history", 
9     chat_memory=get_session_history("my-session")
10 )
  • A função get_session_history recebe um session_id como entrada e retorna uma instância de MongoDBChatMessageHistory. Esta instância é configurada com um URI MongoDB (MONGO_URI), o ID da sessão, o nome do banco de dados (DB_NAME) e o nome da collection (history).
  • Uma instânciaConversationBufferMemory é criada e atribuída à memória variável. Esta instância foi especificamente projetada para acompanhar o chat_history.
  • O parâmetro chat_memory de ConversationBufferMemory é definido usando a funçãoget_session_history, o que significa que o histórico de bate-papo é carregado do MongoDB com base no ID de sessão especificado ("my-session" ).
Essa configuração permite a recuperação dinâmica do histórico de chat de uma determinada sessão, usando o MongoDB como o backend do armazenamento de vetores do agente.

Etapa 9: criação do agente

Esta é uma etapa crucial da implementação neste tutorial. Essa etapa abrange a criação de seu agente e a configuração de seu cérebro, que é o LLM, as ferramentas disponíveis para execução de tarefas e o prompt de objetivo que direciona os agentes para a conclusão de uma tarefa ou objetivo específico. Esta seção também aborda a inicialização de uma interface de tempo de execução LangChain, AgentExecutor, que permite a execução dos agentes com propriedades configuradas, como memória e tratamento de erros.
1 from langchain.agents import AgentExecutor, create_tool_calling_agent
2 agent = create_tool_calling_agent(llm, tools, prompt)
3
4 agent_executor = AgentExecutor(
5     agent=agent,
6     tools=tools,
7     verbose=True,
8     handle_parsing_errors=True,
9     memory=memory,
10 )
  • A funçãocreate_tool_calling_agentinicializa um agente especificando um modelo de linguagem (llm), um conjunto de ferramentas (tools) e um modelo de prompt (prompt). Esse agente foi projetado para interagir com base no prompt estruturado e aproveitar ferramentas externas em sua estrutura operacional.
  • Uma instância AgentExecutoré criada com o agente Tool Calling. A classeAgentExecutor é responsável pelo gerenciamento da execução do agente, facilitando a interação com as entradas e as etapas intermediárias, como tratamento de erros e registro. A AgentExecutor também é responsável pela criação de um ambiente recursivo para a execução do agente e passa a saída de uma iteração anterior como entrada para a próxima iteração da execução do agente.
    • agente: O agente de chamada de ferramentas
    • ferramentas: uma sequência de ferramentas que o agente pode usar. Essas ferramentas são habilidades ou integrações predefinidas que aumentam os recursos do agente.
    • handle_parsing_errors: certifique-se de que o agente trate os erros de análise normalmente. Isso aumenta a robustez do agente, permitindo que ele se recupere ou ignore erros na análise de entradas ou saídas.
    • memória: especifica o mecanismo de memória que o agente usa para lembrar interações ou dados passados. Essa integração fornece ao agente contexto adicional ou interação histórica para garantir que as interações contínuas sejam relevantes e baseadas na verdade relativa.

Etapa 10: execução do agente

As etapas anteriores criaram o agente, solicitaram e iniciaram uma interface de tempo de execução para sua execução. Esta etapa final da implementação abrange o método para iniciar a execução do agente e seus processos.
Na estrutura LangChain, objetos nativos como modelos, recuperadores e modelos de prompt herdam o protocolo Runnable . Este protocolo dota os componentes nativos do LangChain com a capacidade de realizar suas operações internas. Os objetos que implementam o protocolo Runnable são reconhecidos como executáveis e introduzem métodos adicionais para iniciar a execução do processo por meio de um método.invoke(), modificando seu comportamento, registrando sua configuração interna e muito mais.
O executor do agente desenvolvido neste tutorial modela um objeto Runnable. Usamos o método .invoke()no objetoAgentExecutor para chamar o agente. O executor do agente inicializou-o com uma entrada de string no código de exemplo fornecido. Essa entrada é usada como {input} no componente de pergunta do modelo ou no prompt do agente.
1agent_chain.invoke({"input": "Get me a list of research papers on the topic Prompt Compression"})
Na primeira invocação inicial do agente, os passos ideais seriam os seguintes:
  • O agente usa a ferramenta retriever para acessar sua base de conhecimento inerente e verificar se há documentos de pesquisa semanticamente semelhantes à entrada/instrução do usuário usando a pesquisa vetorial habilitada pelo MongoDB Atlas.
  • Se o agente recuperar trabalhos de pesquisa de sua base de conhecimento, ele o fornecerá como resposta.
  • Se o agente não encontrar artigos de pesquisa em sua base de conhecimento, ele deverá usar a ferramentaget_metadata_information_from_arxiv() para recuperar uma lista de documentos que correspondam ao termo na entrada do usuário e retorná-la como resposta.
1 agent_executor.invoke({"input":"Get me the abstract of the first paper on the list"})
A próxima invocação do agente demonstra a capacidade do agente de fazer referência ao histórico de conversas, que é recuperado do MongoDB database da coleçãochat_historye usado como entrada no modelo.
Na segunda invocação do agente, o resultado ideal seria o seguinte:
  • O agente faz referência a documentos de pesquisa em sua história ou memória de curto prazo e recupera os detalhes do primeiro documento da lista.
  • O agente usa os detalhes do primeiro documento de pesquisa da lista como entrada na ferramentaget_information_from_arxiv() para extrair o resumo do documento de query.

Conclusão

Este tutorial orientou você na criação de um agente assistente de pesquisa de AI, aproveitando ferramentas como MongoDB, Fireworks AI e LangChain. É mostrado como essas tecnologias se combinam para criar um agente sofisticado capaz de auxiliar os pesquisadores gerenciando e recuperando informações de um extenso banco de dados de trabalhos de pesquisa.
Se você tiver alguma dúvida sobre este treinamento, acesse os fóruns.
Se você quiser explorar mais exemplos de RAG e agentes, visite o repositório do GenAI Showcase.
Ou, se você simplesmente deseja obter uma compreensão completa da AI Stack na era GenAI, leia esta peça.

Perguntas frequentes

  1. O que é um agente? Um agente é uma entidade computacional artificial com consciência de seu ambiente. É equipado com faculdades que permitem a percepção por meio de entrada, ação por meio do uso de ferramentas e habilidades cognitivas por meio de modelos básicos apoiados por memória de longo e curto prazo. Dentro da AI, os agentes são entidades artificiais que podem tomar decisões inteligentes seguidas de ações baseadas na percepção ambiental, habilitadas por grandes modelos de linguagem.
  2. Qual é a principal função do MongoDB no agente de AI? O MongoDB serve como o provedor de memória para o agente, armazenando o histórico de conversação, dados de incorporação de vetor e dados operacionais. Ele suporta a recuperação de informações por meio de seus recursos de banco de dados vetorial, permitindo pesquisas semânticas entre queries de usuários e dados armazenados. 
  3. Como a AI do Fireworks aprimora a funcionalidade do agente? A AI do Fireworks , por meio de seu modelo FireFunction V1, permite que o agente gere respostas às consultas dos usuários e decida quando usar ferramentas específicas, fornecendo uma entrada estruturada para as ferramentas disponíveis.
  4. Quais são algumas das principais características dos agentes de AI? Os agentes são autônomos, introspectivos, proativos, reativos e interativos. Eles podem planejar e raciocinar de forma independente, responder a estímulos com metodologias avançadas e interagir dinamicamente em seus ambientes.
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Uma introdução aos índices para MongoDB Atlas Search


Feb 03, 2023 | 7 min read
Tutorial

Primeiros passos com o MongoDB Atlas e Ruby no Rails


Dec 11, 2023 | 6 min read
Tutorial

Como escolher a estratégia de chunking certa para seu aplicativo LLM


Jun 17, 2024 | 16 min read
Artigo

Como criar um serviço de pesquisa em Java


Apr 23, 2024 | 11 min read
Sumário