Tutorial de Comparação de Agent SDK: Construindo Aplicações Inteligentes com Exemplos Práticos

Introdução aos SDKs de Agentes

O campo da inteligência artificial está evoluindo rapidamente, com uma ênfase crescente em agentes inteligentes capazes de realizar tarefas complexas, interagir com usuários e se adaptar a ambientes dinâmicos. Construir tais agentes do zero pode ser uma tarefa árdua, exigindo expertise em processamento de linguagem natural, aprendizado de máquina, representação do conhecimento, entre outros. É aí que os SDKs de Agentes (Kits de Desenvolvimento de Software) entram em cena. Os SDKs de Agentes fornecem aos desenvolvedores componentes, estruturas e ferramentas pré-construídas para acelerar o desenvolvimento de agentes inteligentes, abstraindo grande parte da complexidade subjacente.

Um SDK de Agente normalmente oferece funcionalidades para definir comportamentos de agentes, gerenciar fluxos conversacionais, integrar com ferramentas e APIs externas, lidar com memória e contexto, e muitas vezes inclui recursos para implantação e monitoramento. Escolher o SDK de Agente certo é crucial para o sucesso do seu projeto, uma vez que diferentes SDKs atendem a vários casos de uso, linguagens de programação e níveis de abstração. Este tutorial tem o objetivo de fornecer uma comparação prática de vários SDKs de Agentes populares, ilustrando suas forças e fraquezas através de exemplos concretos.

Características Principais a Considerar em um SDK de Agente

• Suporte a Linguagens: Ele suporta a sua linguagem de programação preferida (Python, JavaScript, Java, etc.)?
• Facilidade de Uso e Curva de Aprendizado: Com que rapidez um novo desenvolvedor pode se tornar produtivo com o SDK?
• Capacidades de Integração: Ele pode se integrar facilmente com outros serviços, APIs, bancos de dados e sistemas existentes?
• Gerenciamento de Estado e Memória: Como ele lida com o contexto conversacional e a memória de longo prazo para o agente?
• Orquestração e Fluxo de Trabalho: Ele fornece ferramentas para definir comportamentos complexos de agentes, tomada de decisão e processos em múltiplas etapas?
• Escalabilidade e Desempenho: Ele pode lidar com um grande volume de interações e cálculos complexos?
• Opções de Implantação: Quais são os ambientes de implantação suportados (nuvem, local, sem servidor)?
• Comunidade e Documentação: Existe uma comunidade ativa e uma documentação completa para auxiliar durante o desenvolvimento?
• Extensibilidade: Quão fácil é estender as funcionalidades do SDK com componentes personalizados?

Comparando SDKs de Agentes: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

Para este tutorial, nos concentraremos em três SDKs de Agentes proeminentes e amplamente utilizados: LangChain, LlamaIndex e Microsoft Semantic Kernel. Cada um deles oferece uma abordagem única para a construção de agentes inteligentes, especialmente aqueles que usam grandes modelos de linguagem (LLMs).

1. LangChain: O Orquestrador para Aplicações com Poder de LLM

LangChain emergiu rapidamente como uma estrutura dominante para o desenvolvimento de aplicações impulsionadas por grandes modelos de linguagem. Sua filosofia central gira em torno de ‘encadear’ diferentes componentes para criar fluxos de trabalho complexos. Ele fornece um conjunto completo de abstrações para interagir com LLMs, gerenciar prompts, lidar com memória conversacional, integrar com ferramentas externas (Agentes) e recuperar informações de várias fontes de dados (Recuperação).

Características Principais do LangChain:

• Cadeias: Defina sequências de chamadas, por exemplo, templates de prompt + LLM + analisador de saída.
• Agentes: Permitem que os LLMs escolham uma sequência de ações a serem tomadas, frequentemente usando ferramentas.
• Memória: Armazene e recupere informações sobre interações passadas.
• Carregadores: Carregue dados de várias fontes (PDFs, sites, bancos de dados).
• Armazenamento em Vetores: Armazene e consulte embeddings para busca semântica.
• Ferramentas: Funcionalidades externas que um agente pode usar (por exemplo, motores de busca, calculadoras, APIs personalizadas).

Exemplo Prático do LangChain: Um Agente Conversacional Simples com Uso de Ferramenta

Vamos construir um agente LangChain que pode responder a perguntas gerais e também usar uma ferramenta de calculadora se uma operação matemática for detectada.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_core.tools import Tool
from langchain.chains import LLMMathChain

# 1. Inicializar o LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")

# 2. Definir Ferramentas
# Ferramenta calculadora
llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
calculator = Tool(
 name="Calculator",
 func=llm_math_chain.run,
 description="Útil quando você precisa responder perguntas sobre matemática."
)

tools = [calculator]

# 3. Obter o prompt do LangChain Hub (estilo ReAct)
# O prompt ReAct orienta o LLM a pensar, observar e agir.
prompt = hub.pull("hwchase17/react")

# 4. Criar o agente ReAct
agent = create_react_agent(llm, tools, prompt)

# 5. Criar o Executor do Agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 6. Executar o agente
print(agent_executor.invoke({"input": "Qual é a capital da França?"}))
print(agent_executor.invoke({"input": "Qual é 1234 * 5678?"}))

Explicação:

• Inicializamos um modelo de Chat da OpenAI.
• Definimos uma ferramenta Calculator usando o LLMMathChain do LangChain.
• Puxamos um prompt padrão ReAct do LangChain Hub. ReAct (Raciocínio e Ação) é um paradigma que permite que os LLMs realizem raciocínio dinâmico e planejamento de ações.
• create_react_agent combina o LLM, as ferramentas e o prompt para criar um agente.
• AgentExecutor é responsável por executar o agente, gerenciar seu processo de pensamento e executar ferramentas.
• Quando questionado sobre a capital da França, o LLM responde diretamente. Quando é feita uma pergunta matemática, ele reconhece a necessidade da calculadora, chama a ferramenta e fornece o resultado.

2. LlamaIndex: Estrutura de Dados para Aplicações com LLM

Enquanto o LangChain foca fortemente na orquestração e encadeamento de chamadas de LLM, o LlamaIndex (anteriormente GPT Index) se especializa na ingestão de dados, indexação e recuperação para aplicações com LLM. Seu objetivo principal é facilitar a conexão entre LLMs e fontes de dados personalizadas, permitindo aplicações poderosas de RAG (Geração Aumentada por Recuperação). O LlamaIndex se destaca na construção de bases de conhecimento e na sua consulta por LLMs.

Características Principais do LlamaIndex:

• Conectores de Dados: Ingerir dados de várias fontes (documentos, bancos de dados, APIs).
• Indexação de Dados: Estruturar e armazenar dados de uma maneira otimizada para consultas de LLM (por exemplo, bancos de dados vetoriais, gráficos de conhecimento).
• Motores de Consulta: Recuperar informações relevantes de índices e sintetizar respostas usando LLMs.
• Agentes: Combinar motores de consulta com ferramentas e LLMs para raciocínios mais complexos e em múltiplas etapas sobre dados.
• Contexto de Serviço: Gerenciar LLM, modelo de embedding e outras configurações de serviço.

Exemplo Prático do LlamaIndex: Consultando um Documento Personalizado

Vamos criar uma aplicação simples do LlamaIndex que pode responder perguntas com base em um arquivo de texto local.

# Primeiro, crie um arquivo dummy: 'policy.txt'
# Conteúdo:
# "A política de férias da nossa empresa concede aos funcionários 15 dias de folga paga por ano. 
# Após 5 anos de serviço, os funcionários recebem 5 dias adicionais. 
# Os dias de férias não utilizados não são transferidos para o próximo ano."

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
import os

# Defina a chave da API da OpenAI (certifique-se de que está nas suas variáveis de ambiente)
# os.environ["OPENAI_API_KEY"] = "SUA_CHAVE_DE_API"

# 1. Configurar LLM e Modelo de Embedding (opcional, mas boa prática)
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# 2. Carregar documentos de um diretório
documents = SimpleDirectoryReader("data").load_data() # Supondo que 'policy.txt' esteja em um diretório 'data'

# 3. Criar um índice a partir dos documentos (VectorStoreIndex é comum)
index = VectorStoreIndex.from_documents(documents)

# 4. Criar um motor de consulta
query_engine = index.as_query_engine()

# 5. Consultar o motor
response = query_engine.query("Quantos dias de férias os funcionários recebem por ano?")
print(response)

response = query_engine.query("O que acontece com os dias de férias não utilizados?")
print(response)

Explicação:

• Primeiro, criamos um arquivo policy.txt em um diretório data.
• Configuramos o LLM e o modelo de embedding através de Settings.
• SimpleDirectoryReader carrega o arquivo de texto.
• VectorStoreIndex.from_documents processa os documentos, os divide em partes, os embeda e os armazena em um banco de dados vetorial (em memória, por padrão).
• index.as_query_engine() cria uma interface para consultar o índice.
• Quando uma consulta é feita, o motor de consulta recupera partes de documentos relevantes com base na similaridade semântica e, em seguida, usa o LLM para sintetizar uma resposta a partir dessas partes.

3. Microsoft Semantic Kernel: O Orquestrador para Aplicativos com IA com Plugins

O Microsoft Semantic Kernel (SK) é um SDK de código aberto que permite que desenvolvedores integrem grandes modelos de linguagem (LLMs) e outras capacidades de IA em suas aplicações usando linguagens de programação existentes (C#, Python, Java). Ele se concentra em permitir que aplicações orquestrem interações com LLMs e código tradicional, enfatizando uma arquitetura de ‘plugin’. O SK é particularmente forte para desenvolvedores já no ecossistema Microsoft ou aqueles que buscam uma estrutura sólida e de nível empresarial.

Características Principais do Semantic Kernel:

• Kernel: O motor central de orquestração para IA e código tradicional.
• Skills/Plugins: Coleções de funções semânticas (prompt de LLM) e funções nativas (código tradicional) que a IA pode invocar.
• Semantic Functions: Prompts que definem o que o LLM deve fazer.
• Native Functions: Métodos de código tradicional expostos à IA, permitindo que ela interaja com sistemas externos.
• Memory: Armazenar e recuperar informações para o contexto da conversa.
• Planners: Permitem que a IA planeje e execute uma sequência de habilidades para alcançar um objetivo.

Exemplo Prático de Semantic Kernel: Um Planejador Simples com Plugin Personalizado

Vamos criar uma aplicação Semantic Kernel que possa cumprimentar o usuário e também realizar uma operação aritmética simples usando uma função nativa personalizada (plugin).

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
import asyncio

# 1. Inicializa o Kernel
kernel = sk.Kernel()

# 2. Configura o serviço LLM
# Certifique-se de que sua OPENAI_API_KEY esteja definida como uma variável de ambiente
kernel.add_service(
 OpenAIChatCompletion(
 service_id="chat_completion",
 ai_model_id="gpt-4o",
 ),
)

# 3. Define um plugin nativo personalizado (Skills em SK)
class MathPlugin:
 @kernel_function(description="Soma dois números.", name="Add")
 def add(self, num1: float, num2: float) -> float:
 return num1 + num2

 @kernel_function(description="Multiplica dois números.", name="Multiply")
 def multiply(self, num1: float, num2: float) -> float:
 return num1 * num2

# 4. Importa o plugin para o kernel
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Define uma função semântica (para conversa geral)
# Este é um prompt simples que pode ser invocado diretamente ou usado por um planejador
prompt_template = "{{$input}}"
chat_function = kernel.create_function_from_prompt(
 prompt_template=prompt_template,
 plugin_name="ChatPlugin",
 function_name="Chat"
)

async def main():
 # 6. Invoca a função de chat diretamente
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Olá, o que você pode fazer por mim?"))
 print(f"Resposta do chat: {result}")

 # 7. Usa um planejador para orquestrar ações, incluindo nosso MathPlugin
 # Para planejamento complexo, você usaria um planejador dedicado como SequentialPlanner
 # Para este exemplo simples, demonstraremos uma chamada direta via prompt com capacidades de chamada de função
 
 # O LLM, quando invocado com o prompt correto, reconhecerá e usará os plugins registrados.
 # Vamos criar um objetivo para que o LLM o alcance usando plugins disponíveis.
 
goal = "Preciso saber a soma de 10 e 20, e depois multiplicar esse resultado por 3."

 # O mecanismo de chamada de função do SK permite que o LLM escolha a função certa.
 # Vamos usar um serviço de conclusão de chat diretamente, permitindo que ele use ferramentas.
 history = kernel.create_chat_history()
 history.add_user_message(goal)

 response = await kernel.get_service("chat_completion").get_chat_message_content(
 history=history,
 settings=sk.OpenAIChatCompletionSettings(function_call="auto")
 )
 print(f"Resposta do planejador: {response}")

if __name__ == "__main__":
 asyncio.run(main())

Explicação:

• Inicializamos o Kernel e adicionamos um serviço de conclusão de chat da OpenAI.
• Definimos uma classe MathPlugin com decoradores @kernel_function, expondo add e multiply como funções nativas.
• Importamos esse plugin para o kernel.
• Uma função semântica simples chat_function é criada para interação direta com o LLM.
• No main(), primeiro invocamos a função de chat diretamente.
• Então, para o exemplo de planejamento, criamos um histórico de chat com um objetivo. Ao usar function_call="auto" nas configurações, o LLM é habilitado a decidir se responde diretamente ou se chama uma das funções nativas registradas (plugins) para alcançar o objetivo. O SK trata da tradução da chamada de função do LLM em invocações de método reais e depois alimenta o resultado de volta ao LLM.

Escolhendo o SDK de Agente Certo

A escolha do SDK de Agente depende fortemente das necessidades específicas do seu projeto e da sua pilha de tecnologia existente:

• Escolha LangChain se:
  • Você precisa de uma orquestração extensa de LLM, comportamento agente complexo e encadeamento flexível de componentes.
  • Você quer integrar uma grande variedade de LLMs, ferramentas e tipos de memória.
  • Você está construindo aplicações que envolvem raciocínio em várias etapas, seleção dinâmica de ferramentas e agentes conversacionais.
  • Você valoriza uma comunidade grande e ativa e exemplos extensos.
• Escolha LlamaIndex se:
  • Seu foco principal é conectar LLMs aos seus dados personalizados (documentos, bancos de dados, APIs) para RAG.
  • Você precisa de capacidades sólidas de ingestão de dados, indexação e recuperação.
  • Você está construindo sistemas de perguntas e respostas baseados em conhecimento, resumidores de documentos ou agentes conscientes de dados.
  • Você prioriza gerenciamento de dados eficiente e escalável para LLMs.
• Escolha Microsoft Semantic Kernel se:
  • Você é um desenvolvedor C#, Python ou Java que deseja integrar a IA perfeitamente em aplicações existentes.
  • Você quer um framework sólido e pronto para enterprise da Microsoft.
  • Você precisa combinar capacidades de LLM (funções semânticas) com código tradicional (funções nativas/plugins) de maneira estruturada.
  • Você está construindo aplicações que requerem que a IA interaja com seus sistemas internos e APIs.

Conclusão

Os SDKs de Agente são ferramentas indispensáveis para construir aplicações de IA sofisticadas. LangChain, LlamaIndex e Microsoft Semantic Kernel oferecem recursos poderosos adaptados a diferentes aspectos do desenvolvimento de IA. LangChain se destaca na orquestração de fluxos de trabalho complexos de LLM e raciocínio agente. LlamaIndex é a escolha ideal para integração de dados e geração aumentada por recuperação. O Semantic Kernel fornece uma base sólida para integrar IA em aplicações existentes com uma arquitetura de plugin robusta, especialmente para casos de uso empresarial. Ao entender suas principais forças e vê-los em ação através de exemplos práticos, você está agora melhor preparado para selecionar o SDK certo para trazer suas ideias de agentes inteligentes à vida.

🕒 Published: March 31, 2026