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

Introdução aos SDKs de Agent

O espaço da inteligência artificial está evoluindo rapidamente, com um foco 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 desafiadora, exigindo habilidades em processamento de linguagem natural, aprendizado de máquina, representação do conhecimento e muito mais. É aqui que entram os SDKs de Agent (software development kits). Os SDKs de Agent fornecem aos desenvolvedores componentes predefinidos, frameworks e ferramentas para acelerar o desenvolvimento de agentes inteligentes, abstraindo grande parte da complexidade subjacente.

Um SDK de Agent oferece geralmente funcionalidades para definir os comportamentos dos agentes, gerenciar os fluxos de conversação, integrar-se com ferramentas e APIs externas, gerenciar a memória e o contexto, e inclui frequentemente funcionalidades para o deployment e o monitoramento. Escolher o SDK de Agent correto é 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 visa fornecer uma comparação prática de vários SDKs de Agent populares, ilustrando seus pontos fortes e fracos através de exemplos concretos.

Características Chave a Considerar em um SDK de Agent

• Suporte Linguístico: Suporta sua linguagem de programação preferida (Python, JavaScript, Java, etc.)?
• Facilidade de Uso e Curva de Aprendizado: Quão rapidamente um novo desenvolvedor pode se tornar produtivo com o SDK?
• Capacidade de Integração: Pode integrar-se facilmente com outros serviços, APIs, bancos de dados e sistemas existentes?
• Gerenciamento de Estado e Memória: Como gerencia o contexto da conversação e a memória de longo prazo do agente?
• Orquestração e Workflow: Fornece ferramentas para definir comportamentos complexos dos agentes, a tomada de decisões e os processos multi-fase?
• Escalabilidade e Performance: Pode lidar com um alto volume de interações e cálculos complexos?
• Opções de Deployment: Quais são os ambientes de deployment suportados (cloud, on-premise, serverless)?
• Comunidade e Documentação: Existe uma comunidade ativa e uma documentação completa para ajudar durante o desenvolvimento?
• Extensibilidade: Quão fácil é estender as funcionalidades do SDK com componentes personalizados?

Comparar os SDKs de Agent: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel

Para este tutorial, nos concentraremos em três SDKs de Agent proeminentes e amplamente utilizados: LangChain, LlamaIndex e Microsoft Semantic Kernel. Cada um deles propõe uma abordagem única para construir agentes inteligentes, particularmente aqueles que utilizam modelos de linguagem de grandes dimensões (LLM).

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

LangChain rapidamente se destacou como um framework dominante para desenvolver aplicações alimentadas por grandes modelos de linguagem. Sua filosofia central gira em torno da ‘cadeia’ de diferentes componentes para criar fluxos de trabalho complexos. Fornece um conjunto completo de abstrações para interagir com os LLM, gerenciar as solicitações, processar a memória conversacional, integrar-se com ferramentas externas (Agentes) e recuperar informações de várias fontes de dados (Retrieval).

Características Chave do LangChain:

• Cadeias: Definir sequências de chamadas, por exemplo, modelos de solicitação + LLM + analisador de saída.
• Agentes: Permitir que os LLM escolham uma sequência de ações a serem tomadas, muitas vezes utilizando ferramentas.
• Memória: Armazenar e recuperar informações sobre interações passadas.
• Carregadores: Carregar dados de várias fontes (PDF, sites, bancos de dados).
• Vectorstores: Armazenar e interrogar embeddings para pesquisa semântica.
• Ferramentas: Funcionalidades externas que um agente pode usar (por exemplo, mecanismos 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 de matemática."
)

tools = [calculator]

# 3. Obter a solicitação do LangChain Hub (estilo ReAct)
# A solicitação 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:

• Iniciamos um modelo de Chat OpenAI.
• Definimos uma ferramenta Calculator utilizando o LLMMathChain do LangChain.
• Buscamos uma solicitação padrão ReAct do LangChain Hub. ReAct (Raciocínio e Ação) é um paradigma que permite que os LLM realizem raciocínios dinâmicos e planejem ações.
• create_react_agent combina o LLM, as ferramentas e a solicitação para criar um agente.
• AgentExecutor é responsável pela execução do agente, gerenciando seu processo de reflexão e executando as ferramentas.
• Quando é questionado sobre a capital da França, o LLM responde diretamente. Quando uma pergunta matemática é feita, 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 foca fortemente na orquestração e na cadeia 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 LLM com fontes de dados personalizadas, permitindo aplicações RAG (Recupero-Aumentado por Geração) poderosas. O LlamaIndex se destaca na construção de bases de conhecimento e na sua consulta pelos LLM.

Características Principais do LlamaIndex:

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

Exemplo Prático de LlamaIndex: Consultar um Documento Personalizado

Vamos criar uma aplicação simples do LlamaIndex 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 férias pagas por ano.
# Após 5 anos de serviço, os funcionários recebem mais 5 dias.
# Os dias de férias não utilizados não acumulam 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

# Defina a chave API OpenAI (certifique-se de que ela esteja em suas variáveis de ambiente)
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# 1. Configure o LLM e o modelo de incorporação (opcional, mas uma boa prática)
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")

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

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

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

# 5. Interrogue o motor
response = query_engine.query("Quantos dias de férias os funcionários recebem a cada 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 incorporação através de Settings.
• SimpleDirectoryReader carrega o arquivo de texto.
• VectorStoreIndex.from_documents processa os documentos, os divide em partes, os incorpora e os armazena em um banco de dados vetorial (em memória por padrão).
• index.as_query_engine() cria uma interface para interrogar o índice.
• Quando uma consulta é feita, o motor de solicitações recupera partes de documentos relevantes com base na similaridade semântica e depois 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 open-source que permite aos desenvolvedores integrar grandes modelos de linguagem (LLMs) e outras capacidades de IA em suas aplicações utilizando linguagens de programação existentes (C#, Python, Java). Foca em habilitar as aplicações a orquestrar interações com LLMs e código tradicional, enfatizando uma arquitetura de ‘plugin’. SK é particularmente adequado para desenvolvedores que já estão dentro do ecossistema Microsoft ou para aqueles que buscam uma estrutura sólida a nível enterprise.

Características-Chave do Semantic Kernel:

• Kernel: O motor central de orquestração para IA e código tradicional.
• Competências/Plugins: Coleções de funções semânticas (prompt LLM) e de 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 interagir 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 competências 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ântico que pode cumprimentar o usuário e realizar uma operação aritmética simples utilizando 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 esteja definida como variável de ambiente
kernel.add_service(
 OpenAIChatCompletion(
 service_id="chat_completion",
 ai_model_id="gpt-4o",
 ),
)

# 3. Definir um plugin nativo personalizado (Competências em 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)
# É um prompt simples que pode ser invocado diretamente ou utilizado 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. Invocamos diretamente a função de chat
 result = await kernel.invoke(chat_function, sk.KernelArguments(input="Oi, o que você pode fazer por mim?"))
 print(f"Resposta do chat: {result}")

 # 7. Utilizar um planejador para orquestrar ações, incluindo nosso MathPlugin
 # Para um planejamento complexo, um planejador dedicado como SequentialPlanner seria utilizado
 # Neste exemplo simples, demonstraremos uma invocação direta através de um prompt com capacidade de chamada de função
 
 # O LLM, quando invocado com o prompt correto, reconhecerá e utilizará os plugins registrados.
 # Vamos criar um objetivo para o LLM alcançar utilizando os plugins disponíveis.
 
goal = "Preciso saber a soma de 10 e 20, depois multiplicar esse resultado por 3."

 # O mecanismo de chamada de função de SK permite ao LLM escolher a função correta.
 # Usaremos diretamente um serviço de completamento de chat, permitindo que utilize 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 completamento de chat OpenAI.
• Definimos uma classe MathPlugin com decoradores @kernel_function, expondo add e multiply como funções nativas.
• Importamos este plugin no kernel.
• Uma função semântica simples chat_function é criada para uma interação direta com o LLM.
• No main(), invocamos primeiro a função de chat diretamente.
• Depois, para o exemplo de planejamento, criamos um histórico de chat com um objetivo. Usando function_call="auto" nos parâmetros, o LLM pode decidir se responde diretamente ou invoca 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, em seguida, retorna o resultado ao LLM.

Escolhendo o Agente SDK Certo

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

• Escolha LangChain se:
  • Você precisa de uma orquestração LLM extensa, um comportamento agencial complexo, e uma cadeia flexível de componentes.
  • Quer integrar uma ampla gama de LLMs, ferramentas e tipos de memória.
  • Está construindo aplicações que envolvem raciocínios multi-etapas, uma seleção dinâmica de ferramentas, e agentes conversacionais.
  • Aprecia uma grande comunidade ativa e numerosos exemplos.
• Escolha LlamaIndex se:
  • Seu principal objetivo é conectar os LLMs aos seus dados personalizados (documentos, bancos de dados, API) para RAG.
  • Você precisa de sólidas capacidades de ingestão de dados, indexação e recuperação.
  • Está construindo sistemas de perguntas/respostas de base de conhecimento, resumos de documentos, ou agentes sensíveis a dados.
  • Prioriza uma gestão de dados eficaz e escalável para os LLMs.

  “`html

• Escolha Microsoft Semantic Kernel se:
  • Você é um desenvolvedor C#, Python ou Java que deseja integrar a IA de forma harmoniosa em aplicações existentes.
  • Você quer um framework sólido e pronto para enterprise da Microsoft.
  • Você precisa combinar as capacidades dos LLM (funções semânticas) com o código tradicional (funções nativas/plugin) de forma estruturada.
  • Você está construindo aplicações que necessitam que a IA interaja com seus sistemas internos e APIs.

Conclusão

Os SDKs 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 adequadas a diferentes aspectos do desenvolvimento da IA. LangChain se destaca na orquestração de fluxos de trabalho LLM complexos e no raciocínio agencial. LlamaIndex é a escolha ideal para integração e geração aumentada pelo recuperação de dados. Semantic Kernel fornece uma base sólida para integrar a IA em aplicações existentes com uma arquitetura de plugin robusta, em particular para casos de uso empresariais. Compreendendo suas forças fundamentais e observando-os em ação através de exemplos práticos, agora você está melhor equipado para selecionar o SDK certo para dar vida às suas ideias de agentes inteligentes.

“`

🕒 Published: April 5, 2026