Dédalo — Infraestrutura

Visão da stack

Dezesseis serviços. Uma topologia.

Tudo orquestrado via Docker Compose num único host (MVP) ou escalando horizontalmente. Zero dependência cloud no caminho crítico — invariante do projeto.

Vista isométrica de um templo grego com múltiplas alas conectadas

flowchart TB
  IG["Ingress
FastAPI :8000"] --> TEMP
  DASH["Dashboard
Next.js :3002"] --> APIGW["API Gateway
tRPC :4000"] --> TEMP
  MCP["MCP Server
FastMCP :8765"] --> TEMP
  TEMP["Temporal :7233
UI :8088"] --> PG[("Postgres :5432
+ pgvector + outbox")]
  PG -.outbox.-> NEO[("Neo4j :7687
graph memory")]
  TEMP --> LWT[local_worktree] & DOC[docker] & SSH[ssh] & E2B["remote_sandbox
e2b"]
  LWT & DOC & SSH & E2B --> LMS["LMStudio :1234
gemma4-27b + nomic"]
  LWT & DOC & SSH & E2B --> CLD["Claude Code CLI
Sonnet · Haiku"]
  TEMP --> LF["Langfuse :3000"]
  TEMP --> OTEL["OTel · Tempo · Loki"] --> GRAF["Grafana :3001"]
  PG --> GRAF
  NEO --> GRAF

Porta	Serviço	Função
8000	Ingress (FastAPI)	POST /v1/ingress · idempotência por content_hash · transactional outbox
3002	Dashboard (Next.js)	Inbox kanban, gates, timeline, cost explorer, releases
4000	API Gateway (tRPC)	Auth, rate-limit, audit, espelha tools MCP
8765	MCP Server (FastMCP)	25+ tools + 3 resources — gates, releases, items, memória, observabilidade, grafo
7233	Temporal Server	Workflow engine durável (gRPC)
8088	Temporal UI	Inspeção de workflows, signals, history
5432	Postgres + pgvector	Estado canônico · FSM · phase_events · embeddings · outbox_events
7474	Neo4j Browser	Knowledge graph bi-temporal — visualização Cypher
7687	Neo4j Bolt	Driver/Cypher · derivado de outbox_events
1234	LMStudio	gemma4-27b chat + nomic-embed-text-v1.5 (768-dim)
3000	Langfuse Web	Traces de LLM, scoring, datasets, eval
3001	Grafana	5 dashboards + alertas Alertmanager
4317/4318	OTel Collector	gRPC/HTTP — agrega spans
3100	Loki	Logs estruturados por phase_event_id
3200	Tempo	Armazenamento distribuído de traces
9090	Prometheus	TSDB métricas (15d retention)

Coração durável

Temporal.

Workflow engine self-hosted, persistido em Postgres. Cada uma das 11 fases é um child workflow durável.

Falha de processo, restart de worker, cluster reboot — o estado sobrevive. Replay determinístico para debug.

Signals para gates humanos (sem polling). Schedules para batches (MemorySync, DocGen, KnowledgeTree). Search attributes por ProjectID e ItemID para auditoria sob demanda.

Mecanismo de Antikythera com engrenagens de bronze interligadas

Estado canônico

Postgres é a fonte da verdade.

Nada em Redis. Nada em MongoDB. Nada perdido em cache volátil. Toda transição de estado, todo artefato, todo custo, toda memória semântica vive em uma única instância.

backlog_items

FSM canônica do item — status, content_hash, branch, commit_sha

phase_events

Audit trail invariante — toda transição de status persiste uma linha

artifacts

Plans, diffs, test_results, postmortems, deploy_logs versionados

agent_runs

Cada chamada LLM com prompt_hash, modelo efetivo, tokens, binding_role

cost_ledger

tokens_in, tokens_out, USD por run · pivot em dashboards

memory vector(768)

Embeddings pgvector · scope project · busca semântica + híbrida

gates

discovery_review, execution_gate, publication_gate, production_approval · SLA, decisão, reviewer

execution_environments

Por projeto — kind, config, commands, env_vars, env_secrets

agent_model_bindings

Mapa agente → modelo default + fallback chain · global e por projeto

release_batches Onda 13

FSM ativa do batch (open → frozen → gate_pending → deployed) · singleton por projeto

outbox_events

Pivot transacional · alimenta o Neo4j na mesma transação dos writes do Postgres

Outbox transacional. Toda escrita em phase_events, agent_runs, gate_decisions ou cost_ledger insere uma linha em outbox_events na mesma transação. Um workflow Temporal consome esse pivot e propaga para o Neo4j. Sem dual-write, sem perda — e o grafo é dropável e replayável a qualquer momento.

Fio de Ariadne

Grafo de memória.

Neo4j Community 5 como camada de enriquecimento derivada. Não é dual store — é projeção 100% replayable a partir de outbox_events.

Dois workflows Temporal alimentam o grafo:

GraphSyncWorkflow — escrita determinística via mappers Cypher por aggregate (phase_event, agent_run, gate_decision, memory_chunk, cost_ledger).
GraphitiExtractWorkflow — extração semântica via Bedrock (default bedrock-deepseek-v3-2), com cap em agent_policy.cost.caps_per_agent.graph_extraction.

Consumido pelos agentes via HybridRecall — pgvector ⊕ grafo ⊕ recência fundidos por Reciprocal Rank Fusion. Tools MCP pipeline_rework_history, graph_topic_query, graph_item_neighborhood e graph_cypher_readonly expõem o grafo para o Claude Code humano.

Se o Neo4j cair, agentes rodam em modo degradado (só pgvector) e logam — nunca falham por isso.

Constelação de nós em bronze conectados por fios dourados saindo de manuscritos gregos

Métrica Prometheus	Mede
pipeline_graph_outbox_lag_seconds	Lag do consumer do outbox · alerta GraphOutboxLagHigh em >30s
pipeline_graph_sync_events_processed_total	Eventos processados por aggregate × status (success/failed/skipped)
pipeline_memory_hybrid_recall_total	Recall hits por source · alerta HybridRecallFallbackHigh em fallback excessivo
pipeline_graphiti_episodes_processed_total	Progresso da extração semântica

Cérebros

Díptico alegórico com dois oráculos conectados — local e nuvem

Modelos LLM — local + premium.

Local em :1234/v1: gemma4-27b para chat estruturado · nomic-embed-text-v1.5 para embeddings 768-dim. Custo: zero.

Premium via Claude Code CLI: Haiku (fallback universal, $1/$5 por MTok) · Sonnet (execução em tasks L/XL, $3/$15 por MTok).

O LLMRouter resolve por agente em três camadas: override de projeto → binding default → fallback chain. Cada fallback grava agent_runs.binding_role='fallback'. Sem fallback silencioso. Custo entra como tie-breaker.

Mãos especializadas

Coding agents — quatro ferramentas.

Cada problema, sua ferramenta. O LLMRouter escolhe; o Temporal orquestra; o coding agent executa.

Quatro artesãos gregos cada um com sua ferramenta característica

Agente	Stack	Quando
Claude Code CLI	`claude --max-turns 200 --output-format stream-json --cwd <wt>` · subprocess · MCPs por projeto via `~/.claude/projects/<slug>/settings.json`	code_executor em tasks L/XL
OpenHands SDK	Python in-process · bash + filesystem · LLM aponta para LMStudio	code_executor em S/M · qa_triage · deploy_agent
OpenCode CLI	`opencode run --format json --agent plan` · modo plan = read-only	planner · plan_critic · discovery_history · discovery_tech
Hermes Agent	`hermes chat --max-turns 30` · toolsets browser/web/file/search · skill browser-harness	discovery_market · discovery_docs · discovery_state · doc_auditor

Onda 13 · trilha de release

Release Management.

Items em modo release agregam em release_batches — entidade ativa com FSM própria, singleton por projeto (partial unique index). Items em modo hotfix rodam individualmente e podem preemptar um release em andamento.

O ReleaseManagerWorkflow é long-running e responde a signals: attach_item, freeze, submit_release_gate_decision, notify_hotfix_deployed. O gate release_gate aceita decisões mode_change e detach_from_release para realocar item entre trilhas sem reabrir o ciclo.

Conflitos de rebase passam pelo rebase_conflict_resolver (Claude Sonnet, cap USD 1.00 por tentativa) e escalam para release_conflict_review com cap 3 ciclos.

flowchart TB
  O([open]) --> F[frozen]
  F --> GP[gate_pending]
  GP -- approved --> RB[rebasing]
  GP -- rejected --> CL([closed])
  RB -- clean --> MM[merge_to_main]
  RB -- conflict --> RCR[release_conflict_review]
  RCR --> RB
  MM --> DP[deploying]
  DP --> DEP([deployed])

  classDef gate fill:#C8A24A,stroke:#7A2A2A,color:#0E1116
  class GP,RCR gate

Caravana de mensageiros gregos atravessando ponte de pedra em formação, cada um carregando pergaminho selado, lanterna dourada à frente — metáfora do release batch

Ambientes por projeto

Quatro backends, quatro papéis.

Cada projeto declara execution_environments e mapeia quatro roles a backends. Multi-tenant desde o dia zero — zero acoplamento entre projetos.

Backends: local_worktree docker ssh remote_sandbox (e2b)

Roles: agent (onde o agente roda) · task_runner (executor de tarefas) · validator (suite de testes) · publisher (deploy)

Projeto	agent	task_runner	validator	publisher
nexo (NestJS)	local	docker	docker	docker compose
reconvert (microserviços)	local	docker	docker	ssh / EC2
docgen (Python)	local	local	local	none

Sentinelas

Observabilidade em quatro camadas.

Um trace cruza todas. Trace LLM no Langfuse referencia o trace_id OTel, que aponta para o Activity Temporal, que persiste o phase_event_id em Postgres.

Quatro olhos-sentinela observando fluxos de dados distintos

Langfuse

localhost:3000

Prompts, respostas, tool calls, scoring assíncrono (5% sample), datasets para eval, prompt versioning. Cada agente abre uma trace por execução.

OTel + Tempo

collector :4317 · tempo :3200

Spans de Activities Temporal, queries Postgres, chamadas Executor. Correlação trace_id ↔ Temporal history ↔ Langfuse trace.

Loki

localhost:3100

Logs estruturados JSON. Busca por phase_event_id. Retenção hot 30d / cold 1y.

Prometheus + Grafana

prometheus :9090 · grafana :3001

Métricas (latência, queue depth, health). 5 dashboards: Item Timeline, Project Health, Cost Explorer, Agent Performance, Gates Inbox. Alertas Alertmanager: budget, gate expirado, validation loop, LMStudio down, queue backlog, Postgres p99.

Portas

Quatro interfaces.

Quatro formas de submeter, observar e operar o pipeline. Mesma fonte de verdade no Postgres por trás de todas.

Ingress

FastAPI · :8000

POST /v1/ingress com idempotência por content_hash em janela de 24h. Transactional outbox dispara o workflow Temporal.

Dashboard

Next.js App Router · :3002

Inbox kanban, gate review, item timeline, cost explorer, releases. tRPC + TanStack Query + shadcn/ui.

API Gateway

Express + tRPC v11 · :4000

Auth (JWT/magic-link), rate-limit, audit log. Espelha as tools do MCP Server para integrações externas.

MCP Server

FastMCP · :8765

25+ tools por domínio — gates (list/get/approve/reject), releases (list_batches/freeze/approve), items (submit/status), memory (search/refresh), observability (phase_events, cost_summary, langfuse_*), graph (rework_history, topic_query, neighborhood, cypher_readonly). Mesma superfície alimenta o memory_chat no Dashboard via ActionCards.

A oficina por trás
do Labirinto.