Tutorial de comparação do Agent SDK: Construindo aplicativos inteligentes com exemplos práticos

Introdução aos SDKs de Agente

O espaço da inteligência artificial está evoluindo rapidamente, com um foco crescente em agentes inteligentes capazes de realizar tarefas complexas, interagir com os usuários e se adaptar a ambientes dinâmicos. Construir tais agentes desde o início pode ser uma tarefa desafiadora, exigindo especialização em processamento de linguagem natural, aprendizado de máquina, representação do conhecimento, e muito mais. É aqui que entram os SDKs de Agente. Os SDKs de Agente fornecem aos desenvolvedores componentes pré-definidos, frameworks e ferramentas para acelerar o desenvolvimento de agentes inteligentes, abstraindo grande parte da complexidade subjacente.

Um SDK de Agente geralmente oferece funcionalidades para definir os comportamentos dos agentes, gerenciar fluxos de conversação, integrar-se a ferramentas e APIs externas, gerenciar a memória e o contexto, e frequentemente inclui recursos para implantação e monitoramento. Escolher o SDK de Agente certo é crucial para o sucesso do seu projeto, pois diferentes SDKs atendem a vários casos de uso, linguagens de programação e níveis de abstração. Este tutorial tem como objetivo fornecer uma comparação prática de vários SDKs de Agente populares, ilustrando seus pontos fortes e fracos por meio de exemplos concretos.

Características Chave a Considerar em um SDK de Agente

• Suporte Linguístico: Ele suporta sua linguagem de programação preferida (Python, JavaScript, Java, etc.)?
• Facilidade de Uso e Curva de Aprendizado: Quão rápido 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 gerencia o contexto da conversação e a memória de longo prazo do agente?
• Orquestração e Fluxo de Trabalho: Ele fornece ferramentas para definir comportamentos complexos dos agentes, tomada de decisão e processos em múltiplas etapas?
• Escalabilidade e Performance: Ele pode lidar com um alto 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 abrangente para ajudar durante o desenvolvimento?
• Extensibilidade: Qual é a facilidade de extensão das funcionalidades do SDK com componentes personalizados?

Comparando os SDKs de Agente: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

Para este tutorial, vamos nos concentrar em três SDKs de Agente proeminentes e amplamente utilizados: LangChain, LlamaIndex e Microsoft Semantic Kernel. Cada um deles oferece uma abordagem única para construir agentes inteligentes, especialmente aqueles que utilizam modelos de linguagem de grande porte (LLMs).

1. LangChain: O Orquestrador para Aplicações Alimentadas por LLM

LangChain rapidamente eclodiu como um framework dominante para desenvolver aplicações alimentadas por grandes modelos de linguagem. Sua filosofia central gira em torno do ‘encadeamento’ de diferentes componentes para criar fluxos de trabalho complexos. Ele oferece um conjunto abrangente de abstrações para interagir com os LLMs, gerenciar prompts, processar a memória conversacional, integrar-se a ferramentas externas (Agentes) e recuperar informações de várias fontes de dados (Recuperação).

Características Chave do LangChain:

• Chain: Definir sequências de chamadas, por exemplo, modelo de prompt + LLM + analisador de saída.
• Agentes: Permitir que os LLMs escolham uma sequência de ações a serem realizadas, geralmente utilizando ferramentas.
• Memória: Armazenar e recuperar informações sobre interações passadas.
• Carregadores: Carregar dados de diversas fontes (PDF, sites, bancos de dados).
• Vectorstores: Armazenar e consultar embeddings para busca semântica.
• Ferramentas: Funcionalidades externas que um agente pode utilizar (por exemplo, motores de busca, calculadoras, APIs personalizadas).

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

Vamos criar um agente LangChain capaz de responder a perguntas gerais e utilizar uma ferramenta de cálculo, 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 as Ferramentas
# Ferramenta de cálculo
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 a 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 OpenAI.
• Definimos uma ferramenta Calculator usando o LLMMathChain do LangChain.
• Buscamos 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 pela execução do agente, gerenciamento de seu processo de reflexão e execução das ferramentas.
• Quando perguntamos pela capital da França, o LLM responde diretamente. Quando fazemos uma pergunta matemática, ele reconhece a necessidade da calculadora, chama a ferramenta e fornece o resultado.

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

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

Características Chave do LlamaIndex:

• Conectores de Dados: Ingestão de dados a partir de diversas fontes (documentos, bancos de dados, APIs).
• Indexação de Dados: Estruturar e armazenar os dados de uma forma otimizada para consultas LLM (por exemplo, lojas de vetores, gráficos de conhecimento).
• Motores de Consulta: Recuperar informações relevantes a partir dos índices e sintetizar respostas usando LLMs.
• Agentes: Combinar motores de consulta com ferramentas e LLMs para um raciocínio mais complexo sobre os dados.
• Contexto de Serviço: Gerenciar o LLM, o modelo de embedding e outras configurações de serviço.

Exemplo Prático do LlamaIndex: Consultar um Documento Personalizado

Vamos criar uma aplicação LlamaIndex simples capaz de responder a perguntas baseadas em um arquivo de texto local.

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

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

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

# 1. Configurar o LLM e o Modelo de Embedding (opcional, mas é uma 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' está no 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 folga os funcionários recebem por ano?")
print(response)

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

Explicação:

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

3. Microsoft Semantic Kernel: O Orquestrador para Aplicações Alimentadas por IA com Plugins

Microsoft Semantic Kernel (SK) é um SDK de código aberto que permite aos desenvolvedores integrar 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 habilitar aplicações a orquestrar interações com LLMs e código tradicional, com ênfase em uma arquitetura de ‘plugin’. SK é particularmente adequado para desenvolvedores já no ecossistema Microsoft ou aqueles em busca de uma estrutura sólida, de nível empresarial.

Características Chave do Semantic Kernel:

• Kernel: O motor central de orquestração para IA e código tradicional.
• Habilidades/Plugins: Coleções de funções semânticas (prompts LLM) e funções nativas (código tradicional) que a IA pode invocar.
• Funções Semânticas: Prompts que definem o que o LLM deve fazer.
• Funções Nativas: Métodos de código tradicional expostos à IA, permitindo que interaja com sistemas externos.
• Memória: Armazenar e recuperar informações para o contexto conversacional.
• Planejadores: Permitem que a IA planeje e execute uma sequência de habilidades para alcançar um objetivo.

Exemplo Prático de Kernel Semântico: Um Planejador Simples com um Plugin Personalizado

Vamos criar uma aplicação Kernel Semântica que pode cumprimentar o usuário e realizar uma simples operação aritmética 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. Inicializar o Kernel
kernel = sk.Kernel()

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

# 3. Definir um plugin nativo personalizado (Habilidades no SK)
class MathPlugin:
 @kernel_function(description="Adiciona 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. Importar o plugin no kernel
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")

# 5. Definir uma função semântica (para a 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. Invocar 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. Usar um planejador para orquestrar ações, incluindo nosso MathPlugin
 # Para um planejamento complexo, você usaria um planejador dedicado como SequentialPlanner
 # Para este exemplo simples, vamos demonstrar uma chamada direta via um 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 o LLM alcançar usando os 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 correta.
 # Vamos usar um serviço de completude 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:

• Nós inicializamos o Kernel e adicionamos um serviço de completude de chat OpenAI.
• Nós definimos uma classe MathPlugin com decoradores @kernel_function, expondo add e multiply como funções nativas.
• Nós importamos este plugin no kernel.
• Uma função semântica simples chat_function é criada para uma interação direta com o LLM.
• Na main(), primeiro invocamos a função de chat diretamente.
• Em seguida, para o exemplo de planejamento, criamos um histórico de chat com um objetivo. Usando function_call="auto" nos parâmetros, o LLM é capaz de decidir se deve responder diretamente ou chamar uma das funções nativas registradas (plugins) para alcançar o objetivo. SK gerencia a tradução da chamada de função do LLM em invocações de métodos reais e então retorna o resultado ao LLM.

Escolhendo o SDK Agent Certo

A escolha do SDK Agent depende fortemente das necessidades específicas do seu projeto e da sua pilha tecnológica existente:

• Escolha o LangChain se:
  • Você precisa de uma orquestração LLM extensiva, comportamento agente complexo, e uma cadeia flexível de componentes.
  • Você deseja integrar uma ampla 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 grande comunidade ativa e muitos exemplos.
• Escolha o LlamaIndex se:
  • Seu principal objetivo é conectar os LLMs aos seus dados personalizados (documentos, bancos de dados, APIs) para RAG.
  • Você precisa de fortes capacidades de ingestão de dados, indexação e recuperação.
  • Você está construindo sistemas de perguntas/respostas de base de conhecimento, resumos de documentos, ou agentes sensíveis a dados.
  • Você prioriza uma gestão de dados eficiente e escalável para os LLMs.
• Escolha o Microsoft Semantic Kernel se:
  • Você é um desenvolvedor C#, Python, ou Java buscando integrar a IA de maneira harmoniosa em aplicações existentes.
  • Você quer uma estrutura sólida e pronta para empresa da Microsoft.
  • Você precisa combinar as capacidades dos 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 SDK para agentes são ferramentas indispensáveis para construir aplicações de IA sofisticadas. LangChain, LlamaIndex e Microsoft Semantic Kernel oferecem cada um funcionalidades poderosas adaptadas a diferentes aspectos do desenvolvimento de IA. LangChain se destaca na orquestração de fluxos de trabalho LLM complexos e no raciocínio agente. LlamaIndex é a escolha ideal para a integração e geração aumentada pela recuperação de dados. Semantic Kernel fornece uma base sólida para integrar a IA em aplicações existentes com uma arquitetura de plugins forte, especialmente para casos de uso em empresas. Ao compreender suas forças fundamentais e vê-los em ação por meio de exemplos práticos, você está agora melhor preparado para selecionar o SDK adequado para dar vida às suas ideias de agentes inteligentes.

🕒 Published: March 31, 2026