🤖 Agentes, MCP e Skills

Programas autonomos que percebem o ambiente, tomam decisoes e executam acoes para atingir objetivos sem intervencao humana constante.

42% das empresas ja usam agentes em producao. Entender o que sao e o primeiro passo para construi-los.

Agente vs chatbot, autonomia, loop percepcao-acao, LLM como cerebro do agente.

Sistemas com multiplos agentes especializados que colaboram, cada um com um papel definido, coordenados por um orquestrador.

Tarefas complexas exigem divisao de trabalho. Um agente sozinho tem limites de contexto e habilidade.

Orquestrador, router, agentes especializados, padroes fan-out/fan-in, pipeline.

Funcoes externas que agentes podem invocar: APIs, buscas, calculos, acesso a banco de dados, execucao de codigo.

Sem tools, agentes so geram texto. Com tools, eles agem no mundo real.

Function calling, tool definitions, JSON Schema, structured outputs.

Protocolo padrao da Anthropic para conectar LLMs a fontes de dados e ferramentas externas via arquitetura Host/Client/Server.

MCP e o USB-C dos agentes: um padrao universal que elimina integracoes ad-hoc.

Host, Client, Server, Resources, Tools, Prompts, stdio vs SSE transport.

Mecanismos para agentes reterem informacao entre interacoes e transferirem contexto entre si de forma eficiente.

Sem memoria, cada interacao comeca do zero. Sem handoff, agentes nao colaboram.

Memoria curta vs longa, episodica vs semantica, context passing, compactacao.

Exercicio pratico: desenhar um sistema com 2 agentes, 1 skill e 1 MCP server conectados.

Visao integrada antes de aprofundar cada tema. Conecta todos os conceitos da trilha.

Diagrama de sistema, fluxo de mensagens, definicao de roles, escolha de ferramentas.

Automacao segue regras fixas (if/then). Agentes tomam decisoes dinamicas baseadas em contexto e objetivos.

Confundir automacao com agentes leva a arquiteturas erradas. Saber quando usar cada abordagem e critico.

RPA vs agentes, determinismo vs adaptacao, espectro de autonomia, quando usar cada um.

Padrao onde o agente alterna entre raciocinio (Reason) e acao (Act) em ciclos ate completar a tarefa.

ReAct e o padrao fundamental de 90% dos agentes em producao. Entender o loop e entender agentes.

Thought-Action-Observation, loop iterativo, condicao de parada, max iterations.

Capacidade do agente de invocar funcoes externas: buscar dados, executar codigo, chamar APIs, ler arquivos.

Tool use transforma um chatbot em um agente. E a diferenca entre falar sobre fazer e realmente fazer.

Function calling, tool definitions, parametros tipados, retorno de resultados, error handling.

Capacidade do agente de quebrar tarefas complexas em subtarefas menores e executaveis, criando um plano de acao.

Agentes sem planning falham em tarefas de mais de 3 passos. Decomposicao e o que separa agentes toy de agentes reais.

Task decomposition, plan-and-execute, re-planning, backtracking, dependencias entre subtarefas.

Dados de adocao de agentes em empresas: customer support, code review, data analysis, DevOps automation.

Agentes nao sao teoria: 42% das empresas ja usam. Entender os use cases reais guia o que construir.

Top 5 use cases, ROI medio, limitacoes atuais, projecoes Gartner 2027.

Construir um agente simples com loop ReAct, 2 tools e condicao de parada. Testar com 3 cenarios.

Primeiro contato pratico com agentes. O loop ReAct fica concreto quando voce implementa.

Implementacao ReAct, 2 tools basicas, 3 cenarios de teste, debug de loop infinito.

Limites de um agente unico: context window, especializacao, paralelismo. Dividir para conquistar.

Agente unico com 50 tools e confuso. Agentes especializados com 5 tools cada sao precisos.

Limites de contexto, especializacao, paralelismo, isolamento de falhas, escalabilidade.

4 padroes: Pipeline (sequencial), Router (classificador), Fan-out/Fan-in (paralelo), Hierarchical (manager).

Escolher o padrao errado cria complexidade desnecessaria. Cada padrao resolve um tipo de problema.

Pipeline, Router, Fan-out/Fan-in, Hierarchical, quando usar cada padrao.

Definir papeis claros para cada agente: quem executa, quem analisa, quem revisa, quem decide.

Agentes sem role definido geram conflito e redundancia. Roles claros = sistema previsivel.

Role definition, system prompts por agente, separation of concerns, chain of responsibility.

Como agentes trocam informacoes: message passing, shared state, event bus, structured handoff.

Comunicacao mal feita e a principal causa de falha em sistemas multiagente.

Message passing, shared memory, event-driven, protocolos de handoff, serialization.

Comparacao dos 3 principais frameworks de multiagentes: CrewAI (roles), LangGraph (grafos), Swarm (handoffs).

Nao reinvente a roda. Cada framework tem trade-offs: simplicidade vs controle vs flexibilidade.

CrewAI crews/agents/tasks, LangGraph nodes/edges/state, Swarm routines/handoffs, quando usar cada.

Construir sistema com Router + 2 agentes especializados. Testar roteamento e comunicacao.

Multiagentes so faz sentido quando voce implementa. A complexidade real aparece no handoff.

Router implementation, 2 agentes especializados, protocolo de comunicacao, testes end-to-end.

Capacidades modulares que um agente pode invocar: buscar dados, enviar email, consultar API, executar codigo.

Skills sao o que transformam um LLM em algo util. Sem skills, agentes so conversam.

Skill vs tool vs plugin, anatomia de uma skill, input/output contract, composicao.

Como definir tools usando JSON Schema: nome, descricao, parametros tipados, required vs optional.

Todas as APIs de LLM (OpenAI, Anthropic, Google) usam JSON Schema para tool definitions. E o padrao universal.

JSON Schema types, properties, required, enum, nested objects, array items.

O fluxo completo: LLM recebe tools > decide usar > retorna JSON com nome e args > app executa > retorna resultado.

Function calling e o mecanismo core de agentes. Entender o fluxo completo evita bugs sutis.

Tool choice (auto/required/none), parallel tool calls, multi-turn tool use, error propagation.

Forcar o LLM a retornar JSON valido que segue um schema pre-definido. Garantia de formato, nao apenas sugestao.

Sem structured outputs, parsing de resposta e fragil. Com eles, integracao entre agentes e confiavel.

response_format, strict mode, Zod/Pydantic schemas, validacao server-side.

Padroes para criar skills que funcionam em qualquer agente: interface padrao, versionamento, composicao, testes.

Skills reutilizaveis aceleram o desenvolvimento de novos agentes em 3-5x.

Interface padrao, input validation, error handling, logging, composicao de skills.

Criar 3 skills com JSON Schema completo: 1 de leitura, 1 de escrita, 1 de integracao externa.

Skills concretas para o SaaS que voce esta construindo. Saida diretamente utilizavel.

3 skills tipadas, JSON Schema completo, testes unitarios, documentacao inline.

Model Context Protocol: padrao aberto da Anthropic para conectar LLMs a dados e ferramentas. O USB-C dos agentes.

Antes do MCP, cada integracao era custom. MCP padroniza: escreva uma vez, funcione em qualquer host.

Problema N x M, padronizacao, analogia USB-C, adocao por OpenAI/Google/Microsoft.

3 camadas: Host (app como Claude Desktop), Client (gerencia conexao), Server (expoe capacidades).

Entender a arquitetura e pre-requisito para criar e debugar MCP servers.

Host, Client, Server, transport (stdio/SSE), lifecycle, capability negotiation.

Resources (dados/contexto), Tools (acoes executaveis), Prompts (templates reutilizaveis). As 3 primitivas do MCP.

Saber qual primitiva usar para cada caso evita over-engineering e subuso do protocolo.

Resources (URI-based), Tools (JSON Schema), Prompts (templates), quando usar cada um.

Passo a passo: setup com @modelcontextprotocol/sdk, definir tools, handler de requests, testar com MCP Inspector.

Criar MCP servers e a skill mais valiosa do ecossistema de agentes em 2026.

SDK TypeScript/Python, StdioServerTransport, tool handler, MCP Inspector, debug.

Ecossistema de MCP servers prontos: GitHub, Slack, Google Drive, PostgreSQL, filesystem, browser.

Nao reinvente a roda. Centenas de MCP servers open source ja resolvem integracoes comuns.

MCP server registry, servers oficiais vs community, configuracao em claude_desktop_config.json.

Criar MCP server com 2 tools para o seu SaaS. Testar com Inspector e conectar ao Claude Desktop.

MCP server custom e o bridge entre seu produto e qualquer LLM. Skill diretamente monetizavel.

Setup projeto, 2 tools, testes com Inspector, deploy, configuracao no host.

4 tipos: Curta (context window), Longa (persistida), Episodica (eventos), Semantica (fatos/conhecimento).

Cada tipo resolve um problema diferente. Usar o tipo errado desperdica tokens ou perde informacao critica.

Short-term vs long-term, episodic vs semantic, salience scoring, decay functions.

Como implementar: SQLite para memoria estruturada, embeddings + vector DB para semantica, key-value para sessao.

Teoria de memoria sem implementacao nao serve. Cada backend tem trade-offs de performance e custo.

SQLite, pgvector, ChromaDB, Pinecone, RAG para memoria, caching strategies.

Como transferir contexto de um agente para outro sem perder informacao critica nem estourar context window.

Handoff mal feito perde contexto. Handoff com contexto demais estoura tokens. O equilibrio e uma arte.

Structured handoff, summary injection, selective context, metadata vs full context.

Garantir que memorias de um usuario nao vazem para outro. Particionamento por tenant_id em todos os niveis.

Vazamento de memoria entre tenants e um dos bugs mais graves em SaaS com IA. Prevencao e obrigatoria.

Tenant isolation, row-level security, namespace partitioning, audit trails.

Tecnicas para reduzir contexto sem perder informacao: sumarizacao progressiva, sliding window, hierarchical memory.

Context windows tem limite. Conversas longas precisam de compactacao inteligente para continuar funcionando.

Progressive summarization, sliding window, hierarchical memory, when to compact, quality metrics.

Implementar sistema com memoria curta (sessao) + memoria longa (SQLite) + handoff entre 2 agentes.

Memoria e o que faz agentes parecerem inteligentes. Sem memoria, cada interacao e uma tabula rasa.

Session store, SQLite persistence, handoff protocol, 3 cenarios de teste.

Visao integrada de tudo que foi aprendido: como agentes, skills, MCP e memoria se conectam em um sistema real.

Cada modulo ensinou uma peca. Agora e hora de ver o quebra-cabeca completo.

Diagrama de arquitetura, fluxo de dados, dependencias entre componentes, checklist de integracao.

Mapear quais agentes seu SaaS precisa, qual o papel de cada um, quais tools cada um usa.

Definir agentes antes de codar evita refactoring. A arquitetura de agentes e a arquitetura do produto.

Agent inventory, role matrix, tool assignment, system prompt per agent.

O componente que recebe requests e direciona para o agente certo. Classificacao por intencao, fallback, retry.

O router e o ponto de entrada do sistema. Router ruim = todos os agentes recebem input errado.

Intent classification, routing rules, fallback agent, confidence threshold, logging.

Wiring: conectar skills criadas no 4.4 e MCP servers do 4.5 aos agentes definidos no 4.7.2.

Integracao e onde tudo quebra. Testar cada conexao individualmente antes de testar o sistema completo.

Tool registry, MCP client config, dependency injection, health checks, integration tests.

End-to-end testing: request entra, router classifica, agente processa, tools executam, memoria persiste, resposta sai.

Testes unitarios nao pegam bugs de integracao. O fluxo completo revela problemas que pecas isoladas escondem.

E2E test scenarios, happy path, error paths, latency budget, observability.

Demo funcional: sistema com router + 2 agentes + skills + MCP + memoria. 5 cenarios de teste documentados.

Entregavel final da Trilha 4. Prova que voce sabe integrar todos os componentes de um sistema de agentes.

Demo script, 5 test scenarios, arquitetura documentada, video walkthrough, next steps.