Comparação do Agent SDK: Um Tutorial Prático para Construir Aplicações Inteligentes

Introdução: A Ascensão dos Agentes Inteligentes e Seus SDKs

No espaço em rápida evolução da inteligência artificial, os agentes inteligentes estão se tornando cada vez mais integrais a uma ampla gama de aplicações. De chatbots de atendimento ao cliente e assistentes pessoais a sofisticadas ferramentas de análise de dados e sistemas autônomos, os agentes são projetados para perceber seu ambiente, raciocinar sobre suas observações e tomar ações para alcançar objetivos específicos. No entanto, a construção desses agentes requer estruturas e ferramentas sólidas, frequentemente fornecidas na forma de Kits de Desenvolvimento de Software (SDKs).

Um SDK de Agente geralmente oferece uma coleção de bibliotecas, APIs e ferramentas de desenvolvimento que agilizam o processo de criação, implantação e gerenciamento de agentes inteligentes. Esses SDKs abstraem muita da complexidade subjacente, permitindo que os desenvolvedores se concentrem na lógica do agente, representação do conhecimento e padrões de interação. Com uma infinidade de SDKs disponíveis, escolher o certo para seu projeto pode ser uma tarefa assustadora. Este tutorial tem como objetivo desmistificar esse processo, comparando alguns SDKs de Agente populares por meio de exemplos práticos, ajudando você a tomar uma decisão informada.

Exploraremos as funcionalidades, pontos fortes e casos de uso ideais de vários SDKs proeminentes, fornecendo trechos de código e explicações para ilustrar sua aplicação prática. Nosso objetivo é equipá-lo com o conhecimento para selecionar e efetivamente usar um SDK de Agente para dar vida às suas aplicações inteligentes.

Considerações Chave ao Escolher um SDK de Agente

Antes de explorar SDKs específicos, é crucial entender os critérios que devem guiar sua seleção:

• Suporte a Linguagem de Programação: O SDK suporta sua linguagem preferida (Python, Java, JavaScript, etc.)?
• Paradigma do Agente: Ele se alinha com o tipo de agente que você está construindo (por exemplo, reativo, deliberativo, BDI)?
• Escalabilidade e Desempenho: Ele pode lidar com a carga e complexidade esperadas do seu sistema de agentes?
• Facilidade de Uso e Curva de Aprendizado: Quão simples é começar e desenvolver com o SDK?
• Comunidade e Documentação: Há suporte ativo da comunidade e documentação abrangente?
• Capacidades de Integração: Quão bem ele se integra com outras ferramentas e serviços (bancos de dados, plataformas de nuvem, bibliotecas de PNL)?
• Extensibilidade: Você pode facilmente estender suas funcionalidades ou integrar componentes personalizados?
• Licenciamento e Custo: É open-source, comercial ou tem termos de licenciamento específicos?

SDK 1: Rasa – A Potência da IA Conversacional

Visão Geral

Rasa é um framework de aprendizado de máquina open-source para conversas automatizadas por texto e voz. É especialmente adequado para a construção de chatbots sofisticados e assistentes virtuais. O Rasa fornece um conjunto completo de ferramentas para compreensão de linguagem natural (NLU), gerenciamento de diálogos e geração de respostas, permitindo que os desenvolvedores criem agentes conversacionais altamente contextuais e inteligentes.

Principais Recursos

• Compreensão de Linguagem Natural (NLU): Extrai intenções e entidades das mensagens dos usuários.
• Gerenciamento de Diálogo: Gerencia o fluxo da conversa, monitorando o contexto e decidindo a próxima ação.
• Ações Personalizadas: Permite integração com APIs e bancos de dados externos.
• Gestão de Dados de Treinamento: Ferramentas para criar e gerenciar exemplos de treinamento.
• Escalabilidade: Projetado para implantações em produção.

Exemplo Prático: Um Bot de Clima Simples

Vamos criar um bot de clima básico usando Rasa. Primeiro, você precisará instalar o Rasa:

pip install rasa

Em seguida, inicialize um novo projeto Rasa:

rasa init --no-prompt

Isso cria uma estrutura básica do projeto. Vamos modificar data/nlu.yml, data/stories.yml e domain.yml.

data/nlu.yml (Dados de Treinamento NLU)

version: "3.1"
nlu:
- intent: greet
 examples: |
 - oi
 - olá
 - bom dia
- intent: ask_weather
 examples: |
 - como está o clima
 - me fale sobre o clima
 - está ensolarado em [Londres](city)
 - como está o clima em [Paris](city)
- intent: thank_you
 examples: |
 - obrigado
 - valeu
- intent: goodbye
 examples: |
 - adeus
 - tchau

data/stories.yml (Histórias de Diálogo)

version: "3.1"
stories:
- story: caminho feliz
 steps:
 - intent: greet
 - action: utter_greet
 - intent: ask_weather
 - action: utter_ask_city
 - intent: ask_weather
 entities:
 - city: "Nova York"
 - action: action_fetch_weather
 - intent: thank_you
 - action: utter_you_welcome
 - intent: goodbye
 - action: utter_goodbye

domain.yml (Domínio do Agente)

version: "3.1"
intents:
 - greet
 - ask_weather
 - thank_you
 - goodbye

entities:
 - city

slots:
 city:
 type: text
 influence_conversation: true
 mappings:
 - type: from_entity
 entity: city

responses:
 utter_greet:
 - text: "Olá! Como posso ajudar você hoje?"
 utter_ask_city:
 - text: "Em qual cidade você está interessado?"
 utter_you_welcome:
 - text: "De nada!"
 utter_goodbye:
 - text: "Adeus! Tenha um ótimo dia."

actions:
 - action_fetch_weather

session_config:
 session_expiration_time: 60
 carry_over_slots_to_new_session: true

actions.py (Ação Personalizada)

from typing import Any, Text, Dict, List

from rasa_sdk import Action, Tracker
from rasa_sdk.executor import CollectingDispatcher
from rasa_sdk.events import SlotSet

import requests # Para buscar dados reais do clima, ou simular para simplicidade

class ActionFetchWeather(Action):

 def name(self) -> Text:
 return "action_fetch_weather"

 def run(self, dispatcher: CollectingDispatcher, tracker: Tracker,
 domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:

 city = tracker.get_slot("city")

 if not city:
 dispatcher.utter_message(text="Não consegui captar a cidade. Você poderia me dizer em qual cidade está?")
 return []

 # Em uma aplicação real, você chamaria uma API de clima aqui.
 # Para este exemplo, usaremos uma resposta simulada.
 weather_data = {
 "London": "Está nublado com chance de chuva.",
 "Paris": "Ensolarado e quente.",
 "New York": "Um pouco frio, cerca de 10 graus Celsius."
 }

 response = weather_data.get(city, f"Desculpe, não tenho informações sobre o clima para {city} no momento.")
 dispatcher.utter_message(text=response)

 return [SlotSet("city", None)] # Limpa o slot da cidade após fornecer o clima

Para rodar isso, treine o modelo Rasa:

rasa train

Em seguida, inicie o servidor Rasa e o servidor de ações (em terminais separados):

rasa run -m models --enable-api --cors "*"
rasa run actions

Você pode então interagir com seu bot via linha de comando:

rasa shell

Pontos Fortes: Excelente para IA conversacional, forte NLU e gerenciamento de diálogos, open-source, comunidade ativa.
Pontos Fracos: Curva de aprendizado mais acentuada para tarefas não conversacionais, foco principalmente em interação por texto/voz.
Caso de Uso Ideal: Chatbots, assistentes virtuais, interfaces conversacionais para aplicações.

SDK 2: AIMA Python – Agentes de IA Clássicos para Educação e Pesquisa

Visão Geral

O livro ‘Inteligência Artificial: Uma Abordagem Moderna’ (AIMA) de Russell e Norvig é uma pedra angular da educação em IA. O repositório de código Python que o acompanha, frequentemente referido como AIMA Python, fornece implementações de muitos algoritmos clássicos de IA e estruturas de agentes discutidas no livro. Embora não seja um SDK completo para produção, é um recurso valioso para entender conceitos fundamentais de agentes e prototipar sistemas inteligentes simples.

Principais Recursos

• Arquiteturas de Agentes Clássicos: Implementações de agentes reflexivos simples, agentes reflexivos baseados em modelo, agentes baseados em objetivos e agentes baseados em utilidade.
• Algoritmos de Busca: Vários algoritmos de busca (BFS, DFS, A*, etc.) para resolução de problemas.
• Lógica e Planejamento: Ferramentas básicas para lógica proposicional, lógica de primeira ordem e planejamento.
• Foco Educacional: Projetado para ilustrar princípios fundamentais de IA.

Exemplo Prático: Um Agente Reflexivo Simples (Mundo do Aspirador de Pó)

Vamos implementar um agente reflexivo simples para o clássico mundo do aspirador de pó. Este agente percebe sua localização atual e se está suja, então age com base em um conjunto predefinido de regras.

Primeiro, você precisará clonar ou baixar o repositório AIMA Python:

git clone https://github.com/aimacode/aima-python.git

Navegue até o diretório e você pode usar seus módulos. Vamos definir um ambiente e um agente.

vacuum_agent.py

from agents import Agent, Environment, Percept, TraceAgent, SimpleReflexAgent

class VacuumEnvironment(Environment):
 """O ambiente para o mundo do aspirador de pó."""
 def __init__(self, A='limpo', B='limpo'):
 super().__init__()
 self.status = {'A': A, 'B': B}
 self.percepts = {'A': None, 'B': None}
 self.location = 'A'

 def percept(self, agent):
 """Retorna a percepção do agente sobre o ambiente."""
 return (self.location, self.status[self.location])

 def execute_action(self, agent, action):
 """Executa a ação do agente no ambiente."""
 if action == 'Right':
 self.location = 'B'
 elif action == 'Left':
 self.location = 'A'
 elif action == 'Suck':
 if self.status[self.location] == 'sujo':
 self.status[self.location] = 'limpo'
 # print(f"Agente {agent.name} executou {action}. Ambiente: {self.status}, Localização: {self.location}")

 def default_location(self, agent):
 return 'A'

 def default_percept(self):
 return ('A', 'limpo') # Percepção padrão para o ambiente


def SimpleVacuumAgent():
 """Um agente reflexivo simples para o mundo do aspirador de pó."""
 return SimpleReflexAgent({
 (('A', 'sujo'), 'Suck'),
 (('B', 'sujo'), 'Suck'),
 (('A', 'limpo'), 'Right'),
 (('B', 'limpo'), 'Left')
 })


if __name__ == '__main__':
 # Cria um ambiente com sujeira
 env = VacuumEnvironment(A='sujo', B='sujo')

 # Cria o agente
 agent = SimpleVacuumAgent()

 # Adiciona o agente ao ambiente
 env.add_agent(agent)

 # Executa a simulação por alguns passos
 print("Ambiente Inicial:", env.status, "Localização:", env.location)
 env.run(steps=10)
 print("Ambiente Final:", env.status, "Localização:", env.location)

 # Outro cenário
 env2 = VacuumEnvironment(A='limpo', B='sujo')
 agent2 = SimpleVacuumAgent()
 env2.add_agent(agent2)
 print("\nAmbiente Inicial (2):", env2.status, "Localização:", env2.location)
 env2.run(steps=5)
 print("Ambiente Final (2):", env2.status, "Localização:", env2.location)

Este script define um VacuumEnvironment e um SimpleVacuumAgent usando a classe SimpleReflexAgent do framework Python da AIMA. As regras do agente ditam suas ações com base exclusivamente em sua percepção atual (localização e status de sujeira).

Pontos Fortes: Excelente para aprender os fundamentos de IA, implementações claras de algoritmos clássicos, leve.
Pontos Fracos: Não projetado para produção, recursos limitados em comparação com SDKs completos, principalmente para uso acadêmico.
Uso Ideal: Educação, pesquisa, protótipos de agentes de IA conceituais, compreensão de paradigmas de agentes.

SDK 3: Microsoft Bot Framework – Desenvolvimento de Bots de Nível Empresarial

Visão Geral

O Microsoft Bot Framework é uma plataforma completa para construir, conectar, implantar e gerenciar bots inteligentes em vários canais. Ele fornece ferramentas, SDKs e serviços que permitem aos desenvolvedores criar interfaces de conversação que podem entender linguagem natural, envolver-se em diálogos e integrar-se a sistemas de backend. É particularmente forte para aplicações empresariais e utiliza outros serviços do Microsoft Azure, como os Azure Cognitive Services (por exemplo, LUIS para NLU).

Recursos Principais

• Suporte Multi-Canal: Conecta-se a canais populares como Teams, Slack, Facebook Messenger, chat na web, etc.
• Bot Builder SDKs: Disponíveis para C#, JavaScript, Python e Java.
• Diálogos Adaptativos: Gestão avançada de diálogos para fluxos de conversa complexos.
• Compreensão de Linguagem (LUIS): Serviço de NLU da Microsoft para reconhecimento de intenção e entidade.
• QnA Maker: Serviço para criar rapidamente bots que podem responder a FAQs.
• Integração com Azure: integração suave com outros serviços do Azure para inteligência, armazenamento e computação.

Exemplo Prático: Um Bot Echo Simples (Python)

Vamos criar um bot echo básico usando o SDK do Microsoft Bot Framework para Python. Este bot simplesmente repete o que o usuário diz.

Primeiro, instale o SDK:

pip install botbuilder-core botbuilder-schema botbuilder-dialogs aiohttp

Crie um arquivo chamado app.py:

import asyncio
from datetime import datetime

from aiohttp import web
from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext
from botbuilder.schema import Activity, ActivityTypes

# O APP_ID e APP_PASSWORD do seu bot podem ser configurados aqui.
# Para testes locais, geralmente podem ser deixados vazios.
SETTINGS = BotFrameworkAdapterSettings(
 app_id="",
 app_password=""
)

# Crie um adaptador. O adaptador é responsável por lidar com os pedidos HTTP recebidos
# e criar um TurnContext para cada chamada.
adapter = BotFrameworkAdapter(SETTINGS)

async def on_error(context: TurnContext, error: Exception):
 """Callback para erros durante uma turn."""
 print(f"\n [on_error] erro não tratado: {error}")

 # Enviar uma mensagem para o usuário
 await context.send_activity("O bot encontrou um erro ou bug.")
 await context.send_activity("Para continuar executando este bot, por favor, conserte o código do bot.")

 # Enviar uma atividade de rastreamento
 trace_activity = Activity(
 label="TurnError",
 name="on_error Exception",
 timestamp=datetime.utcnow(),
 type=ActivityTypes.trace,
 value=f"Exceção: {error}",
 value_type="https://schema.org/Exception",
 )
 await context.send_activity(trace_activity)

adapter.on_turn_error = on_error

class MyBot:
 """Bot Echo Básico que repete o que o usuário diz."""
 async def on_turn(self, turn_context: TurnContext):
 if turn_context.activity.type == ActivityTypes.message:
 await turn_context.send_activity(f"Você disse: {turn_context.activity.text}")
 elif turn_context.activity.type == ActivityTypes.conversation_update:
 # Lidar com atualizações de conversa, por exemplo, quando um usuário entra na conversa
 if turn_context.activity.members_added:
 for member in turn_context.activity.members_added:
 if member.id != turn_context.activity.recipient.id:
 await turn_context.send_activity("Olá e bem-vindo!")
 else:
 await turn_context.send_activity(f"[{turn_context.activity.type} evento detectado]")


# Crie a instância do bot
BOT = MyBot()

async def messages(request):
 """Endpoint principal para mensagens de bot."""
 if "application/json" in request.headers["Content-Type"]:
 body = await request.json()
 else:
 return web.Response(status=415)

 activity = Activity().deserialize(body)
 auth_header = request.headers["Authorization"] if "Authorization" in request.headers else ""

 try:
 # Processar a atividade com a lógica do bot
 response = await adapter.process_activity(activity, auth_header, BOT.on_turn)
 if response:
 return web.json_response(data=response.body, status=response.status)
 return web.Response(status=200)
 except Exception as e:
 return web.Response(status=500, text=str(e))

app = web.Application()
app.router.add_post("/api/messages", messages)

if __name__ == "__main__":
 try:
 web.run_app(app, host="localhost", port=3978)
 except Exception as e:
 print(f"Erro ao iniciar o servidor: {e}")

Execute a aplicação:

python app.py

Para testar isso localmente, você precisará do Bot Framework Emulator. Baixe-o do site oficial do Microsoft Bot Framework. Depois de instalado, abra o emulador e conecte-se a http://localhost:3978/api/messages.

Pontos Fortes: Pronto para empresas, documentação extensa, suporte multi-canal, integração sólida com serviços Azure (NLU, Speech, QnA), gestão sólida de diálogos.
Pontos Fracos: Pode ser complexo para bots simples, vínculos fortes com o ecossistema Microsoft, pode gerar custos Azure.
Uso Ideal: Chatbots empresariais, bots de atendimento ao cliente, assistentes organizacionais internos, aplicações conversacionais complexas que exigem escalabilidade e integração com outros serviços da Microsoft.

SDK 4: LangChain – O Orquestrador para Agentes Potencializados por LLM

Visão Geral

LangChain é uma estrutura em rápida evolução projetada para simplificar a criação de aplicações potencializadas por grandes modelos de linguagem (LLMs). Embora não seja um SDK de Agente no sentido tradicional de agentes BDI (Crença-Desejo-Intenção), o LangChain fornece uma poderosa camada de abstração e um conjunto de ferramentas para construir agentes sofisticados impulsionados por LLM. Esses agentes podem raciocinar, usar ferramentas e interagir com várias fontes de dados, tornando-se um framework crucial para a nova geração de aplicações de IA.

Recursos Principais

• Cadeias: Combine LLMs com outros componentes (por exemplo, modelos de prompt, analisadores) para formar sequências de operações.
• Agentes: LLMs que podem raciocinar sobre quais ferramentas usar e em que ordem para alcançar um objetivo.
• Memória: Adicione estado a cadeias e agentes, permitindo que eles lembrem interações passadas.
• Ferramentas: Abstrações para recursos e APIs externas com os quais os agentes podem interagir (por exemplo, motores de busca, calculadoras, bancos de dados).
• Carregadores de Documentos & Embeddings: Ferramentas para ingerir e processar dados para geração aumentada por recuperação.

Exemplo Prático: Um Agente de Pesquisa Simples no Wikipedia

Vamos criar um agente LangChain que pode usar o Wikipedia para responder perguntas. Você precisará de uma chave de API da OpenAI para o LLM.

Primeiro, instale o LangChain e as dependências necessárias:

pip install langchain openai wikipedia

Defina sua chave de API da OpenAI como uma variável de ambiente (ou diretamente no código, embora a variável de ambiente seja recomendada).

export OPENAI_API_KEY='YOUR_OPENAI_API_KEY'

wikipedia_agent.py

import os

from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI

# Inicializa o LLM (por exemplo, o GPT-3.5-turbo da OpenAI)
llm = OpenAI(temperature=0)

# Carrega as ferramentas que o agente usará
# A ferramenta 'wikipedia' permite pesquisar na Wikipedia
# 'llm-math' é uma ferramenta simples de calculadora
tools = load_tools(["wikipedia", "llm-math"], llm=llm)

# Inicializa o agente com o LLM e as ferramentas
# AgentType.ZERO_SHOT_REACT_DESCRIPTION é um tipo de agente comum
# que usa o LLM para decidir qual ferramenta usar e qual entrada fornecer.
agent = initialize_agent(
 tools,
 llm,
 agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
 verbose=True # Defina como True para ver o raciocínio do agente
)

# Exemplos de perguntas para o agente
questions = [
 "Qual é a capital da França?",
 "Quantas pessoas vivem em Paris?",
 "Quem foi o 44º presidente dos Estados Unidos?",
 "Qual é 123 * 456?"
]

for q in questions:
 print(f"\n--- Pergunta: {q} ---")
 try:
 agent.run(q)
 except Exception as e:
 print(f"Ocorreu um erro: {e}")

Quando você executar este script, vai observar o ’processo de pensamento’ do agente se verbose=True. Ele analisará a pergunta, decidirá usar a ferramenta ‘wikipedia’, formulará uma consulta de pesquisa, executará a ferramenta e, em seguida, usará as informações recuperadas para responder à pergunta.

Pontos Fortes: Excelente para aplicações movidas por LLM, modular e flexível, rico ecossistema de integrações (ferramentas, carregadores de dados), comunidade em rápido desenvolvimento.
Pontos Fracos: Evolução rápida (APIs podem mudar), requer compreensão dos conceitos de LLM, pode ser intensivo em recursos (chamadas de API).
Caso de Uso Ideal: Construção de agentes inteligentes que usam LLMs para raciocínio, recuperação de informações, automação de tarefas complexas e interação com serviços externos.

Conclusão: Escolhendo a Ferramenta Certa para Sua Jornada Agente

Como vimos, o mundo dos SDKs de Agentes é diversificado, com cada framework oferecendo pontos fortes únicos e atendendo a diferentes casos de uso. Não há uma solução única; o melhor SDK para seu projeto depende fortemente de seus requisitos específicos, do tipo de agente que você imagina e do seu ecossistema de desenvolvimento.

• Rasa se destaca por uma sólida IA conversacional, proporcionando profundas capacidades de NLU e gerenciamento de diálogo para chatbots e assistentes virtuais.
• AIMA Python é uma ferramenta educacional e de pesquisa inestimável para entender conceitos fundamentais de agentes de IA, perfeita para prototipagem e exploração acadêmica.
• Microsoft Bot Framework oferece uma solução de nível empresarial para construir bots escaláveis e multicanal, especialmente quando integrado ao ecossistema mais amplo da Azure.
• LangChain está na vanguarda do desenvolvimento de agentes movidos por LLM, permitindo raciocínio complexo, uso de ferramentas e interação com diversas fontes de dados para criar sistemas altamente inteligentes e adaptativos.

Antes de se comprometer com um SDK, considere prototipar com algumas opções, avaliando sua curva de aprendizado, suporte da comunidade e quão bem elas se integram ao seu stack tecnológico existente. Os exemplos fornecidos neste tutorial devem servir como um ponto de partida prático para explorar essas ferramentas poderosas. Ao pesar cuidadosamente suas necessidades em relação às capacidades de cada SDK, você pode embarcar com confiança na construção de agentes inteligentes que transformam suas aplicações e experiências de usuário.

🕒 Published: March 31, 2026