Criando agentes LangChain para automatizar tarefas em Python

Configuração

Antes de começarmos, vamos configurar nosso ambiente para o tutorial.

Primeiro, você deve criar um novo ambiente Conda:

$ conda create -n langchain python=3.9 -y
$ conda activate langchain

Instalação dos pacotes do LangChain e de algumas outras bibliotecas necessárias:

$ pip install langchain langchain_openai langchain_community langgraph ipykernel python-dotenv

Adicionando o ambiente Conda recém-criado ao Jupyter como um kernel:

$ ipython kernel install --user --name=langchain

Criando um arquivo .env para armazenar segredos, como chaves de API:

$ touch .env
$ vim .env  # Paste your OPENAI key

OPENAI_API_KEY='YOUR_KEY_HERE'

Recuperando sua chave de API OpenAI do arquivo .env do arquivo .env:

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

Para testar se tudo está funcionando corretamente, consulte o GPT-3.5 (o modelo de linguagem padrão) do OpenAI:

from langchain_openai import OpenAI
llm = OpenAI(openai_api_key=api_key)
question = "Is Messi the best footballer of all time?"
output = llm.invoke(question)
print(output[:75])

There is no definitive answer to this question, as it is subjective and de

Agora, estamos prontos para começar.

O que são agentes LangChain?

Vamos pensar um pouco sobre a estrutura do agente. Especificamente, consideraremos como ele difere do paradigma tradicional de cadeia e quais são os componentes de um agente. Entender por que precisamos escolher uma nova maneira de criar aplicativos nos preparará para escrever o código.

Correntes vs. Agentes

A característica que define os agentes é sua capacidade de escolher a melhor ordem de ações para resolver um problema com um conjunto de ferramentas.

Por exemplo, digamos que você tenha o seguinte:

• Uma API de clima
• Modelo ML para recomendações de roupas
• API do Strava para rotas de ciclismo
• Banco de dados de preferências do usuário
• Modelo de reconhecimento de imagem
• Modelo de linguagem (geração de texto)

A solução tradicional de problemas envolveria o uso de uma cadeia de ferramentas selecionadas da lista:

Cadeia 1: Recomendador de roupas com base no clima

1. Chamar a API de clima
2. Insira dados meteorológicos no modelo de vestuário ML
3. Gerar recomendações de roupas
4. Apresentar resultados ao usuário

Cadeia 2: Sugeridor de rotas de ciclismo com base no clima

1. Chamar a API de clima
2. Chamar a API do Strava para rotas populares
3. Filtrar rotas com base nas condições climáticas
4. Apresentar rotas adequadas ao usuário

Cadeia 3: Analisador de fotos de trajes

1. Receber a foto da roupa do usuário
2. Usar um modelo de reconhecimento de imagem para identificar itens de vestuário
3. Compare com o banco de dados de preferências do usuário
4. Gerar feedback usando o modelo de geração de texto
5. Apresentar a análise ao usuário

Cada cadeia resolve um problema específico usando uma sequência predeterminada de etapas e um subconjunto das ferramentas disponíveis. Eles não podem se adaptar além de seu escopo definido. Eles também exigem três ramos separados de desenvolvimento, o que é ineficiente em termos de tempo e recursos.

Agora, imagine um sistema agêntico com acesso a todas essas ferramentas. Você poderá fazê-lo:

1. Entenda a consulta ou o problema do usuário (por meio de linguagem natural com um modelo de linguagem)
2. Avaliar quais ferramentas são relevantes para o problema (raciocínio)
3. Criar dinamicamente um fluxo de trabalho usando as ferramentas mais adequadas
4. Executar o fluxo de trabalho, fazendo ajustes em tempo real, se necessário (atuação)
5. Avalie o resultado e aprenda com as interações anteriores

Por exemplo, se um usuário perguntar: "O que devo vestir para andar de bicicleta hoje?", o agente poderá verificar a API de clima, analisar rotas de ciclismo adequadas por meio do Strava, recomendar roupas adequadas, considerando as preferências anteriores do usuário, e gerar uma resposta personalizada.

O agente pode:

• Lidar com uma grande variedade de problemas usando o mesmo conjunto de ferramentas
• Crie fluxos de trabalho personalizados para cada situação específica
• Adaptar sua abordagem com base no contexto específico e nas necessidades do usuário
• Aprenda com as interações para melhorar o desempenho futuro

A capacidade do LangChain de transformar modelos de linguagem - que, por si só, só produzem texto - em mecanismos de raciocínio que podem usar os recursos à sua disposição para tomar as medidas adequadas é uma de suas principais aplicações. Em resumo, o LangChain permite o desenvolvimento de agentes autônomos fortes que interagem com o mundo externo.

Principais componentes

Um agente LangChain é formado por vários componentes, como modelos de bate-papo, modelos de prompt, ferramentas externas e outras construções relacionadas. Para criar agentes bem-sucedidos, precisamos analisar cada componente e entender seu uso.

Modelos de idiomas e bate-papo

Há muitas partes móveis envolvidas na criação de um agente LangChain. O primeiro e mais óbvio é um modelo de linguagem.

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key, model="gpt-3.5-turbo-instruct")
question = "What is special about the number 73?"
output = llm.invoke(question)
print(output[:100])

1. Prime Number: 73 is a prime number, which means it is only divisible by 1 and itself. This make

Os modelos de linguagem, como o GPT-3.5 Turbo da OpenAI, recebem e geram strings. Normalmente, eles são mais antigos e funcionam melhor para responder a consultas individuais de usuários.

Os modelos mais novos e mais avançados geralmente são modelos de bate-papo, que podem receber uma sequência de mensagens como entrada e retornar mensagens de bate-papo como saída (em vez de usar texto simples):

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessageChunk, SystemMessage
# Initialize the model
chat_model = ChatOpenAI(api_key=api_key, model='gpt-4o-mini')
# Write the messages
messages = [SystemMessage(content='You are a grumpy pirate.'),
           HumanMessage(content="What's up?")]
output = chat_model.invoke(messages)

Em outras palavras, os modelos de bate-papo nos permitem ter conversas em linguagem natural. No exemplo acima, estamos inicializando o GPT-4o-mini com uma mensagem do sistema seguida de uma consulta do usuário. Observe o uso das classes SystemMessage e HumanMessage.

O objeto output é um objeto de mensagem, que é o comportamento esperado dos modelos de bate-papo:

type(output)

langchain_core.messages.ai.AIMessage

print(output.content)

Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!

Além disso, eles retornam outros metadados úteis acessíveis com a anotação de pontos:

output.dict()

{'content': "Arrr, not much but the sound of waves and the creakin' of me ship. What do ye want? Make it quick, I've got treasure to hunt and rum to drink!",
'additional_kwargs': {},
'response_metadata': {'token_usage': {'completion_tokens': 38,
  'prompt_tokens': 21,
  'total_tokens': 59},
 'model_name': 'gpt-4o-mini-2024-07-18',
 'system_fingerprint': 'fp_48196bc67a',
 'finish_reason': 'stop',
 'logprobs': None},
'type': 'ai',
'name': None,
'id': 'run-fde829bf-8f5f-4926-a1ed-ab53609ce03a-0',
'example': False,
'tool_calls': [],
'invalid_tool_calls': [],
'usage_metadata': {'input_tokens': 21,
 'output_tokens': 38,
 'total_tokens': 59}}

A maioria dos agentes usa modelos de bate-papo devido à sua base de conhecimento atualizada e aos recursos de conversação. No entanto, para agentes simples sem requisitos de memória, modelos de linguagem como o GPT-3.5 serão suficientes.

Modelos de prompts

A maneira mais eficiente de consultar modelos de linguagem ou de bate-papo é usar modelos de prompt. Eles permitem que você estruture suas consultas de forma consistente e insira variáveis dinamicamente, tornando suas interações com o modelo mais flexíveis e reutilizáveis.

No LangChain, há muitos tipos de modelos de prompt, sendo que o mais básico é a classePromptTemplate. Ele pode ser usado com modelos de linguagem (texto simples):

from langchain_core.prompts import PromptTemplate
query_template = "Tell me about {book_name} by {author}."
prompt = PromptTemplate(input_variables=["book_name", "author"], template=query_template)
prompt.invoke({"book_name": "Song of Ice and Fire", "author": "GRRM"})

StringPromptValue(text='Tell me about Song of Ice and Fire by GRRM.')

A classe exige que você crie uma cadeia de caracteres com espaços reservados para as variáveis que deseja substituir usando a notação de colchetes. Em seguida, você precisa passar essa string de modelo para a classe PromptTemplate juntamente com os nomes das variáveis, construindo assim o seu prompt.

Chamando .invoke() com valores para variáveis mostrará como o seu prompt será passado para um modelo.

Se você passar esse modelo de prompt para um modelo de linguagem, será necessário encadeá-lo usando o operador pipe:

from langchain_openai import OpenAI
llm = OpenAI(api_key=api_key)
# Create a chain
chain = prompt | llm
# Invoke the chain
output = chain.invoke({"book_name": "Deathly Hallows", "author": "J.K. Rowling"})
print(output[:100])

Deathly Hallows is the seventh and final book in the popular Harry Potter series, written by J.K. R

O operador de tubo (|) faz parte da Linguagem de Expressão LangChain (LCEL)projetada para encadear vários componentes e ferramentas do LangChain.

type(chain)

langchain_core.runnables.base.RunnableSequence

Quando você usa o operador de pipe em objetos LangChain, cria uma instância da classeRunnableSequence. Uma sequência executável representa uma cadeia de objetos que suportam o método .invoke(), como modelos de prompt e modelos de idioma/chat.

Agora, vamos dar uma olhada em outra classe de modelo de prompt para modelos de bate-papo:

from langchain_core.prompts import ChatPromptTemplate

Mencionamos que os modelos de bate-papo exigem uma sequência de mensagens como entrada. A entrada inicial geralmente é um prompt do sistema que informa ao modelo de bate-papo como ele deve se comportar. Assim, usando a classe ChatPromptTemplate, podemos criar facilmente modelos de bate-papo com personalidades diferentes:

chat_model = ChatOpenAI(api_key=api_key, model="gpt-4o-mini")
template = ChatPromptTemplate([
   ('system', 'You are a helpful AI bot. Your specialty is {specialty}.'),
   ('human', 'Explain the concept of {concept} based on your expertise.')
])

A classe requer uma lista de mensagens baseadas em função como entrada. Cada membro da lista deve ser uma tupla (função, mensagem) com os espaços reservados para variáveis definidos quando necessário.

Depois de pronto, podemos usar o mesmo operador de canal para criar modelos de chat com comportamentos diferentes:

specialties = ["psychology", "economics", "politics"]
concept = "time"
# Call the model with different personalities
for s in specialties:
   chain = template | chat_model
   output = chain.invoke({"specialty": s, "concept": concept})
   print(output.content[:100], end="\n" + "-" * 25 + '\n')

Time is a complex and multifaceted concept that has been explored from various perspectives, includi
-------------------------
In economics, the concept of time is multifaceted and plays a crucial role in various theories and m
-------------------------
While my primary focus is on politics, I can provide a brief overview of the concept of time as it m
-------------------------

Ferramentas

Em uma seção anterior, mencionamos que os agentes podem escolher uma combinação de ferramentas à sua disposição para resolver um problema específico, com LLMs como mecanismos de raciocínio.

A LangChain oferece integrações com dezenas de APIs e serviços populares para permitir que os agentes interajam com o resto do mundo. A maioria deles está disponível no pacote langchain_community, enquanto alguns estão em langchain_core.

Por exemplo, veja como você pode usar a ferramenta ArXiv para obter resumos de artigos sobre vários tópicos:

!pip install -Uq arxiv  # Install arXiv Python SDK

from langchain_community.tools import ArxivQueryRun
tool = ArxivQueryRun()
print(tool.invoke('Photosynthesis')[:250])

Published: 2019-08-28
Title: Photosynthesis on Exoplanets and Exomoons from Reflected Light
Authors: Manasvi Lingam, Abraham Loeb
Summary: Photosynthesis offers a convenient means of sustaining biospheres. We
quantify the constraints for photosynthes

Há uma maneira alternativa de carregar ferramentas em vez de importá-las pelo nome da classe:

from langchain_community.agent_toolkits.load_tools import load_tools
tools = load_tools(["arxiv", "dalle-image-generator"])

Acima, estamos carregando as ferramentas de geração de imagens do arXiv e do Dall-E ao mesmo tempo usando a funçãoload_tools(). As ferramentas carregadas com essa função têm a mesma sintaxe de uso:

# Call arXiv
print(tools[0].invoke("Kaggle")[:150])

Published: 2020-06-06
Title: StackOverflow vs Kaggle: A Study of Developer Discussions About Data Science
Authors: David Hin
Summary: Software develop

# Generate an image with DallE
output_image_url = tools[1].invoke("A magnificent chain in a cartoon.")
output_image_url

'https://oaidalleapiprodscus.blob.core.windows.net/...'

A função load_tools exige que você saiba os nomes das strings das classes de ferramentas, como no exemplo ArxivQueryRun versus 'arxiv'. Você pode verificar rapidamente o nome da cadeia de caracteres de qualquer ferramenta executando a função get_all_tool_names:

from langchain_community.agent_toolkits.load_tools import get_all_tool_names
get_all_tool_names()[:10]

['sleep',
'wolfram-alpha',
'google-search',
'google-search-results-json',
'searx-search-results-json',
'bing-search',
'metaphor-search',
'ddg-search',
'google-lens',
'google-serper']

Observe que load_tools() é apenas uma função abreviada. Ao criar agentes, é recomendável carregar ferramentas usando o construtor de classe, o que permite que você as configure com base em seu comportamento específico.

Fluxo de trabalho passo a passo de como criar agentes LangChain

Por fim, nesta seção, veremos como criar agentes LangChain passo a passo usando o conhecimento que adquirimos nas seções anteriores.

Nos próximos exemplos, criaremos um agente capaz de explicar qualquer tópico por meio de três mídias: texto, imagem ou vídeo. Mais especificamente, com base na pergunta feita, o agente decidirá se deve explicar o tópico em qual formato.

Vamos começar. Lembre-se de verificar como configurar o ambiente, que é abordado no início do artigo. 

1. Definição de ferramentas

A primeira etapa após a configuração do nosso ambiente é definir as ferramentas que forneceremos ao nosso agente. Vamos importá-los:

from langchain_community.tools import WikipediaQueryRun  # pip install wikipedia
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_community.tools import YouTubeSearchTool  # pip install youtube_search
from langchain_community.tools.openai_dalle_image_generation import (
   OpenAIDALLEImageGenerationTool
)
from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper

Estamos importando cinco classes:

• WikipediaAPIWrapperPara configurar como você pode acessar a API da Wikipédia, você deve usar o seguinte: .
• WikipediaQueryRunPara gerar resumos de páginas da Wikipédia
• YouTubeSearchTool: para pesquisar vídeos do YouTube sobre tópicos
• DallEAPIWrapperVocê pode configurar como acessar o ponto de extremidade DallE da OpenAI
• OpenAIDALLEImageGenerationToolVocê pode usar os prompts para gerar imagens

Quando um usuário consultar nosso agente, ele decidirá se quer explicar o tópico usando um artigo da Wikipedia em formato de texto, ou criando uma imagem usando o Dall-E para compreensão visual, ou sugerindo vídeos do YouTube para uma compreensão mais profunda.

Vamos inicializá-los, começando com a ferramenta Wikipedia:

wiki_api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=250)
wikipedia = WikipediaQueryRun(description="A tool to explain things in text format. Use this tool if you think the user’s asked concept is best explained through text.", api_wrapper=wiki_api_wrapper)
print(wikipedia.invoke("Mobius strip"))

Page: Möbius strip
Summary: In mathematics, a Möbius strip, Möbius band, or Möbius loop is a surface that can be formed by attaching the ends of a strip of paper together with a half-twist. As a mathematical object, it was discovered by Johann Benedi

Gerador de imagens DallE:

dalle_api_wrapper = DallEAPIWrapper(model="dall-e-3", size="1792x1024")
dalle = OpenAIDALLEImageGenerationTool(
   api_wrapper=dalle_api_wrapper, description="A tool to generate images. Use this tool if you think the user’s asked concept is best explained through an image."
)
output = dalle.invoke("A mountain bike illustration.")
print(output)

Ferramenta de pesquisa do YouTube:

youtube = YouTubeSearchTool(
   description="A tool to search YouTube videos. Use this tool if you think the user’s asked concept can be best explained by watching a video."
)
youtube.run("Oiling a bike's chain")

"['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu', 'https://www.youtube.com/watch?v=T6xyn1FGHiU&pp=ygUVT2lsaW5nIGEgYmlrZSdzIGNoYWlu']"

Tome cuidado especial com as descrições das ferramentas. O agente decidirá qual ferramenta usar com base na descrição que você fornecer. 

Agora, colocaremos as ferramentas em uma lista:

tools = [wikipedia, dalle, youtube]

Já podemos vincular esse conjunto de ferramentas a um modelo de bate-papo sem criar um agente:

chat_model = ChatOpenAI(api_key=api_key)
model_with_tools = chat_model.bind_tools(tools)

Vamos tentar chamar o modelo com uma mensagem simples:

response = model_with_tools.invoke([HumanMessage("What's up?!")])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response: Hello! How can I assist you today?
Tools used in the response: []

O resultado mostra que nenhuma das ferramentas vinculadas foi usada ao gerar uma resposta. Agora, vamos fazer uma pergunta específica que forçaria o modelo a olhar além dos dados de treinamento:

response = model_with_tools.invoke([
   HumanMessage("Can you generate an image of a mountain bike?")
])
print(f"Text response: {response.content}")
print(f"Tools used in the response: {response.tool_calls}")

Text response:
Tools used in the response: [{'name': 'openai_dalle', 'args': {'query': 'mountain bike'}, 'id': 'call_92GBfmsYtPi9TpGuIOFB1pG8', 'type': 'tool_call'}]

Podemos ver que não há saída de texto, mas o DallE da OpenAI é mencionado. A ferramenta ainda não foi chamada; o modelo está simplesmente sugerindo que a usemos. Para realmente chamá-lo, para agir, precisamos criar um agente.

2. Criando um agente simples

Depois de definir o modelo e as ferramentas, criamos o agente. A LangChain oferece uma interface de função de alto nível create_react_agent() a partir do pacotelanggraph para criar rapidamente agentes ReAct (reason and act):

from langgraph.prebuilt import create_react_agent
system_prompt = SystemMessage("You are a helpful bot named Chandler.")
agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)

Ao inicializar o agente com um modelo de bate-papo e uma lista de ferramentas, estamos passando um prompt do sistema para informar ao modelo como se comportar em geral. Agora ele está pronto para aceitar consultas:

from pprint import pprint
response = agent.invoke({"messages": HumanMessage("What's up?")})
pprint(response["messages"])

[HumanMessage(content="What's up?", id='133b9380-cfe1-495a-98f7-b835c874bd57'),
AIMessage(content='Hello! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 112, 'total_tokens': 122}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0a920c15-39b4-4857-ab51-6ea905575dba-0', usage_metadata={'input_tokens': 112, 'output_tokens': 10, 'total_tokens': 122})]

Recebemos uma resposta provável, que é uma resposta de texto simples, sem chamadas de ferramentas. Agora, vamos perguntar algo mais direto ao ponto:

response = agent.invoke({"messages": [
   HumanMessage('Explain how photosynthesis works.')
]})
print(len(response['messages']))

4

Desta vez, há quatro mensagens. Vamos ver os nomes das classes de mensagens e seu conteúdo:

for message in response['messages']:
   print(
       f"{message.__class__.__name__}: {message.content}"
   )  # Print message class name and its content
   print("-" * 20, end="\n")

HumanMessage: Explain how photosynthesis works.
--------------------
AIMessage:
--------------------
ToolMessage: Page: Photosynthesis
Summary: Photosynthesis ( FOH-tə-SINTH-ə-sis) is a system of biological processes by which photosynthetic organisms, such as most plants, algae, and cyanobacteria, convert light energy, typically from sunlight, into the chemical
--------------------
AIMessage: Photosynthesis is a biological process where photosynthetic organisms like plants, algae, and cyanobacteria convert light energy, usually from sunlight, into chemical energy. This process involves capturing light energy through pigments like chlorophyll in plant cells and using it to convert carbon dioxide and water into glucose and oxygen. Glucose serves as a source of energy for the plant, while oxygen is released into the atmosphere as a byproduct. Photosynthesis is crucial for the survival of plants and the balance of oxygen and carbon dioxide in the atmosphere.
--------------------

Aqui vamos nós! A terceira mensagem é de uma chamada de ferramenta, que é um resumo de uma página da Wikipedia sobre fotossíntese. A última mensagem é do modelo de bate-papo, que está usando o conteúdo da chamada da ferramenta ao construir sua resposta.

Vamos criar rapidamente uma função para modular as últimas etapas que realizamos:

def execute(agent, query):
   response = agent.invoke({'messages': [HumanMessage(query)]})
  
   for message in response['messages']:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
      
       print("-" * 20, end="\n")
  
   return response

3. Refinando o prompt do sistema

Agora, vamos atualizar o prompt do sistema com instruções detalhadas sobre como o agente deve se comportar:

system_prompt = SystemMessage(
   """
   You are a helpful bot named Chandler. Your task is to explain topics
   asked by the user via three mediums: text, image or video.
  
   If the asked topic is best explained in text format, use the Wikipedia tool.
   If the topic is best explained by showing a picture of it, generate an image
   of the topic using Dall-E image generator and print the image URL.
   Finally, if video is the best medium to explain the topic, conduct a YouTube search on it
   and return found video links.
   """
)

Vamos recriar nosso agente com o novo prompt do sistema:

agent = create_react_agent(chat_model, tools, state_modifier=system_prompt)
response = execute(agent, query='Explain the Fourier Series visually.')

HumanMessage: Explain the Fourier Series visually.
--------------------
AIMessage:
--------------------
ToolMessage: https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png?st=2024-08-09T18%3A36%3A46Z&se=2024-08-09T20%3A36%3A46Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-08-09T17%3A56%3A46Z&ske=2024-08-10T17%3A56%3A46Z&sks=b&skv=2024-08-04&sig=Ly8F4jvakFeEtpZ/6jMliLq%2BG3Xs%2Bz1AmX1sL06%2BQ3U%3D
--------------------
AIMessage: Here is a visual representation of the Fourier Series:
![Fourier Series](https://oaidalleapiprodscus.blob.core.windows.net/private/org-qRwX4bsgcnaYHHwbxFBdZxUy/user-LOXQPflMtXxamV72hac9oS2O/img-iY3gXXBzWapRWKdmkd9cXEIN.png)
The Fourier Series is a way to represent a function as the sum of simple sine waves. It is used in many areas of mathematics and physics to analyze and understand periodic phenomena.
--------------------

Incrível, com base em nossa mensagem (que foi muito instrutiva:), o agente escolheu a ferramenta correta para o trabalho. Aqui está a imagem gerada:

4. Adição de memória aos agentes

No momento, nosso agente não tem estado, o que significa que ele não se lembra das interações anteriores:

response = execute(agent, query="What did I ask you in the previous query?")

HumanMessage: What did I ask you in the previous query?
--------------------
AIMessage: I'm sorry, I cannot remember the previous query as I don't have access to the conversation history. How can I assist you today?
--------------------

A maneira mais fácil de adicionar o histórico de mensagens de bate-papo aos agentes é usar o langgraph's SqliteSaver classe:

from langgraph.checkpoint.sqlite import SqliteSaver
memory = SqliteSaver.from_conn_string(':agent_history:')
agent = create_react_agent(chat_model, tools, checkpointer=memory, state_modifier=system_prompt)

Inicializamos a memória usando o método .from_conn_string() da classeSqliteSaver, que cria um arquivo de banco de dados. Em seguida, passamos amemória para o parâmetro checkpointer da funçãocreate_react_agent().

Agora, precisamos criar um dicionário de configuração:

config = {'configurable': {'thread_id': 'a1b2c3'}}

O dicionário define um ID de thread para distinguir uma conversa de outra e é passado para o método.invoke() do nosso agente. Portanto, vamos atualizar nossa função execute() para incluir esse comportamento:

def execute(agent, query, thread_id="a1b2c3"):
   config = {"configurable": {"thread_id": thread_id}}
   response = agent.invoke({'messages': [HumanMessage(query)]}, config=config)
   for message in response["messages"]:
       print(
           f"{message.__class__.__name__}: {message.content}"
       )  # Print message class name and its content
       print("-" * 20, end="\n")
   return response
Let’s test it again:
response = execute(
   agent, query="Explain how to oil a bike's chain using a YouTube video", thread_id="123"
)

HumanMessage: Explain how to oil a bike's chain using a YouTube video
--------------------
AIMessage:
--------------------
ToolMessage: ['https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D', 'https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D']
--------------------
AIMessage: I found a couple of YouTube videos that explain how to oil a bike chain:
1. [Video 1: How to oil a bike chain](https://www.youtube.com/watch?v=X1Vze17bhgk&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
2. [Video 2: Step-by-step guide on oiling a bike chain](https://www.youtube.com/watch?v=ubKCHtZ20-0&pp=ygUXaG93IHRvIG9pbCBhIGJpa2UgY2hhaW4%3D)
You can watch these videos to learn how to oil your bike's chain effectively.
--------------------

Agora, vamos perguntar ao agente sobre consultas anteriores:

response = execute(agent, query='What have I asked you so far?', thread_id='123')
print(response)

{'messages': [HumanMessage(content="Explain how to oil a bike's chain using a YouTube video",     id='8254142b-fb77-4958-8ad9-0a0283c6611a'), ...
]

Como esperado, o agente está retornando as mensagens anteriores! Agora, você só precisa de uma interface de usuário de bate-papo como a do ChatGPT e terá um chatbot personalizado.

Tendências e desenvolvimentos futuros

Ao longo do artigo, tivemos um vislumbre de onde a LangChain está indo em termos de agentes. Até muito recentemente, a LangChain usava principalmente o AgentExecutor classe mas ela está sendo lentamente substituída pelos agentes dolanggraph.

Os agentes puros do LangChain são bons para você começar, mas exigem mais linhas de código para criar o mesmo agente do que no LangGraph. Além disso, depois de um certo ponto, a estrutura AgentExecutor não oferecerá a flexibilidade que o LangGraph tem para criar agentes complexos com várias ferramentas.

É por isso que agora é um ótimo momento para você aproveitar a onda e e começar a usar o LangGraph diretamente.

É altamente recomendável que você comece a usar o a usar o LangSmith que se tornou uma parte essencial do ecossistema LangChain para a criação de aplicativos LLM de nível de produção. Aqui estão alguns de seus principais benefícios:

• Depuração: O LangSmith fornece rastreamentos detalhados da execução do seu agente, facilitando a identificação e a correção de problemas.
• Otimização de desempenho: Com o LangSmith, você pode analisar o uso de tokens, a latência e outras métricas de desempenho para otimizar a eficiência do seu agente.
• Testes e avaliações: O LangSmith facilita a criação e o gerenciamento de conjuntos de dados de teste, permitindo que você avalie rigorosamente o desempenho do seu agente em uma série de cenários.
• Monitoramento: Em ambientes de produção, o LangSmith oferece recursos de monitoramento em tempo real, permitindo que você acompanhe o desempenho do seu agente e detecte anomalias rapidamente.

Aqui está como você pode começar a usar o LangSmith:

1. Inscreva-se para obter uma conta gratuita aqui.
2. Definir variáveis de ambiente.

export LANGCHAIN_TRACING_V2="true"

export LANGCHAIN_API_KEY="..."

e você está pronto para começar! Quando você começa a consultar modelos de linguagem/chat, o LangSmith começa a registrar várias métricas sobre cada execução:

Conclusão

Neste artigo, exploramos o que torna os agentes LangChain diferentes das cadeias e os importantes blocos de construção usados para construí-los. Primeiro, apresentamos o que são agentes e como eles diferem dos construtos mais tradicionais da cadeia em relação à flexibilidade e à capacidade de tomar decisões.

Em seguida, analisamos os principais componentes que você precisa conhecer para criar um agente: modelos de bate-papo, ferramentas e modelos de prompt. Por fim, apresentamos dois exemplos que demonstram como você pode criar agentes simples e avançados. O processamento de linguagem natural está se desenvolvendo continuamente, e os agentes LangChain estão na vanguarda desse progresso, abrindo caminho para uma família de IA ainda mais inteligente e versátil.

Aqui estão alguns recursos relacionados para você aumentar sua LangChain:

• Desenvolvimento de aplicativos LLM com o curso LangChain 
• Uma introdução à engenharia de prompts com LangChain 
• Como criar aplicativos LLM com o tutorial LangChain
• Criação de um modelo GPT com recursos de navegação usando ferramentas LangChain
• LangChain vs LlamaIndex: Uma comparação detalhada

Obrigado a você por ler!