Pular para o conteúdo
fernando.moretes.com
BlogEstudosCursosE-booksOpen SourcePodcasts
Loading…
Fernando Azevedo

Arquiteto de TI Especialista

Arquitetura, AWS, IA em produção, sistemas financeiros e FinOps, escritos a partir do que foi operado, com os números.

  • LinkedIn
  • GitHub
  • E-mail

Conteúdo

  • Blog
  • Estudos de arquitetura
  • Cursos
  • E-books
  • Open Source
  • Podcasts
  • Assuntos
  • Trilhas

Ferramentas

  • Moretes Architect MCP
  • Well-Architected self-check
  • Arquitetura deste site
  • Números públicos
  • Histórico de estudo

Sobre

  • Comunidade
  • IA Builder
  • Perfil
  • Currículo (CV)
  • Trabalhe comigo
  • Media kit
  • RSS do blog
  • RSS dos estudos
  • Artigos narrados (podcast)
  • llms.txt
  • Termos, privacidade e uso de IA

(c) 2026 Fernando Francisco Azevedo

MCP para Arquitetos: o Moretes Architect na prática/Da ideia à decisão: requisitos, painel de arquitetos e ADR
Módulo 2 · Trabalhar· Aula 03/10

Da ideia à decisão: requisitos, painel de arquitetos e ADR

O fluxo de descoberta no marketplace de pedidos: requirements_check expõe o que falta, architect_panel traz quatro lentes, architecture_pattern, service_compare e service_equivalents comparam sem eleger vencedor, e decision_record fecha num ADR de verdade.

13 min de leitura

Escolha como aprender

combine como quiser

Dica: o vídeo é um resumo visual rápido; o áudio e o texto trazem a aula completa. Terminar o áudio ou o vídeo, ou passar no quiz, já conta a aula como concluída.

Assista a esta aula
Narrado por Fernando AzevedoMP4PDF
Ouça esta aula
0:0016:18
Velocidade
Baixar

No Módulo 1 você conectou o servidor e leu a primeira resposta. Agora o MCP trabalha de verdade: pegamos a API de pedidos do marketplace (300 pedidos por minuto no pico, pagamento por cartão, clientes no Brasil, time de 4 pessoas, USD 1.500/mês, SLO de 99,9%) e vamos da ideia solta até um ADR com status proposed. Seis ferramentas e um prompt, na ordem em que eu uso quando sento com um time.

requirements_check: o que ela pergunta e o que se recusa a inventar

Todo projeto que eu vi dar errado começou escolhendo serviço antes de escrever requisito. requirements_check existe para forçar a ordem certa. Ela recebe três campos: workload (o texto livre do problema), requirements (lista) e constraints (lista). Não recebe SLA nem orçamento como número mágico, e é de propósito: a descrição da ferramenta diz "No inferred SLA or budget".

O que ela devolve é um espelho mais honesto do que você escreveu. Repete workload, requirements e constraints exatamente como entraram e acrescenta decisionsToClarify, sete pontos que sempre precisam de resposta antes de desenhar:

  • resultado de negócio e dono do workload;
  • classificação, residência e retenção dos dados;
  • tráfego normal e de pico, payload e crescimento;
  • SLO, p95/p99, RTO e RPO;
  • autenticação, autorização e tenancy;
  • orçamento com moeda e região de preço;
  • habilidades do time, dependências e restrições de migração.

Repare no que não aconteceu: ninguém chutou que 300 pedidos/minuto são 5 RPS sustentados (o pico tem forma, e a ferramenta não a conhece), ninguém assumiu que "clientes no Brasil" significa residência obrigatória em sa-east-1. A lista é a mesma para qualquer workload, e é isso que a torna útil: é um checklist determinístico, não uma opinião. O modelo do seu cliente lê a lista e vai atrás das respostas com você. nextTools já aponta o caminho: architecture_pattern, aws_knowledge_search e decision_record.

Todo resultado chega com kind: "heuristic-design-aid", validated: false e um limitation dizendo que não é revisão oficial da AWS, auditoria de segurança, deploy nem cotação. Leia isso como contrato, não como rodapé.

requirements_check no marketplace: argumentos e resultado (encurtado de docs/examples/requirements_check.json)
json
{
  "arguments": {
    "workload": "API de pedidos para marketplace com pagamento por cartão, 300 pedidos/minuto no pico, clientes no Brasil",
    "requirements": [
      "Confirmação do pedido em menos de 2 segundos (p95)",
      "Histórico de pedidos por 5 anos"
    ],
    "constraints": ["Equipe de 4 pessoas", "Orçamento de USD 1.500/mês"]
  },
  "result": {
    "kind": "heuristic-design-aid",
    "validated": false,
    "limitation": "Validate assumptions and current AWS documentation. This is not an official AWS review, security audit, deployment or price quote.",
    "decisionsToClarify": [
      "Business outcome and workload owner",
      "Data classification, residency and retention",
      "Traffic: normal/peak RPS, payloads and growth",
      "SLO, p95/p99 latency, RTO and RPO",
      "Authentication, authorization and tenancy",
      "Monthly budget, currency and pricing region",
      "Team skills, dependencies and migration constraints"
    ],
    "nextTools": ["architecture_pattern", "aws_knowledge_search", "decision_record"]
  }
}

architect_panel: quatro lentes, nenhum veredito

Quando um time me chama, a primeira coisa que faço não é opinar: é perguntar como quatro pessoas diferentes perguntariam. architect_panel faz isso de forma reproduzível. Você passa subject, artifactType (requirements, design, code, iac, api-contract, data-model, pipeline ou incident), roles (qualquer combinação dos 10 personas; o padrão é solution, security e finops) e knownFacts, a lista do que você já sabe.

No marketplace eu convoquei solution, security, data e finops sobre um artifactType: "design", com dois fatos conhecidos: "Budget: USD 1,500/month" e "SLO: 99.9% monthly". Cada persona volta com mandate, askFirst, checks, toolsToCall, deliverables e antiPatterns. A lista askFirst é filtrada pelos knownFacts: o Arquiteto de Soluções tem seis perguntas no catálogo, mas no resultado aparecem cinco, porque "Budget per month and pricing region?" casa com o fato "Budget: ..." e sai. O filtro é simples: compara a primeira palavra da pergunta, em minúsculas, com o texto dos fatos. Por isso "SLO: 99.9% monthly" não remove "SLO, p95 latency, RTO and RPO?" (a primeira palavra é "SLO," com vírgula). Saber como o filtro funciona evita esperar inteligência onde existe uma regra.

toolsToCall vem ordenado pelo artifactType: para design, as ferramentas de foco são c4_model, service_compare, threat_model, well_architected_review e cost_model; as que a persona domina sobem primeiro, até seis por papel. O bloco synthesis fecha com três regras que eu assino: conflito entre papéis (custo versus resiliência) se resolve num decision_record; todo achado tem dono, evidência e critério de validação; o que é desconhecido continua desconhecido.

A descrição da ferramenta diz "Lens, not a verdict". O painel não decide nada. Ele faz o modelo do seu cliente adotar quatro pontos de vista e dá a cada um a lista certa de ferramentas. Cada papel também existe como prompt (architect_solution, architect_security...) e como recurso moretes://personas/<id>.

architect_panel com quatro papéis: a persona solution, encurtada (docs/examples/architect_panel.json). Note as cinco perguntas em askFirst: a de orçamento saiu por causa de knownFacts.
json
{
  "arguments": {
    "subject": "Checkout API for a marketplace: 300 orders/minute at peak, card payments, pt-BR customers, team of 4",
    "artifactType": "design",
    "roles": ["solution", "security", "data", "finops"],
    "knownFacts": ["Budget: USD 1,500/month", "SLO: 99.9% monthly"]
  },
  "result": {
    "kind": "architect-panel",
    "validated": false,
    "panel": [
      {
        "role": "solution",
        "title": "Solution Architect",
        "askFirst": [
          "What outcome and who owns it?",
          "Normal and peak traffic, payload sizes, growth?",
          "SLO, p95 latency, RTO and RPO?",
          "Data classification, residency and retention?",
          "Team skills and existing platform constraints?"
        ],
        "checks": [
          "Two alternatives compared with evidence, not one option justified",
          "Costs are a dated scenario with sources"
        ],
        "toolsToCall": ["service_compare", "c4_model", "cost_model", "requirements_check", "architecture_pattern", "service_equivalents"],
        "antiPatterns": ["Choosing services before requirements", "Diagram without data flows or trust boundaries", "Single-region by accident"]
      },
      { "role": "security", "toolsToCall": ["threat_model", "iam_policy_review", "..."] },
      { "role": "data", "toolsToCall": ["service_compare", "service_equivalents", "data_classification", "..."] },
      { "role": "finops", "toolsToCall": ["cost_model", "finops_unit_economics", "..."] }
    ],
    "synthesis": [
      "Resolve conflicts between roles explicitly (e.g. cost versus resilience) in a decision_record",
      "Every finding needs an owner, evidence and a validation criterion",
      "Unknown stays unknown; do not fill gaps with assumptions"
    ]
  }
}

architecture_pattern e o parâmetro provider

architecture_pattern responde a uma pergunta diferente: "se o padrão é este, que peças entram e que perguntas eu ainda devo?". São cinco padrões fechados: serverless-api, container-api, event-driven, rag e agent-platform. Cada um devolve services, fit, tradeoffs, nodes, questions e um mermaid pronto para colar na documentação. Para os eventos do pedido alimentando cobrança, estoque e notificações, o padrão é event-driven: EventBridge, SQS, Lambda, DynamoDB e CloudWatch. O encaixe é "eventos de negócio assíncronos com consumidores desacoplados"; os trade-offs são consistência eventual e ordenação, duplicidade e evolução de schema; e as duas perguntas que ela devolve são as que eu faria: qual é o escopo de deduplicação, e quem é dono da recuperação da DLQ e da autorização de replay.

O parâmetro provider (aws, azure, gcp, oci ou oss; padrão aws) é o que torna a ferramenta honesta para quem não vive só na AWS. Ele não troca o padrão: acrescenta serviceMapping, uma lista de pares que lê cada serviço AWS pela categoria de capacidade em equivalents.json (EventBridge é event-bus, SQS é queue, Lambda é serverless-functions, DynamoDB é nosql-kv, CloudWatch é observability). Quando um serviço não tem categoria mapeada, o valor é a string no mapping in snapshot, não um palpite. O mermaid continua com os nós do padrão (Producer, EventBridge, SQS, Consumer), porque o diagrama é do padrão, não do fornecedor. Equivalência aqui é funcional: cota, modelo de consistência e dimensão de preço mudam de nuvem para nuvem, e a ferramenta diz isso em vez de esconder.

architecture_pattern com provider: "azure" (docs/examples/architecture_pattern.json, encurtado): o padrão continua AWS, o serviceMapping lê cada peça em Azure
json
{
  "arguments": {
    "pattern": "event-driven",
    "workload": "Order events feeding billing, inventory and notifications",
    "provider": "azure"
  },
  "result": {
    "services": ["EventBridge", "SQS", "Lambda", "DynamoDB", "CloudWatch"],
    "fit": "Asynchronous business events with decoupled consumers",
    "tradeoffs": ["Eventual consistency", "Ordering, duplication and schema evolution"],
    "questions": [
      "What is the deduplication scope?",
      "Who owns DLQ recovery and replay authorization?"
    ],
    "provider": "azure",
    "serviceMapping": [
      { "aws": "EventBridge", "azure": "Azure Event Grid" },
      { "aws": "SQS", "azure": "Azure Service Bus queues / Queue Storage" },
      { "aws": "Lambda", "azure": "Azure Functions" },
      { "aws": "DynamoDB", "azure": "Azure Cosmos DB" },
      { "aws": "CloudWatch", "azure": "Azure Monitor / Application Insights" }
    ],
    "mermaid": "flowchart LR\n  n0[\"Producer\"]\n  n1[\"EventBridge\"]\n  n2[\"SQS\"]\n  n3[\"Consumer\"]\n  n0 --> n1\n  n1 --> n2\n  n2 --> n3"
  }
}

service_compare e service_equivalents: comparar sem eleger vencedor

service_compare recebe uma family (compute, database, messaging ou rag-store) e as suas constraints, e devolve options com service, fit e tradeoff para cada alternativa. Para mensageria com "ordering per customer", "two consumer teams" e "replay within 7 days", voltam quatro opções: SQS (entrega bufferizada; o consumidor é dono da idempotência e da DLQ), SNS (fanout por push; política de entrega do assinante), EventBridge (roteamento e integração; governança de schema) e Step Functions (estado explícito de workflow; transições e limites de execução). Não há coluna de nota, não há "recomendado", e a descrição avisa: "No automatic winner or fabricated scores". O campo decisionRequired diz o que fazer: coletar evidência do workload e preço atual antes de escolher. As constraints voltam no resultado, mas quem as cruza com as opções é o modelo, e quem assina é você.

service_equivalents é a tabela multi-cloud por trás do provider. São 43 categorias de capacidade (queue, event-bus, serverless-functions, relational-db, vector-search, agent-runtime, kms, iac...), com from e to entre aws, azure, gcp, oci e oss; aceita também query para achar a categoria por texto. Pedindo queue, event-bus, serverless-functions e relational-db de aws para azure, gcp e oss, o Amazon SQS vira Azure Service Bus queues / Queue Storage, Pub/Sub (pull) / Cloud Tasks e RabbitMQ / NATS JetStream; o Amazon EventBridge vira Azure Event Grid, Eventarc e NATS / Knative Eventing. O resultado carrega kind: "reference-snapshot", snapshotDate: "2026-10-24" e uma limitation explícita: equivalência é funcional, não idêntica; cotas, consistência, preço e disponibilidade regional diferem. É o tipo de honestidade que eu quero de uma ferramenta: ela diz de quando é a foto e manda confirmar na documentação de cada fornecedor.

O prompt architecture_discovery é o roteiro desta aula

O servidor publica 20 prompts; architecture_discovery é o que amarra as ferramentas desta aula. O texto que o seu cliente entrega ao modelo quando você o seleciona é este: "Ask for business outcome, traffic, data classification, latency, availability, budget, region and team constraints. Use requirements_check, architecture_pattern, service_compare, service_equivalents and aws_knowledge_search. Cite current sources and list assumptions before decision_record. Do not deploy anything." Repare na ordem: perguntar, comparar, citar fonte, listar premissas, e só então registrar. O prompt não executa nada; ele muda o comportamento do modelo, e o servidor continua sem chamar modelo nenhum.

O fluxo de descoberta, na ordem em que eu faço

  1. 1

    Escreva o que você sabe e o que não sabe

    Chame requirements_check com workload, requirements e constraints como estão hoje, mesmo incompletos. Leve decisionsToClarify para a reunião com o dono do produto: cada item sem resposta é uma premissa que vai aparecer no ADR.

  2. 2

    Convoque o painel com os fatos que já tem

    architect_panel com roles escolhidos para o risco do projeto (no marketplace: solution, security, data, finops) e knownFacts preenchido, para que askFirst só traga o que falta. Anote toolsToCall de cada papel: é o plano das próximas chamadas.

  3. 3

    Nomeie o padrão e leia em outra nuvem se precisar

    architecture_pattern com um dos cinco padrões e o workload. Se o time ou o cliente opera em Azure, GCP ou OCI, passe provider e use serviceMapping para a conversa, lembrando que o diagrama continua sendo do padrão.

  4. 4

    Compare as famílias em disputa

    service_compare por family com as suas constraints, e service_equivalents quando a pergunta for "isso existe fora da AWS?". Nenhuma das duas elege vencedor: a saída é a lista de trade-offs que você vai ter que defender.

  5. 5

    Verifique na fonte oficial e date

    aws_knowledge_search para confirmar cota, limite e preço do que entrou na comparação (o limite de throughput do SQS FIFO por message group, por exemplo). A data da consulta vai para o ADR. Essa ferramenta ganha uma aula própria mais adiante.

  6. 6

    Registre a decisão como proposta

    decision_record com título imperativo, contexto com números, pelo menos duas alternativas reais, decisão e consequências com custo. Deixe status: "proposed" até existir aprovador nomeado e data.

Quem faz o quê na descoberta

EtapaA ferramenta (determinística)O modelo do seu clienteVocê
requirements_checkDevolve a lista fixa de 7 decisões a esclarecer e os próximos tools; não infere SLA nem orçamento.Lê a lista, pergunta ao usuário o que falta e organiza as respostas.Responde com números reais e nomeia o dono do workload.
architect_panelEntrega perguntas, checagens, entregáveis e tools por papel; filtra askFirst por knownFacts.Adota cada lente, faz as perguntas e chama as ferramentas listadas.Escolhe os papéis pelo risco do projeto e resolve o conflito entre eles.
architecture_pattern, service_compare, service_equivalentsLista serviços, encaixe, trade-offs, perguntas e equivalentes datados; nenhum vencedor.Cruza as constraints com as opções e explica o trade-off em linguagem do time.Escolhe, e aceita o trade-off por escrito.
aws_knowledge_searchConsulta o AWS Knowledge MCP oficial e devolve trechos com URL.Resume e cita; separa evidência atual de heurística.Abre a fonte, confere a data e grava a data do preço.
decision_recordMonta o markdown do ADR com seção Validation; não inventa aceite.Redige contexto e consequências a partir das etapas anteriores.Aprova (nome e data) ou mantém proposed; marca a data de revisão.

decision_record: o ADR sai de verdade, e a skill adr-writing diz como escrevê-lo

decision_record é a única ferramenta desta aula que produz um documento. Os campos são os do ADR clássico: title, context, options (de 2 a 10), decision, consequences e status (proposed, accepted ou superseded; o padrão é proposed). O resultado é markdown com as seções Context, Options, Decision, Consequences e uma seção Validation que a ferramenta acrescenta sempre: "Record owner, test evidence, pricing date and review date before adoption". A descrição diz "Does not invent acceptance": você pode passar status: "accepted", mas ninguém vai aprovar por você.

No marketplace, o ADR do exemplo é "Use SQS FIFO per tenant for order events". Contexto: eventos em ordem por cliente, pico de 300 pedidos/min, consumidores de cobrança e estoque em dois times. Três opções: SQS FIFO com message group por cliente, Kinesis Data Streams com partition key, chamadas síncronas diretas entre serviços. Decisão: FIFO com um grupo por cliente, ordenação onde importa, superfície operacional limitada, DLQ por consumidor. Consequências: monitorar o limite de throughput por message group, consumidores idempotentes por id de evento, replay só com runbook autorizado.

A skill adr-writing (recurso moretes://skills/adr-writing) é o que separa um ADR lido de um ADR arquivado, e as regras cabem em seis linhas:

  • Uma decisão por registro. Se precisou de "e", divida.
  • Pelo menos duas alternativas reais, cada uma com a condição em que ela ganharia. Opção listada só para ser rejeitada é cheiro ruim.
  • Consequências incluem os custos: operacional, financeiro e organizacional. Consequência sem negativo é outro cheiro.
  • Status começa em proposed. accepted exige aprovador nomeado e data.
  • Registre a data do preço e a versão da documentação citada.
  • Marque data de revisão: decisão de arquitetura vence.

O terceiro cheiro da skill é decisão justificada por afirmação de fornecedor sem fonte. É por isso que aws_knowledge_search entra antes do decision_record no prompt, e não depois.

O markdown que decision_record devolve para o marketplace (campo result.markdown de docs/examples/decision_record.json, na íntegra)
text
# ADR: Use SQS FIFO per tenant for order events

Status: proposed

## Context
Order events must be processed in order per customer; peak 300 orders/min; consumers are billing and inventory services owned by two teams.

## Options
- SQS FIFO with message group per customer
- Kinesis Data Streams with partition key
- Direct synchronous calls between services

## Decision
SQS FIFO with one message group per customer: ordering where it matters, bounded operational surface, dead-letter queue per consumer.

## Consequences
- FIFO throughput limit per message group must be monitored
- Consumers must be idempotent on event id
- Replay requires an authorized runbook

## Validation
Record owner, test evidence, pricing date and review date before adoption.
Ordenar

Ordene a descoberta

Do problema solto ao ADR proposto, na ordem do prompt architecture_discovery.

  1. 1requirements_check: escrever workload, requisitos e restrições e ler decisionsToClarify
  2. 2architecture_pattern: nomear o padrão (e o provider, se preciso)
  3. 3decision_record: registrar o ADR com status proposed
  4. 4service_compare e service_equivalents: listar trade-offs sem vencedor
  5. 5architect_panel: convocar os papéis com knownFacts e anotar toolsToCall
  6. 6aws_knowledge_search: confirmar limites e preços na fonte oficial e datar
Quiz

Checagem rápida

1. Você chama requirements_check sem informar SLO nem orçamento. O que a ferramenta faz com esses dois pontos?
2. No exemplo do marketplace, o Arquiteto de Soluções tem seis perguntas no catálogo, mas askFirst traz cinco. Por quê?
3. O que muda no resultado de architecture_pattern quando você passa provider: "azure"?
4. Segundo a skill adr-writing, quando um ADR pode sair de proposed para accepted?

Referências

Moretes Architect MCP: repositório (MIT), com docs/tools.md e docs/examples/*.json de onde saíram os resultados desta aulaInventário público de ferramentas do servidor (/tools.json)Model Context Protocol: especificação de prompts (como architecture_discovery chega ao cliente)Architectural Decision Records (adr.github.io): origem do formato Context / Options / Decision / ConsequencesAWS Well-Architected Framework (a fonte que todo resultado heurístico cita em sources)
Concluir e ir para a próxima Aula anterior