“`html
Introdução ao Agent SDK
O campo da inteligência artificial está em rápida evolução, 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 árdua, que requer habilidades em processamento de linguagem natural, aprendizado de máquina, representação do conhecimento e muito mais. É aqui que entram os Agent SDK (Software Development Kits). Os Agent SDK fornecem aos desenvolvedores componentes, frameworks e ferramentas pré-definidos para acelerar o desenvolvimento de agentes inteligentes, abstraindo grande parte da complexidade subjacente.
Um Agent SDK normalmente oferece funcionalidades para definir comportamentos dos agentes, gerenciar fluxos conversacionais, integrar-se a ferramentas e APIs externas, gerenciar memória e contexto, e muitas vezes inclui características para o deployment e monitoramento. Escolher o Agent SDK certo é crucial para o sucesso do seu projeto, já que diferentes SDK 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 diferentes Agent SDK populares, ilustrando seus pontos fortes e fracos por meio de exemplos concretos.
Características Chave a Considerar em um Agent SDK
- 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 se integrar facilmente com outros serviços, APIs, bancos de dados e sistemas existentes?
- Gerenciamento de Estado e Memória: Como gerencia o contexto conversacional e a memória de longo prazo para o agente?
- Orquestração e Fluxo de Trabalho: Fornece ferramentas para definir comportamentos complexos dos agentes, tomada de decisão e processos em várias etapas?
- Escalabilidade e Desempenho: 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 documentação detalhada para ajudar durante o desenvolvimento?
- Extensibilidade: Quão fácil é estender as funcionalidades do SDK com componentes personalizados?
Comparação entre Agent SDK: LangChain vs. LlamaIndex vs. Microsoft Semantic Kernel
Para este tutorial, nos concentraremos em três agent SDK 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 utilizam modelos de linguagem de grande escala (LLM).
1. LangChain: O Orquestrador para Aplicações Alimentadas por LLM
LangChain rapidamente se destacou como um framework dominante para o desenvolvimento de aplicações alimentadas por modelos de linguagem de grande escala. Sua filosofia principal gira em torno de ‘conectar’ diferentes componentes para criar fluxos de trabalho complexos. Fornece um conjunto completo de abstrações para interagir com LLM, gerenciar prompts, tratar da memória conversacional, integrar-se com ferramentas externas (Agentes) e recuperar informações de várias fontes de dados (Recupero).
Características Chave do LangChain:
- Cadeias: Definir sequências de chamadas, por exemplo, modelos de prompt + LLM + analisador de output.
- 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.
- Loader: Carregar dados de diferentes fontes (PDF, sites, bancos de dados).
- Vectorstore: 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 de LangChain: Um Simples Agente Conversacional com Uso de Ferramentas
Construímos um agente LangChain capaz de responder a perguntas gerais e de usar uma calculadora se for detectada uma operação matemática.
“““html
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. Inicializa o LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Define 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 a perguntas de matemática."
)
tools = [calculator]
# 3. Obtém o prompt do LangChain Hub (estilo ReAct)
# O prompt ReAct guia o LLM a pensar, observar e agir.
prompt = hub.pull("hwchase17/react")
# 4. Cria o agente ReAct
agent = create_react_agent(llm, tools, prompt)
# 5. Cria o Executor do Agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)
# 6. Executa o agente
print(agent_executor.invoke({"input": "Qual é a capital da França?"}))
print(agent_executor.invoke({"input": "Qual é 1234 * 5678?"}))
Explicação:
- Começamos inicializando um modelo de chat OpenAI.
- Definimos uma ferramenta
CalculatorutilizandoLLMMathChaindo LangChain. - Extraímos um prompt ReAct padrão do LangChain Hub. ReAct (Raciocínio e Ação) é um paradigma que permite que os LLM executem raciocínios dinâmicos e planejamento de ações.
create_react_agentcombina o LLM, as ferramentas e o prompt para criar um agente.AgentExecutoré responsável pela execução do agente, gerenciando seu processo de raciocínio e a execução das ferramentas.- Quando perguntado sobre a capital da França, o LLM responde diretamente. Quando é feita uma pergunta de matemática, ele reconhece a necessidade da calculadora, chama a ferramenta e fornece o resultado.
2. LlamaIndex: Estrutura de Dados para Aplicações LLM
Enquanto o LangChain se concentra muito na orquestração e na concatenação dos chamados LLM, o LlamaIndex (anteriormente conhecido como GPT Index) se especializa na ingestão, indexação e recuperação de dados para aplicações LLM. Seu principal objetivo é simplificar a conexão dos LLM com fontes de dados personalizadas, permitindo aplicações poderosas RAG (Geração Aumentada por Recuperação). O LlamaIndex se destaca na construção de bases de conhecimento e na disponibilização de consultas pelos LLM.
Características Principais do LlamaIndex:
- Conectores de Dados: Ingerir dados de diferentes fontes (documentos, bancos de dados, APIs).
- Indexação de Dados: Estruturar e armazenar os dados de uma forma otimizada para as consultas LLM (por exemplo, arquivos vetoriais, grafos de conhecimento).
- Motores de Consulta: Recuperar informações relevantes dos índices e sintetizar respostas utilizando LLM.
- Agentes: Combinar motores de consulta com ferramentas e LLM para raciocínios mais complexos e em várias etapas sobre os dados.
- Contexto de Serviço: Gerenciar LLM, modelo de embedding e outras configurações de serviço.
Exemplo Prático de LlamaIndex: Consultar um Documento Personalizado
Vamos criar uma aplicação LlamaIndex simples que possa responder perguntas com base em um arquivo de texto local.
# Primeiro, cria 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 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
# Configura a chave API do OpenAI (certifique-se de que está nas suas variáveis de ambiente)
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"
# 1. Configura 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. Carrega documentos de um diretório
documents = SimpleDirectoryReader("data").load_data() # Assumindo que 'policy.txt' está em um diretório 'data'
# 3. Cria um índice a partir dos documentos (VectorStoreIndex é comum)
index = VectorStoreIndex.from_documents(documents)
# 4. Cria um motor de consulta
query_engine = index.as_query_engine()
# 5. Consulta 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.txtem um diretóriodata. - Configuramos o LLM e o modelo de embedding através do
Settings. SimpleDirectoryReadercarrega o arquivo de texto.VectorStoreIndex.from_documentsprocessa os documentos, os divide em pedaços, os integra 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 consulta recupera pedaços de documentos relevantes com base na similaridade semântica e, em seguida, utiliza o LLM para sintetizar uma resposta a partir desses pedaços.
3. Microsoft Semantic Kernel: O Orquestrador para Apps com AI-Powered e Plugins
Microsoft Semantic Kernel (SK) é um SDK open-source que permite aos desenvolvedores integrar modelos de linguagem de grandes dimensões (LLM) e outras capacidades de inteligência artificial em suas aplicações usando linguagens de programação existentes (C#, Python, Java). Foca na possibilidade de orquestrar interações com LLM e código tradicional, enfatizando uma arquitetura de ‘plugin’. O SK é particularmente forte para desenvolvedores já envolvidos no ecossistema Microsoft ou para aqueles que buscam um framework sólido de nível enterprise.
Características Chave 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 (LLM prompts) 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.
- Pianificadores: Habilitam a IA a planejar e executar uma sequência de habilidades para alcançar um objetivo.
Exemplo Prático de Semantic Kernel: Um Pianificador Simples com Plugin Personalizado
Criamos uma aplicação Semantic Kernel que pode saudar o usuário e também executar 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. Inicializamos o Kernel
kernel = sk.Kernel()
# 2. Configuramos 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. Definimos 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. Importamos o plugin no kernel
kernel.add_plugin(MathPlugin(), plugin_name="MyMathPlugin")
# 5. Definimos uma função semântica (para conversa geral)
# Este é um simples prompt 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 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. Utilizamos um planejador para orquestrar ações, incluindo nosso MathPlugin
# Para um planejamento complexo, você usaria um planejador dedicado como SequentialPlanner
# Para este simples exemplo, demonstraremos uma chamada direta via prompt com capacidade de chamada de função
# O LLM, quando invocado com o prompt correto, reconhecerá e utilizará os plugins registrados.
# Criamos um objetivo para o LLM alcançar utilizando 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ções do SK permite que o LLM escolha a função certa.
# Utilizaremos um serviço de conclusão de chat diretamente, permitindo que ele 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:
- Iniciamos o
Kernele adicionamos um serviço de conclusão de chat OpenAI. - Definimos uma classe
MathPlugincom decoradores@kernel_function, expondoaddemultiplycomo funções nativas. - Importamos este plugin no kernel.
- É criada uma simples função semântica
chat_functionpara interação direta com o LLM. - No
main(), invocamos primeiro diretamente a função de chat. - Depois, para o exemplo de planejamento, criamos um histórico de chat com um objetivo. Utilizando
function_call="auto"nas configurações, o LLM é habilitado a decidir se responde diretamente ou chama uma das funções nativas registradas (plugin) para alcançar o objetivo. SK gerencia a tradução da chamada de função do LLM em reais invocações de método e depois restitui o resultado ao LLM.
Escolha do Agente SDK Adequado
A escolha do Agente SDK depende fortemente das necessidades específicas do seu projeto e do seu stack tecnológico existente:
- Escolha LangChain se:
- Você precisa de uma orquestração ampla dos LLM, comportamento agente complexo e cadeias flexíveis de componentes.
- Quer integrar uma variedade de LLM, ferramentas e tipos de memória.
- Está construindo aplicações que envolvem raciocínios em várias etapas, seleção dinâmica de ferramentas e agentes conversacionais.
- Avalia uma comunidade ampla e ativa e exemplos extensivos.
- Escolha LlamaIndex se:
- Seu foco principal é conectar os LLM aos seus dados personalizados (documentos, bancos de dados, APIs) para RAG.
- Você precisa de sólidas capacidades de ingestão de dados, indexação e recuperação.
- Está construindo sistemas de Q&A baseados em conhecimento, resumos de documentos ou agentes conscientes dos dados.
- Prioriza uma gestão de dados eficiente e escalável para os LLM.
“`html
- Escolha o Microsoft Semantic Kernel se:
- Você é um desenvolvedor C#, Python ou Java em busca de integrar a IA de forma fluida nas aplicações existentes.
- Você quer um framework sólido, pronto para empresas, da Microsoft.
- Você precisa combinar as capacidades dos LLM (funções semânticas) com código tradicional (funções nativas/plugin) de maneira estruturada.
- Você está construindo aplicações que requerem que a IA interaja com seus sistemas e APIs internas.
Conclusão
Os Agent SDK são ferramentas indispensáveis para construir aplicações de IA sofisticadas. LangChain, LlamaIndex e Microsoft Semantic Kernel oferecem cada um poderosas funcionalidades especializadas em diferentes aspectos do desenvolvimento de IA. LangChain se destaca na orquestração de fluxos de trabalho complexos dos LLM e no raciocínio agente. LlamaIndex é a escolha ideal para integração de dados e geração aumentada a partir de recuperação. O Semantic Kernel fornece uma base sólida para integrar a IA nas aplicações existentes com uma arquitetura de plugin robusta, especialmente para casos de uso empresariais. Compreendendo seus pontos fortes fundamentais e vendo-os em ação através de exemplos práticos, você está agora melhor equipado para escolher o SDK certo para dar vida às suas ideias de agentes inteligentes.
“`
🕒 Published: