Agentes de IA Autônomos com Python e LangChain: Automatize Tarefas Complexas

Aprenda a criar agentes de IA autônomos com Python e LangChain para automatizar tarefas complexas como análise de mercado. Guia prático e passo a passo!

A Inteligência Artificial deu um salto: os LLMs (Modelos de Linguagem Grandes) evoluíram de chatbots para o cérebro de agentes de IA autônomos, capazes de executar tarefas complexas de forma independente.

Se você busca ir além das respostas prontas e construir IAs que planejam, buscam dados em tempo real, utilizam ferramentas e geram insights valiosos de forma proativa, este guia prático é para você.

O que você vai encontrar aqui:

Um mergulho no desenvolvimento de agentes de IA com Python e o framework LangChain.
A construção de um exemplo real e útil: um agente para análise de mercado automatizada.

Ao final, você terá:

Compreensão dos conceitos fundamentais dos agentes de IA autônomos.
Seu próprio agente de IA funcional, pronto para ser adaptado e expandido.
Habilidade para transformar ideias em soluções de IA para problemas reais.

Pronto para construir o futuro da automação inteligente? Continue lendo e eleve suas skills!

Agentes de IA Autônomos: O Que São e Por Que Estão Revolucionando a Tecnologia?

Um agente de IA autônomo é um software inteligente que vai muito além de um programa comum. Ele interage com seu ambiente, coleta dados e, o mais importante, usa essas informações para realizar tarefas de forma independente, visando metas que você define.

Pense nele como um assistente digital proativo e superinteligente: você estabelece o objetivo, e o agente escolhe autonomamente as melhores ações para alcançá-lo.

A Chave: Planejamento e Ação Inteligente (ReAct)

A capacidade de planejamento é o que diferencia um agente de IA autônomo:

Ele não segue apenas um script fixo.
Analisa tarefas complexas e as divide em etapas menores.
Decide quais ferramentas usar (como APIs, bancos de dados ou buscas na web) para cada etapa.
Toma decisões com base nas informações que coleta e no seu progresso.

Essa poderosa capacidade de raciocinar e agir (conhecida como ciclo “Reason and Act” ou ReAct) é o motor de sua eficácia.

Agente Autônomo vs. Chatbot Comum: Qual a Diferença Fundamental?

É comum confundir agentes autônomos com chatbots, mas suas capacidades são distintas:

Chatbot Comum:
Reativo: Geralmente espera por um comando do usuário.
Responde com base em informações pré-definidas ou conhecimento limitado.
Foco: Fornecer informações ou executar tarefas simples e diretas.
Agente de IA Autônomo:
Proativo: Pode iniciar ações e buscar informações de forma independente.
Autônomo: Utiliza múltiplas ferramentas, adapta sua estratégia e aprende para atingir um objetivo complexo.
Foco: Não apenas responde, mas planeja, age e resolve problemas de ponta a ponta.
Exemplo prático: Um agente encarregado de “analisar o sentimento do mercado sobre a empresa X” pode decidir autonomamente buscar notícias recentes, analisar comentários em redes sociais, consultar dados financeiros e, por fim, compilar um relatório coeso.

Gigantes da tecnologia como a Microsoft já veem os agentes de IA como os “aplicativos da era da IA”, essenciais para otimizar processos e resolver desafios de negócios. A AWS também ressalta sua capacidade de tomar decisões baseadas em dados para maximizar resultados.

Aplicações Reais: O Impacto dos Agentes de IA Autônomos

O potencial dos agentes de IA autônomos é imenso e já transforma diversas áreas:

Automação de Processos de Negócios (BPA): Desde triar e-mails e agendar reuniões até otimizar fluxos em CRMs e ERPs.
Pesquisa de Mercado Aprofundada: Coleta e análise de dados sobre concorrentes, tendências e sentimento do consumidor (como exploraremos em nosso exemplo prático!).
Assistentes Pessoais Inteligentes: Gerenciamento de agendas, finanças pessoais e até auxílio em tarefas de programação, aprendendo com suas preferências.
Monitoramento de Sistemas Críticos: Observação do desempenho de redes e aplicações, com capacidade de tomar ações corretivas automaticamente.
Atendimento ao Cliente Avançado: Resolução de problemas complexos, acessando bases de conhecimento, históricos de clientes e até executando transações.
Caso de Sucesso: A Klarna reportou que seus agentes de IA já gerenciam dois terços das consultas de atendimento, realizando o trabalho equivalente a 700 agentes humanos e prevendo uma economia de $40 milhões.
Serviços Financeiros: Análise de risco aprimorada, detecção de fraudes e consultoria de investimentos personalizada.
Agronegócio: Otimização de colheitas, monitoramento de pragas e gestão eficiente de recursos hídricos.

Empresas como Microsoft, Salesforce e UiPath estão na vanguarda, especializando-se na construção e orquestração desses agentes. A Amazon, por exemplo, utiliza agentes de IA para acelerar atualizações de software, enquanto a Palantir desenvolveu um robusto conjunto de 78 agentes para uma grande seguradora americana, demonstrando a escalabilidade e o poder dessa tecnologia.

Python e LangChain: A Combinação Perfeita para Agentes de IA?

Ao embarcar na criação de agentes de IA autônomos, a escolha das ferramentas é um passo decisivo. É aqui que a combinação de Python e LangChain se destaca, oferecendo uma plataforma poderosa, flexível e acessível para desenvolvedores que buscam inovar.

Python: O Alicerce Robusto da Inteligência Artificial Moderna

Não é por acaso que Python se tornou a linguagem preferida para desenvolvimento em Inteligência Artificial (IA) e Machine Learning (ML). Sua popularidade se deve a vantagens claras:

Ecossistema Vasto e Maduro: Python oferece um arsenal incomparável de bibliotecas e frameworks dedicados à IA/ML, como TensorFlow, PyTorch, scikit-learn, Pandas e NumPy. Essa riqueza acelera o desenvolvimento e viabiliza soluções sofisticadas.
Sintaxe Clara e Legível: A simplicidade do Python torna o código mais fácil de escrever, entender e manter. Isso permite que desenvolvedores foquem na lógica da IA, em vez de se prenderem a complexidades da linguagem.
Comunidade Forte e Ativa: A gigantesca comunidade Python é um recurso valioso, oferecendo vasta documentação, tutoriais, fóruns e suporte colaborativo, facilitando o aprendizado e a solução de problemas.
Integração Facilitada: Python se integra de forma eficiente com outras tecnologias e APIs, uma característica crucial para agentes de IA que precisam interagir com diversos sistemas externos e fontes de dados.

LangChain: O “Canivete Suíço” para Orquestrar LLMs em Agentes

Se Python fornece a base sólida, LangChain é o framework que atua como um verdadeiro “canivete suíço”, simplificando a construção de aplicações complexas que utilizam Grandes Modelos de Linguagem (LLMs).

Pense no LangChain como um conjunto de “blocos de montar” (componentes) e “conectores” (integrações) projetado para orquestrar LLMs, ferramentas externas e dados. Ele agiliza o desenvolvimento de:

Chatbots avançados
Sistemas de perguntas e respostas (Q&A)
Geradores de conteúdo e sumarizadores
E, o mais importante para nós: agentes de IA autônomos.

Componentes Essenciais do LangChain para Construir seu Agente

LangChain descomplica a criação de agentes de IA por meio de seus componentes modulares e reutilizáveis:

LLMs (Large Language Models): LangChain oferece uma interface padronizada para interagir com diversos LLMs, incluindo modelos da OpenAI (GPT-3.5, GPT-4), Google (Gemini), Anthropic (Claude) e opções open-source do Hugging Face. Isso permite que você troque o “cérebro” do seu agente com facilidade.
Chains (Correntes): São a espinha dorsal do LangChain. Uma “chain” define uma sequência de chamadas – seja para um LLM, uma ferramenta ou outra chain. Elas permitem construir fluxos de trabalho complexos de maneira estruturada. A LangChain Expression Language (LCEL) é uma forma declarativa e eficaz de montar essas chains, oferecendo recursos como streaming e paralelização.
Prompts (Instruções): A qualidade da interação com um LLM depende criticamente do prompt. LangChain disponibiliza PromptTemplates para criar instruções dinâmicas e reutilizáveis, formatadas com informações variáveis em tempo de execução. Isso é vital para guiar o agente sobre seus objetivos e comportamento esperado.
Tools (Ferramentas): São funções que os agentes utilizam para interagir com o mundo exterior. Podem ser APIs de busca (como Tavily Search), calculadoras, acesso a bancos de dados ou qualquer função Python customizada. As ferramentas concedem “superpoderes” aos agentes, permitindo-lhes buscar informações atualizadas ou executar ações específicas.
Memory (Memória): Para que os agentes mantenham conversas coerentes ou se lembrem de informações de interações anteriores, LangChain oferece diversos mecanismos de memória. Isso dá ao agente o contexto necessário sobre o que já foi discutido ou realizado.
Agents (Agentes): No LangChain, um agente utiliza um LLM como motor de raciocínio para decidir qual sequência de ações tomar. Ele tem acesso a um conjunto de ferramentas e, com base na entrada do usuário e em sua lógica interna (frequentemente utilizando frameworks como ReAct ou a funcionalidade de “tool calling” dos LLMs mais recentes), escolhe qual ferramenta usar, executa a ação, observa o resultado e continua o ciclo até completar a tarefa.

A modularidade e as vastas integrações do LangChain não apenas reduzem significativamente o tempo de desenvolvimento, mas também promovem a reutilização de código e permitem a prototipagem rápida de ideias inovadoras. Essencialmente, ele abstrai muitas das complexidades envolvidas na interação direta com APIs de LLMs e na orquestração dos múltiplos passos lógicos de um agente inteligente.

Prepare-se para Criar Seu Agente de IA: Ferramentas e Pré-Requisitos Essenciais

Antes de mergulharmos na construção do seu agente de IA autônomo, é crucial garantir que seu ambiente de desenvolvimento esteja pronto. Um bom preparo é o segredo para um desenvolvimento fluido e sem surpresas.

Confira o que você vai precisar:

Python 3.10 ou Superior:
Conta em um Provedor de LLM e Chave de API: Seu agente precisará de um “cérebro” na forma de um Grande Modelo de Linguagem (LLM).
Ambiente de Desenvolvimento Integrado (IDE): Escolha o que for mais confortável para você
Tavily API Key: Essencial para nossa ferramenta de busca de notícias.
CoinGecko API Key (Opcional para API Pro): A API pública da CoinGecko para cotações simples geralmente não exige chave (será nosso caso). Para acesso à API Pro com mais funcionalidades, uma chave é necessária.

📌 Prepare-se! Reserve cerca de 10-15 minutos para configurar seu ambiente. Um bom preparo é meio caminho andado para o sucesso do seu agente! 😉

Com tudo isso pronto, estaremos preparados para mergulhar no código e dar vida ao nosso agente de IA!

Mão na Massa: Construindo Seu Primeiro Agente Autônomo com LangChain (Guia Detalhado)

Agora, a parte mais emocionante! Vamos construir juntos, linha por linha, seu primeiro agente de IA autônomo. Este agente será capaz de buscar cotações de criptomoedas e notícias recentes sobre um tópico, demonstrando a capacidade de usar ferramentas (Tools) para interagir com o mundo exterior.

Antes de começar, lembre-se:

Snippets de Código Claros: Os blocos de código serão bem formatados e com destaque de sintaxe.
Comentários Explicativos: Cada trecho de código virá com comentários detalhando sua lógica e função.
Outputs Esperados: Após blocos que geram saídas, mostraremos um exemplo do resultado para você validar seu progresso.

Vamos lá!

🔹 Passo 1: Inicializando o Ambiente e Configurando o LLM

Primeiro, vamos instalar as bibliotecas Python necessárias e configurar nossa chave de API da OpenAI de forma segura.

Instalação das Bibliotecas:

Abra seu terminal (ou uma célula de código em um Jupyter Notebook/Google Colab) e execute:

pip install langchain langchain-openai python-dotenv requests tavily-python langchain-community

langchain: O framework principal.
langchain-openai: Integração com os modelos da OpenAI.
python-dotenv: Para carregar chaves de API de um arquivo .env.
requests: Para fazer chamadas HTTP (ex: para a API da CoinGecko).
tavily-python: SDK Python para a Tavily Search API.
langchain-community: O pacote que agrupa a vasta maioria das integrações de terceiros.

Configuração Segura da Chave de API (API Key):

A segurança das suas chaves de API é crucial. Nunca as coloque diretamente no seu código. Vamos usar um arquivo .env.

1. Crie um arquivo chamado .env na raiz do seu projeto.

2. Adicione suas chaves de API a este arquivo:

 # Dentro do arquivo .env

 OPENAI_API_KEY="sk-SUA_CHAVE_OPENAI_AQUI"
 TAVILY_API_KEY="tvly-SUA_CHAVE_TAVILY_AQUI"
 # COINGECKO_PRO_API_KEY="SUA_CHAVE_COINGECKO_PRO_AQUI" #Opcional, se for usar a API Pro

Substitua pelos seus valores reais.

3. No seu script Python, carregue essas variáveis:

 import os
 from dotenv import load_dotenv

 # Carrega as variáveis de ambiente do arquivo .env
 load_dotenv()

 # Pega as chaves de API das variáveis de ambiente
 openai_api_key = os.getenv("OPENAI_API_KEY")
 tavily_api_key = os.getenv("TAVILY_API_KEY") # Necessário para a TavilySearchResults

 # Verificação opcional para garantir que as chaves foram carregadas
 if not openai_api_key:
   raise ValueError("Chave da OpenAI API não encontrada. Verifique seu arquivo .env.")
 if not tavily_api_key:
   raise ValueError("Chave da Tavily API não encontrada. Verifique seu arquivo .env.")

Este método é uma prática recomendada para gerenciar informações sensíveis.

Instanciação do Modelo LLM:

Vamos instanciar o modelo da OpenAI que será o “cérebro” do nosso agente.

from langchain_openai import ChatOpenAI

# Inicializa o LLM (ex: GPT-3.5 Turbo da OpenAI)
# A temperatura 0 torna as respostas mais determinísticas e factuais, ideal para agentes.
llm = ChatOpenAI(openai_api_key=openai_api_key, model_name="gpt-3.5-turbo", temperature=0)

# Você pode testar o LLM com um prompt simples (opcional)
# response = llm.invoke("Qual a capital da França?")
# print(response.content)

Escolhemos gpt-3.5-turbo por seu equilíbrio entre custo e capacidade, e temperature=0 para respostas mais consistentes. Para usar outro modelo, como gpt-4o-mini, basta alterar o model_name.

Com o ambiente configurado e o LLM instanciado, estamos prontos para definir as ferramentas!

🔹 Passo 2: Definindo e Criando Ferramentas Personalizadas (Tools)

As ferramentas (Tools) dão “superpoderes” ao seu agente, permitindo que ele interaja com o mundo exterior: busque informações na web, acesse APIs, execute cálculos ou qualquer ação programável em Python. O LLM, por si só, tem conhecimento limitado à sua data de treinamento e não pode acessar dados em tempo real ou executar código. As ferramentas preenchem essa lacuna.

Criaremos duas ferramentas:

Para buscar cotações de criptomoedas (API pública da CoinGecko).
Para buscar notícias recentes (Tavily Search API).

Exemplo 1: Ferramenta para Cotações de Criptomoedas (CoinGecko API)

Usaremos o decorador @tool do LangChain para transformar uma função Python em uma ferramenta. A docstring (documentação da função) é crucial, pois o LLM a usará para entender o que a ferramenta faz, seus inputs e quando utilizá-la.

from langchain.tools import tool
import requests # Biblioteca para fazer requisições HTTP

@tool
def buscar_cotacao_cripto(nome_cripto: str) -> str:
  """
  Busca a cotação atual de uma criptomoeda específica em USD (dólares americanos).
  O input 'nome_cripto' deve ser o ID da criptomoeda conforme listado na CoinGecko
  (por exemplo, 'bitcoin', 'ethereum', 'cardano').
  Retorna uma string com a cotação atual em USD ou uma mensagem de erro.
  """
  
  try:
      url = f"https://api.coingecko.com/api/v3/simple/price?ids={nome_cripto.lower()}&vs_currencies=usd"
      print(f"\n[buscar_cotacao_cripto] Chamando API CoinGecko: {url}") # Log para depuração
      response = requests.get(url)
      response.raise_for_status() # Levanta erro para respostas ruins (4XX ou 5XX)
      data = response.json()
      print(f"[buscar_cotacao_cripto] Resposta da API: {data}") # Log

      id_cripto_lower = nome_cripto.lower()
      if id_cripto_lower in data and 'usd' in data[id_cripto_lower]:
          preco = data[id_cripto_lower]['usd']
          return f"A cotação atual de {nome_cripto.capitalize()} é ${preco:,.2f} USD."
      else:
          return f"Não foi possível encontrar a cotação em USD para {nome_cripto}."
  except requests.exceptions.HTTPError as http_err:
      return f"Erro HTTP ao buscar cotação de {nome_cripto}: {http_err}. Resposta: {response.text}"
  except requests.exceptions.RequestException as req_err:
      return f"Erro de requisição ao buscar cotação de {nome_cripto}: {req_err}"
  except Exception as e:
      return f"Ocorreu um erro inesperado ao processar cotação de {nome_cripto}: {e}"

# Teste opcional da ferramenta:
# print(buscar_cotacao_cripto.run({"nome_cripto": "bitcoin"}))
# print(buscar_cotacao_cripto.run("ethereum"))

Output Esperado (para bitcoin, o preço varia):

[buscar_cotacao_cripto] Chamando API CoinGecko: https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd
[buscar_cotacao_cripto] Resposta da API: {'bitcoin': {'usd': 103986}}
A cotação atual de Bitcoin é $103,986.00 USD.

Exemplo 2: Ferramenta para Notícias Recentes (Tavily Search API)

A Tavily Search API é otimizada para LLMs, fornecendo resultados concisos e relevantes.

from langchain_community.tools.tavily_search import TavilySearchResults

@tool
def buscar_noticias_recentes_tavily(topico_da_pesquisa: str, numero_maximo_de_resultados: int = 3) -> str:
  """
  Busca notícias e informações recentes online sobre um 'topico_da_pesquisa' específico usando a Tavily Search API.
  O input 'numero_maximo_de_resultados' (opcional, padrão 3) define quantos resultados retornar.
  Retorna um resumo formatado das notícias encontradas ou uma mensagem de erro.
  """
  try:
      print(f"\n[buscar_noticias_recentes_tavily] Pesquisando por: '{topico_da_pesquisa}', max_results={numero_maximo_de_resultados}")
      search_tool_instance = TavilySearchResults(max_results=numero_maximo_de_resultados)
      results = search_tool_instance.invoke(input=topico_da_pesquisa)
      print(f"[buscar_noticias_recentes_tavily] Resultados da Tavily: {results}")
      if not results:
          return f"Nenhuma notícia recente encontrada para '{topico_da_pesquisa}'."
      formatted_output = f"Principais notícias sobre '{topico_da_pesquisa}':\n\n"
      if not isinstance(results, list): # Tavily pode retornar dict único se max_results=1
          results = [results]
      for i, res_item in enumerate(results):
          title = res_item.get('title', 'N/A')
          url = res_item.get('url', 'N/A')
          content_preview = (res_item.get('content', 'N/A')[:250] + "...") if res_item.get('content') else 'N/A'
          formatted_output += f"{i+1}. {title}\n   URL: {url}\n   Preview: {content_preview}\n\n"
      return formatted_output.strip()
  except Exception as e:
      return f"Erro ao buscar notícias sobre '{topico_da_pesquisa}' com Tavily: {e}"

# Teste opcional da ferramenta:
# print(buscar_noticias_recentes_tavily.run({"topico_da_pesquisa": "IA generativa", "numero_maximo_de_resultados": 1}))

Output Esperado (para IA generativa, o conteúdo varia):

[buscar_noticias_recentes_tavily] Pesquisando por: 'IA generativa', max_results=1
[buscar_noticias_recentes_tavily] Resultados da Tavily: [{'title': 'O que é IA Generativa?', 'url': 'https://exemplo.com/ia-generativa', 'content': 'IA Generativa é um tipo de inteligência artificial capaz de criar conteúdo original...'}]
Principais notícias sobre 'IA generativa':

1. O que é IA Generativa?
 URL: https://exemplo.com/ia-generativa
 Preview: IA Generativa é um tipo de inteligência artificial capaz de criar conteúdo original......

Com nossas ferramentas prontas, vamos montar o agente!

🔹 Passo 3: Construindo e Configurando o Agente com LangChain

O agente usará o LLM para decidir quais ferramentas chamar e como processar suas respostas.

Escolha do Tipo de Agente: Para modelos OpenAI que suportam “tool calling” (como gpt-3.5-turbo-0125 e a família GPT-4), a função create_openai_tools_agent é robusta e recomendada. Ela permite ao modelo indicar de forma estruturada qual ferramenta usar.

Integrando LLM, Ferramentas e Prompt:

1. Reunir as Ferramentas:

tools = [buscar_cotacao_cripto, buscar_noticias_recentes_tavily]

2. Carregar um Prompt Otimizado (LangChain Hub): O LangChain Hub oferece prompts pré-construídos. Usaremos um otimizado para OpenAI Tools.

 from langchain import hub
 
 # Puxa um prompt do LangChain Hub otimizado para agentes com OpenAI Tools.
 # Inclui placeholders como "input", "chat_history" (opcional), e "agent_scratchpad".
 prompt = hub.pull("hwchase17/openai-tools-agent")
 
 # Para inspecionar a estrutura do prompt (opcional):
 # print(prompt.pretty_print())

Usar um prompt do Hub economiza tempo e garante uma estrutura testada.

3. Criar o Agente Lógico:

Esta função combina o LLM, as ferramentas e o prompt.

 from langchain.agents import create_openai_tools_agent
      
 # Cria o "cérebro" do agente que decide o próximo passo.
 agent = create_openai_tools_agent(llm, tools, prompt)

4. Criando o Executor do Agente (AgentExecutor):

Para rodar o agente em um ciclo de pensamento-ação-observação, usamos o AgentExecutor.

 from langchain.agents import AgentExecutor
 # Cria o executor que gerencia o fluxo de execução do agente.
 # verbose=True é ESSENCIAL para vermos os "pensamentos" e ações do agente.
 agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

O verbose=True é crucial para entender o processo de tomada de decisão do agente.

Lógica de Tomada de Decisão (OpenAI Tool Calling):

Quando o agent_executor é invocado:

A entrada do usuário é combinada com o prompt.
O LLM recebe o prompt formatado e as definições das ferramentas.
O LLM decide se responde diretamente ou se chama uma (ou mais) ferramentas.
Se uma ferramenta é chamada, o LLM retorna uma instrução estruturada.
O AgentExecutor executa a ferramenta.
O resultado (observação) volta para o LLM (via agent_scratchpad).
O LLM processa a nova informação e decide o próximo passo (responder, chamar outra ferramenta, etc.).
O ciclo continua até uma resposta final ser gerada.

Nosso agente está montado! No próximo passo, vamos colocá-lo para trabalhar.

🔹 Passo 4: Rodando, Testando e Iterando Seu Agente

Vamos fornecer um input e observar como ele utiliza as ferramentas.

Exemplo de Input para o Agente:

input_usuario = "Qual a cotação atual do Bitcoin e quais as principais notícias sobre ele nas últimas 24 horas?"

Invocando o Agente:

print(f"Executando agente com input: '{input_usuario}'\n")
response = agent_executor.invoke({"input": input_usuario})

print("\n\n--------------------------------------------------")
print("Conteúdo da Resposta Final do Agente:")
print("--------------------------------------------------")
print(response["output"])

Output Esperado com verbose=True (conteúdo exato varia):

Executando agente com input: 'Qual a cotação atual do Bitcoin e quais as principais notícias sobre ele nas últimas 24 horas?'

> Entering new AgentExecutor chain...

Invoking: `buscar_cotacao_cripto` with `{'nome_cripto': 'bitcoin'}`
[buscar_cotacao_cripto] Chamando API CoinGecko: https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd
[buscar_cotacao_cripto] Resposta da API: {'bitcoin': {'usd': 103986}}
Tool AngleBracketSingleLeftbuscar_cotacao_criptoAngleBracketSingleRight
A cotação atual de Bitcoin é $103,986.00 USD.
AngleBracketSingleLeft/buscar_cotacao_criptoAngleBracketSingleRight
Invoking: `buscar_noticias_recentes_tavily` with `{'topico_da_pesquisa': 'Bitcoin', 'numero_maximo_de_resultados': 2}`
[buscar_noticias_recentes_tavily] Pesquisando por: 'Bitcoin', max_results=2
[buscar_noticias_recentes_tavily] Resultados da Tavily: [...]
Tool AngleBracketSingleLeftbuscar_noticias_recentes_tavilyAngleBracketSingleRight
Principais notícias sobre 'Bitcoin':
1. Bitcoin atinge nova máxima...
 URL: ...
 Preview: ...
2. Reguladores discutem futuro...
 URL: ...
 Preview: ...
AngleBracketSingleLeft/buscar_noticias_recentes_tavilyAngleBracketSingleRight
A cotação atual do Bitcoin é $103,986 USD.
As principais notícias sobre ele incluem:
1. Bitcoin atinge nova máxima histórica impulsionado por ETFs (...), detalhando como o influxo de capital em ETFs de Bitcoin à vista impulsionou o preço.
2. Reguladores discutem futuro da criptomoeda em simpósio global (...), abordando discussões sobre a necessidade de uma estrutura regulatória unificada.

> Finished chain.

--------------------------------------------------
Conteúdo da Resposta Final do Agente:
--------------------------------------------------
A cotação atual do Bitcoin é $103,986.00 USD.
As principais notícias sobre ele incluem:
1. Bitcoin atinge nova máxima histórica impulsionado por ETFs (...), detalhando como o influxo de capital em ETFs de Bitcoin à vista impulsionou o preço.
2. Reguladores discutem futuro da criptomoeda em simpósio global (...), abordando discussões sobre a necessidade de uma estrutura regulatória unificada.

(Nota: O formato exato do verbose=True para create_openai_tools_agent pode mostrar as chamadas de ferramenta de forma um pouco diferente do clássico “Thought, Action, Observation” do ReAct, focando nas invocações de ferramentas que o LLM decide fazer.)

Analisando o Output: Observe como o LLM identificou a necessidade de usar ambas as ferramentas e, após receber os resultados, formulou a resposta final.

Iteração e Experimentação: Teste diferentes inputs:

“Qual o preço do Ethereum?”
“Quais as últimas novidades sobre exploração espacial?”
“Só quero saber a cotação do Cardano.” Observe como o agente decide quais ferramentas usar.

💡 Pulo do Gato: Debugando seu Agente LangChain Seu agente não se comporta como esperado?

verbose=True no AgentExecutor: Sua principal ferramenta. Analise o fluxo detalhado.
LangSmith: Plataforma de observabilidade do LangChain.

Para usar:

Crie uma conta.
Configure as variáveis de ambiente:

# No seu .env
LANGCHAIN_TRACING_V2="true"
LANGCHAIN_API_KEY="SUA_CHAVE_API_LANGSMITH_AQUI"
LANGCHAIN_PROJECT="NomeDoSeuProjetoAgente"
# LANGCHAIN_ENDPOINT="https://api.smith.langchain.com" # Geralmente não precisa

Isso loga todas as execuções no LangSmith para uma análise visual detalhada.

3. Verifique as Docstrings das Ferramentas: Devem ser claras sobre o que a ferramenta faz, inputs e outputs. Ambiguidade confunde o LLM.

4. Teste as Ferramentas Isoladamente: Garanta que funcionam corretamente antes de integrar.

5. Simplifique o Prompt do Agente (se customizado): Comece simples.

6. Verifique a Temperatura do LLM: Para agentes, temperaturas baixas (ex: 0 ou 0.1) são mais previsíveis.

Lembre-se: construir agentes é um processo iterativo!

Parabéns! Você construiu e testou seu primeiro agente de IA.

📌 Desafie-se! Fantástico, não? 🔥 Imagine aplicar esse conceito para automatizar propostas comerciais, gerar relatórios de bugs, triar currículos ou monitorar o sentimento online sobre sua marca. As possibilidades são infinitas!

Referências e Leitura Adicional

Documentação Oficial:

LangChain Python Documentation: https://python.langchain.com/
OpenAI API Documentation: https://platform.openai.com/docs
Python Official Website: https://www.python.org/

Bibliotecas e APIs Usadas (Documentação):

CoinGecko API: https://www.coingecko.com/en/api/documentation
Tavily Search API: https://tavily.com/documentation

Outros Recursos:

LangSmith: https://smith.langchain.com/