Pular para o conteudo
MODULO 4.1

🧩 Nos, arestas e estado

Voce ja sabe o que e um grafo. Agora vem a parte pratica: como projetar cada no, onde colocar a decisao na aresta, e o que exatamente viaja de um passo pro outro. E aqui que a teoria vira sistema que roda de verdade.

6
Topicos
40
Minutos
Intermediario
Nivel
Pratica
Tipo
Progresso deste modulo
0%0 de 6
1

🧱 Trate o no como unidade de trabalho

Um no pode ser um agente de IA, uma chamada de modelo, um pedaco de codigo comum ou ate uma decisao humana no meio do fluxo. A pergunta que voce precisa fazer antes de desenhar qualquer no e simples: isso aqui precisa de IA de verdade? Nem sempre a resposta e sim.

Um no deterministico β€” um if, uma query num banco, um script que so formata dados β€” e mais barato, mais rapido e mais confiavel do que jogar tudo pro modelo. A regra que a industria convergiu: codigo controla o roteamento previsivel, modelo cuida do que exige interpretacao ou julgamento.

πŸ†• Novo aqui? Duas palavras antes de seguir

  • No deterministico: um passo que sempre produz o mesmo resultado pra mesma entrada β€” sem modelo de IA no meio. Um if valor > 100 e deterministico.
  • Orquestrador: o no (ou agente) que decide pra quem mandar o trabalho a seguir β€” o "gerente" do grafo, nao quem executa a tarefa em si.
no modelo ferramentas permissoes instrucoes teto de custo se aprovado estado: resultado_valido=true se reprovado estado: motivo_erro preenchido a configuracao vive dentro do no; a decisao vive na aresta que sai dele

O que olhar: as cinco caixinhas ciano dentro do no. Cada uma delas pode ser diferente em cada no do seu grafo β€” e por isso elas ficam dentro da caixa, nao espalhadas pelo sistema. As duas setas de saida ja mostram o que o topico 2 vai destrinchar: e la, na aresta, que a condicao mora.

βœ“ Bom candidato a no deterministico

  • βœ“Validar formato de e-mail β€” regex resolve, sem julgamento
  • βœ“Consultar saldo numa API β€” chamada direta, resposta exata
  • βœ“Rotear por categoria ja marcada no banco β€” um switch

βœ— Precisa mesmo de modelo

  • βœ—Julgar se um texto e ofensivo β€” exige interpretacao de contexto
  • βœ—Resumir um documento longo em linguagem natural
  • βœ—Decidir qual das tres respostas ambiguas o cliente quis dizer

Conceitos-chave

No = unidade

Agente, codigo, humano ou modelo

Deterministico

Mais barato e mais confiavel

Codigo roteia

Modelo julga

Nem tudo e IA

Regra pratica da industria

2

πŸ”€ Ponha a decisao na aresta

Uma aresta condicional β€” a que carrega um "se" β€” e onde mora o roteamento: "se aprovado siga, se reprovado volte". Isso e exatamente o que separa um grafo de uma fila. Se todas as suas arestas sao incondicionais (sempre vao pro mesmo lugar seguinte), voce nao escreveu um grafo β€” escreveu um pipeline disfarcado.

πŸ’‘ Teste rapido: seu fluxo e grafo ou pipeline?

Olhe cada aresta do seu desenho e pergunte: "essa linha so existe porque uma condicao especifica foi satisfeita, ou ela sempre vai ser seguida?". Se a resposta for sempre "sempre segue", voce tem uma sequencia β€” util, mas nao e um grafo de verdade.

  • β€’Pipeline: passo 1 β†’ passo 2 β†’ passo 3, sempre nessa ordem, sem excecao
  • β€’Grafo: passo 1 β†’ (se X) passo 2, (se Y) passo 3, (se nem X nem Y) volta pro passo 1
escritor validador publicar se aprovado se reprovado (volta com motivo_erro) duas arestas condicionais saindo do mesmo no = ja e um grafo

O que olhar: as duas setas saindo do validador vao pra lugares diferentes, dependendo de uma condicao. E essa bifurcacao β€” nao a quantidade de nos β€” que faz esse desenho ser um grafo. Se so existisse a seta verde, seria so um pipeline de tres passos.

Conceitos-chave

Aresta condicional

Carrega um "se"

Roteamento

Mora na aresta, nao no no

Pipeline

Sequencia sem condicao

Teste rapido

"Essa aresta sempre segue?"

3

πŸ“¦ Defina o estado que viaja

O que exatamente passa de um no pro outro? Essa pergunta parece pequena, mas define metade do sucesso do seu grafo. O state schema β€” o formato acordado do que viaja pelas arestas β€” e um contrato, e contrato se escreve, nao se improvisa.

Passar a conversa inteira de um no pro outro parece seguro, mas anula o ganho de contexto limpo: o proximo no volta a ver como o trabalho foi feito, nao so o que foi produzido β€” e isso enche o contexto dele de ruido. Passar de menos faz o no seguinte trabalhar as cegas, sem o dado que ele precisava.

1

Passar demais: a conversa inteira

Historico completo de mensagens, raciocinio intermediario, tentativas anteriores.

O proximo no gasta tokens lendo o "como" quando so precisava do "o que". Contexto sujo, custo maior.

2

Passar de menos: so um texto solto

Um campo "resultado" sem status, sem origem, sem metadado de confianca.

O no seguinte nao sabe se aquilo passou por validacao, quem gerou, ou se pode confiar. Trabalha as cegas.

3

O meio-termo: state schema explicito

Campos nomeados, com tipo e dono: resultado, status, origem.

Cada no le so os campos que precisa e escreve os campos que e responsavel por preencher. Isso e um contrato.

πŸ’‘ Dica pratica

Escreva o state schema antes de escrever o primeiro no. Se voce nao consegue listar os campos que vao viajar, ainda nao entendeu o fluxo o suficiente pra codar β€” e vai acabar jogando a conversa inteira porque e mais facil do que pensar.

Conceitos-chave

State schema

Formato acordado do estado

Contrato

Se escreve, nao se improvisa

Demais

Anula contexto limpo

De menos

No trabalha as cegas

4

βš™οΈ Configure cada no separadamente

Modelo, ferramentas, permissoes, instrucoes e teto de custo (o limite maximo que aquele no pode gastar antes de ser interrompido) podem ser diferentes em cada no. Modelo forte no passo dificil e barato no facil; ferramenta de escrita so no no que escreve; acesso a internet so em quem pesquisa.

Essa configuracao por no e o que da valor economico real ao grafo β€” e onde o custo cai de verdade. Um sistema que usa o mesmo modelo caro em todo passo, so porque "e mais simples configurar uma vez", esta queimando dinheiro em passos que um modelo barato resolveria igual.

Diagrama de um sistema de agentes: o usuario faz uma solicitacao a um orquestrador central, que se liga a um planejador, um pesquisador, um executor com ferramentas proprias, e um validador que retorna feedback de volta pro orquestrador. Ha tambem um bloco de memoria com contexto e historico conectado ao orquestrador, e o resultado final e entregue ao usuario. Uma nota indica que cada no pode ser um agente ou um recurso.
O que olhar: nem toda caixa desse desenho e um agente. "Memoria" e "ferramentas" sao nos que sao recursos, nao agentes β€” eles nao decidem nada, so guardam ou executam. E repare na seta do validador voltando pro orquestrador: e essa aresta condicional de volta que faz esse desenho ser um grafo de verdade, e nao um pipeline linear de caixas em fila.

πŸ“Š O que configurar, no a no

  • Modelo β€” o forte (mais caro) so onde a decisao e dificil de verdade
  • Ferramentas β€” escrita, execucao de codigo, internet: liberado so pra quem precisa
  • Permissoes β€” quem pode alterar dado sensivel, quem so le
  • Teto de custo β€” limite de tokens/dolar por no, pra nenhum passo estourar o orcamento sozinho

Conceitos-chave

Teto de custo

Limite maximo por no

Config por no

Nao uma config global

Valor economico

E onde o custo cai

Ferramenta focada

So quem precisa recebe

5

🚫 Fuja do grafo degenerado

Um grafo de um no so, com todas as ferramentas e todas as instrucoes, girando ate acabar: isso e loop reinventado, e a estrutura de grafo nao esta fazendo nada por voce. Voce pagou a complexidade de "pensar em grafo" e nao colheu nenhum dos beneficios β€” configuracao por no, custo diferenciado, roteamento condicional.

Teste pratico: se voce nao consegue dar configuracoes diferentes a dois nos do seu desenho, provavelmente voce nao precisava de dois nos. Junte-os. Um grafo degenerado desse tipo nao e "errado" β€” ele so nao e um grafo, e um loop com um desenho bonito por cima.

loop loop estado explicito grafo + + = o grafo e composicao de loops com estado explicito β€” nao substituicao

O que olhar: a equacao nao tem "menos loop" em lugar nenhum β€” ela tem loop mais loop mais um ingrediente novo, o estado explicito que viaja entre eles (o que voce viu no topico 3). Um grafo de um no so, sem essa composicao, e so um loop se fingindo de grafo.

⚠️ Atencao: complexidade sem beneficio

Se voce desenhou cinco nos mas todos usam o mesmo modelo, as mesmas ferramentas, e nenhuma aresta tem condicao, voce nao ganhou nada com o desenho β€” so pagou o custo de manter cinco arquivos de configuracao em vez de um. Simplifique de volta pra um loop, ou adicione a diferenciacao que faltava.

Conceitos-chave

Grafo degenerado

Um no, tudo liberado

Teste pratico

Configs diferentes ou junte

Composicao

Grafo = loops + estado

Nao substituicao

Grafo nao mata o loop

6

πŸ“ Escolha a granularidade certa (e escreva seu grafo.json)

No grande demais e o grafo nao ajuda em nada β€” voce voltou pra caixa preta de um orquestrador unico fazendo tudo. No pequeno demais e voce paga sobrecarga de coordenacao em cima de trabalho trivial β€” mais arestas, mais estado pra passar, mais chance de erro, pra ganho nenhum.

Regra pratica: um no por mudanca de contexto, de ferramenta ou de responsabilidade. Se dois passos usam o mesmo contexto e as mesmas ferramentas, provavelmente sao um no so. Se um passo muda de "escrever" pra "validar", isso e mudanca de responsabilidade β€” dois nos.

βœ“ Separe em dois nos quando

  • βœ“Um passo escreve, o outro valida β€” responsabilidades diferentes
  • βœ“Um usa modelo caro, o outro so precisa de um script
  • βœ“Um precisa de acesso a internet, o outro nao pode ter

βœ— Junte num no so quando

  • βœ—Os dois passos usam exatamente o mesmo modelo e ferramentas
  • βœ—Voce so separou pra "deixar organizado", sem diferenca real
  • βœ—A aresta entre eles nunca teve condicao nenhuma

πŸ§ͺ Exemplo pratico: grafo.json com configuracao por no

Objetivo: evoluir o esqueleto de grafo introduzido no modulo 1.3, agora com config por no (modelo, ferramentas, teto de custo) e arestas com condicao quando. Copie, cole num arquivo grafo.json, e leia com qualquer script.

{
  "nos": {
    "escritor": {
      "modelo": "<modelo-medio>",
      "ferramentas": ["escrever_arquivo"],
      "teto_custo_usd": 0.05
    },
    "validador": {
      "modelo": "<modelo-forte>",
      "ferramentas": [],
      "teto_custo_usd": 0.02
    },
    "formatador": {
      "modelo": null,
      "ferramentas": ["script_deterministico"],
      "teto_custo_usd": 0.00
    }
  },
  "arestas": [
    { "de": "escritor", "para": "validador", "quando": "sempre" },
    { "de": "validador", "para": "formatador", "quando": "resultado_valido == true" },
    { "de": "validador", "para": "escritor", "quando": "resultado_valido == false" }
  ]
}

Como verificar: confira que escritor e validador tem modelos diferentes ({'<'}modelo-medio{'>'} vs {'<'}modelo-forte{'>'}) e que formatador nem usa modelo β€” e um no deterministico puro. Se dois dos seus nos tivessem a mesma config, o teste do topico 5 se aplica: junte-os, voce nao precisava de dois.

Agora troque pelo seu: substitua <modelo-medio> e <modelo-forte> pelos nomes reais dos seus modelos, e as condicoes em quando pelas regras de negocio do seu fluxo. Se sobrar um no sem nenhuma condicao de saida diferente dos outros, revise a granularidade.

Checagem rapida (nao bloqueia nada): voce tem dois nos que usam o mesmo modelo, as mesmas ferramentas e a mesma aresta de saida incondicional. O que fazer?

Conceitos-chave

Granularidade

Nem grande, nem microscopico

Regra pratica

Um no por mudanca de contexto

quando

Condicao explicita na aresta

Config por no

Modelo, ferramentas, teto

πŸ“Œ Resumo do Modulo

βœ“
No = unidade de trabalho β€” agente, modelo, codigo ou humano. Nem tudo precisa de IA.
βœ“
Decisao mora na aresta β€” aresta condicional e o que separa grafo de pipeline.
βœ“
Estado e contrato β€” nem a conversa inteira, nem de menos. Um schema explicito.
βœ“
Config por no β€” modelo, ferramentas e teto de custo diferentes e onde o valor economico mora.
βœ“
Fuja do degenerado β€” um no so com tudo liberado e loop disfarcado de grafo.
βœ“
Granularidade certa β€” um no por mudanca de contexto, ferramenta ou responsabilidade.

Proximo Modulo:

4.2 β€” Org graph x work graph: como o grafo de agentes reflete (ou nao) o grafo de pessoas da sua empresa.