Autor: Priya Sharma – Arquiteto de API e Consultor para Integração de IA
A capacidade de criar sistemas inteligentes capazes de compreender instruções, raciocinar e agir autonomamente está transformando nossa maneira de interagir com a tecnologia. No centro dessa transformação estão os agentes de IA – entidades de software projetadas para executar tarefas utilizando o poder dos Modelos de Linguagem de Grande Escala (LLM) e ferramentas externas. Embora o conceito possa parecer complexo, frameworks como LangChain simplificaram significativamente o processo de desenvolvimento, tornando a criação de agentes acessível a um público mais amplo.
Como arquiteto de API e consultor para a integração de IA, vi de perto o potencial incrível dos agentes de IA bem projetados. Eles podem automatizar fluxos de trabalho complexos, fornecer assistência personalizada e desbloquear novas capacidades para empresas e indivíduos. Este guia prático o conduzirá através do processo de construção de agentes de IA sólidos usando a API do LangChain, desde a compreensão dos componentes fundamentais até a implementação de exemplos práticos e do mundo real. No final, você terá uma base sólida para projetar e implantar seus agentes inteligentes, prontos para enfrentar uma multitude de desafios.
Compreendendo os Agentes de IA e o Papel do LangChain
Antes de explorar o código, vamos esclarecer o que é um agente de IA e por que LangChain é uma ferramenta indispensável para sua construção. Um agente de IA é um sistema que utiliza um LLM como “cérebro” para decidir quais ações tomar. Ao contrário de uma simples chamada a um LLM que gera uma única resposta, um agente pode se envolver em um processo de raciocínio em várias etapas:
- Perceber: Compreender a entrada do usuário ou o estado atual.
- Raciocinar: Determinar o melhor curso de ação com base em sua compreensão e nas ferramentas disponíveis.
- Agir: Executar uma ou mais ações usando ferramentas externas.
- Aprender (opcional, mas poderoso): Incorporar feedback para melhorar o desempenho futuro.
LangChain fornece a estrutura necessária para construir esses agentes sofisticados. Oferece uma maneira estruturada de conectar os LLM a várias fontes de dados e ferramentas computacionais, permitindo que eles vão além da simples geração de texto. Considere o LangChain como o sistema operacional para o seu agente de IA, fornecendo a estrutura para sua inteligência, memória e capacidade de interagir com o mundo.
Componentes Chave de um Agente LangChain
Para construir um agente com LangChain, você trabalhará principalmente com estes componentes fundamentais:
- Modelo de Linguagem de Grande Escala (LLM): O núcleo da inteligência. Isso pode ser os modelos GPT da OpenAI, Claude da Anthropic ou alternativas de código aberto. O LLM processa entradas, raciocina e fornece decisões.
- Ferramentas: Funções que o agente pode chamar para interagir com sistemas externos ou realizar cálculos específicos. Exemplos incluem buscar na web, interrogar um banco de dados, chamar uma calculadora ou interagir com uma API personalizada.
- Kit de Ferramentas: Coleções de ferramentas relacionadas projetadas para casos de uso específicos (por exemplo, um “kit de ferramentas do Wikipedia” ou um “kit de ferramentas para agentes CSV”).
- Executor do Agente: O tempo de execução que orquestra as ações do agente. Toma as decisões do LLM, executa as ferramentas escolhidas e retorna os resultados ao LLM para mais raciocínios.
- Memória: Permite que o agente mantenha informações de interações anteriores, possibilitando conversas coerentes em múltiplos turnos e decisões contextualizadas.
- Modelos de Prompt: Definem como a entrada do usuário e outras informações são formatadas para o LLM, orientando seu processo de raciocínio.
Configurando seu Ambiente e Primeiros Passos
Antes de escrever qualquer código de agente, certifique-se de que seu ambiente Python esteja pronto. Você precisará do Python 3.8+ e da biblioteca LangChain, juntamente com qualquer fornecedor de LLM que pretende usar.
Instalação
Instale o LangChain e um fornecedor de LLM (por exemplo, OpenAI):
pip install langchain langchain-openai
pip install python-dotenv # Para gerenciar as chaves API de forma seguraGerencie suas chaves API de forma segura. Crie um arquivo .env na raiz do seu projeto:
OPENAI_API_KEY="your_openai_api_key_here"Então, carregue-o no seu script Python:
import os
from dotenv import load_dotenv
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")Interação Básica com LLM
Para confirmar sua configuração, vamos fazer uma chamada simples ao LLM:
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Usando um modelo poderoso com saída determinística
messages = [
HumanMessage(content="Qual é a capital da França?")
]
response = llm.invoke(messages)
print(response.content)Essa interação básica confirma que sua conexão LLM está funcionando. Agora, vamos habilitar nosso LLM com ferramentas.
Crie Ferramentas para o Seu Agente AI
As ferramentas são as mãos e os pés do agente, permitindo que ele interaja com o mundo externo. LangChain torna a definição das ferramentas simples. Cada ferramenta deve ter um nome claro, uma descrição e uma função que executa a ação.
Exemplo: Uma Ferramenta Calculadora Simples
Vamos criar uma ferramenta que possa executar operações aritméticas básicas. Embora os LLM possam fazer cálculos simples, ferramentas externas são mais confiáveis para cálculos complexos.
from langchain.tools import tool
@tool
def calculator(expression: str) -> str:
"""Avalia uma expressão matemática e retorna o resultado.
A entrada deve ser uma string contendo uma expressão matemática válida, por exemplo, '2 + 2' ou '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Erro na avaliação da expressão: {e}"
# Você pode testar a ferramenta diretamente
print(calculator.invoke("10 * 5 + 3"))Note o decorador @tool. Isso converte automaticamente sua função em uma ferramenta LangChain. A docstring é crucial, pois serve como descrição da ferramenta, que o LLM utiliza para entender quando e como usá-la.
Exemplo: Uma Ferramenta de Pesquisa Web (Usando Tavily)
A maioria dos agentes poderosos precisa de acesso a informações atualizadas. Uma ferramenta de pesquisa na web é fundamental. Usaremos Tavily, uma API de pesquisa projetada especificamente para casos de uso RAG (Geração Aumentada por Recuperação) e agentes.
Primeiro, instale o Tavily e configure sua chave API no seu arquivo .env:
pip install tavily-pythonTAVILY_API_KEY="your_tavily_api_key_here"Em seguida, carregue-a:
import os
from dotenv import load_dotenv
from langchain_community.tools.tavily_search import TavilySearchResults
load_dotenv()
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# Cria a ferramenta de pesquisa Tavily
search = TavilySearchResults(max_results=3) # Obtenha os primeiros 3 resultados
# Você também pode personalizar o nome e a descrição se necessário
# search.name = "web_search"
# search.description = "Pesquise na web informações."
# Teste a ferramenta de pesquisa
print(search.invoke("tutorial agente LangChain"))Definindo essas ferramentas, estamos dando ao nosso agente as capacidades necessárias para expandir seu conhecimento além dos dados de treinamento e realizar cálculos precisos.
Construindo Seu Primeiro Agente LangChain
Com nosso LLM e as ferramentas prontas, agora podemos montar nosso primeiro agente LangChain. Usaremos o método “create_openai_functions_agent”, que é uma maneira conveniente de construir agentes que utilizam as capacidades de chamada de funções da OpenAI.
Passos para a Construção do Agente
- Defina seu LLM: O cérebro do seu agente.
- Defina suas Ferramentas: As capacidades que seu agente possui.
- Crie um Modelo de Prompt: Guie o LLM sobre como se comportar.
- Crie o Agente: Combine LLM, ferramentas e prompts.
- Crie o Executor do Agente: O runtime que executa as decisões do agente.
“`html
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
# Carrega as variáveis de ambiente
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# 1. Define o LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# 2. Define as Ferramentas
@tool
def calculator(expression: str) -> str:
"""Avalia uma expressão matemática e retorna o resultado.
A entrada deve ser uma string contendo uma expressão matemática válida, por exemplo, '2 + 2' ou '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Erro na avaliação da expressão: {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Procura na web informações atuais sobre uma determinada consulta."
tools = [calculator, search]
# 3. Cria um Modelo de Prompt
prompt = ChatPromptTemplate.from_messages(
[
("system", "Você é um assistente AI útil. Responda às perguntas da maneira mais precisa possível."),
MessagesPlaceholder(variable_name="chat_history"),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# 4. Cria o Agente
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Cria o Executor do Agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Executa o agente
# print("--- Execução Agente 1 (Cálculo Simples) ---")
# result1 = agent_executor.invoke({"input": "Qual é 12345 * 6789?", "chat_history": []})
# print(result1["output"])
# print("\n--- Execução Agente 2 (Busca na Web) ---")
# result2 = agent_executor.invoke({"input": "Qual é a capital de Portugal e qual é a sua população atual?", "chat_history": []})
# print(result2["output"])
# print("\n--- Execução Agente 3 (Combinado) ---")
# result3 = agent_executor.invoke({"input": "Qual é a raiz quadrada de 81 e quem inventou a World Wide Web?", "chat_history": []})
# print(result3["output"])Quando você configura verbose=True no AgentExecutor, verá o processo de pensamento do agente: quais ferramentas ele considera, quais seleciona, a entrada que fornece à ferramenta e a saída da ferramenta. Isso é extremamente útil para depuração e para compreender como seu agente raciocina.
Compreender o Modelo de Prompt
system: Define a personalidade geral e as instruções para o agente.MessagesPlaceholder(variable_name="chat_history"): Aqui serão inseridos os turnos de conversa anteriores, permitindo a memória.human: A entrada atual do usuário.MessagesPlaceholder(variable_name="agent_scratchpad"): Aqui são armazenados o processo de pensamento interno do agente e as saídas das ferramentas durante uma única invocação, permitindo que o LLM raciocine passo a passo.
Adicionar Memória e Estado ao Seu Agente AI
Um agente verdadeiramente inteligente precisa de memória para manter o contexto em vários turnos de uma conversa. O LangChain fornece vários tipos de memória, permitindo que seu agente lembre interações passadas.
Por que a Memória é Importante
- Coerência: Os agentes podem fazer referência a declarações e perguntas anteriores.
- Personalização: Os agentes podem lembrar as preferências dos usuários ou interações passadas.
- Eficiência: Evita a repetição de informações ou de pedir esclarecimentos sobre detalhes já fornecidos.
Implementar ConversationBufferMemory
ConversationBufferMemory é um tipo de memória simples, mas eficaz, que armazena diretamente todas as mensagens anteriores.
“““html
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferMemory # Importa a memória
# Carrega as variáveis de ambiente
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# LLM e Ferramentas (mesmas de antes)
llm = ChatOpenAI(model="gpt-4o", temperature=0)
@tool
def calculator(expression: str) -> str:
"""Avalia uma expressão matemática e retorna o resultado.
A entrada deve ser uma string contendo uma expressão matemática válida, como '2 + 2' ou '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Erro na avaliação da expressão: {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Procura na web informações atuais sobre uma determinada consulta."
tools = [calculator, search]
# Cria um Modelo de Prompt (note o placeholder `chat_history`)
prompt = ChatPromptTemplate.from_messages(
[
("system", "Você é um assistente de IA útil. Lembre-se das interações anteriores e responda às perguntas da maneira mais precisa possível."),
MessagesPlaceholder(variable_name="chat_history"), # Aqui a memória será injetada
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# Inicializa a memória
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Cria o Agente
agent = create_openai_functions_agent(llm, tools, prompt)
# Cria o Executor do Agente, passando a memória
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)
# Executa o agente com memória
print("--- Execução do Agente com Memória ---")
print("\nUsuário: Qual é a capital da Espanha?")
result1 = agent_executor.invoke({"input": "Qual é a capital da Espanha?"})
print("Agente:", result1["output"])
print("\nUsuário: Qual é a sua população?")
result2 = agent_executor.invoke({"input": "Qual é a sua população?"})
print("Agente:", result2["output"])
print("\nUsuário: E quanto à população da capital da França?")
result3 = agent_executor.invoke({"input": "E quanto à população da capital da França?"})
print("Agente:", result3["output"])Neste exemplo, o agente lembra “Espanha” da primeira rodada e “capital da França” da terceira, permitindo-lhe fornecer respostas relevantes sem necessidade de repetir explicitamente o país. A memory_key="chat_history" garante que o conteúdo da memória seja mapeado corretamente para o MessagesPlaceholder(variable_name="chat_history") em nosso prompt.
Outros Tipos de Memória
Artigos Relacionados
- Compreender a fundo os modelos de design API eficazes
- APIs de streaming para agentes de IA
- Qdrant vs FAISS: qual escolher para startups
“`
🕒 Published: