Decompose

Texto decomposto em unidades semânticas classificadas — autoridade, risco, atenção, entidades. Sem LLM. Determinístico.

Documentação

Decompose

Pare de dar prompts. Comece a decompor.

Classificação de texto determinística para agentes de IA. Decompose transforma qualquer texto em unidades semânticas estruturadas e classificadas — instantaneamente. Sem LLM. Sem configuração. Uma chamada de função.

Antes: seu agente lê isto

The contractor shall provide all materials per ASTM C150-20. Maximum load
shall not exceed 500 psf per ASCE 7-22. Notice to proceed within 14 calendar
days of contract execution. Retainage of 10% applies to all payments.
For general background, the project is located in Denver, CO...

Depois: seu agente lê isto

[
  {
    "text": "The contractor shall provide all materials per ASTM C150-20.",
    "authority": "mandatory",
    "risk": "compliance",
    "type": "requirement",
    "irreducible": true,
    "attention": 8.0,
    "entities": ["ASTM C150-20"]
  },
  {
    "text": "Maximum load shall not exceed 500 psf per ASCE 7-22.",
    "authority": "prohibitive",
    "risk": "safety_critical",
    "type": "constraint",
    "irreducible": true,
    "attention": 10.0,
    "entities": ["ASCE 7-22"]
  }
]

Cada unidade classificada. Cada padrão extraído. Cada risco pontuado. Seu agente sabe o que importa.

Instalação

pip install decompose-mcp

Uso como Servidor MCP

Adicione à configuração MCP do seu agente (Claude Code, Cursor, Windsurf, etc.):

{
  "mcpServers": {
    "decompose": {
      "command": "uvx",
      "args": ["decompose-mcp", "--serve"]
    }
  }
}

Seu agente recebe duas ferramentas:

decompose_text — decompor qualquer texto
decompose_url — buscar uma URL e decompor seu conteúdo

OpenClaw

Instale a skill do ClawHub ou configure diretamente:

{
  "mcpServers": {
    "decompose": {
      "command": "python3",
      "args": ["-m", "decompose", "--serve"]
    }
  }
}

Ou instale a skill: clawdhub install decompose-mcp

Uso como CLI

# Pipe text
cat spec.txt | decompose --pretty

# Inline
decompose --text "The contractor shall provide all materials per ASTM C150-20."

# Compact output (smaller JSON)
cat document.md | decompose --compact

Uso como Biblioteca

from decompose import decompose_text, filter_for_llm

result = decompose_text("The contractor shall provide all materials per ASTM C150-20.")

for unit in result["units"]:
    print(f"[{unit['authority']}] [{unit['risk']}] {unit['text'][:60]}...")

# Pre-filter for LLM context — keep only high-value units
filtered = filter_for_llm(result, max_tokens=4000)
print(f"{filtered['meta']['reduction_pct']}% token reduction")
llm_input = filtered["text"]  # Ready for your LLM

O Que Cada Campo Significa

Campo	Valores	O Que Informa ao Seu Agente
`authority`	mandatory, prohibitive, directive, permissive, conditional, informational	Isso é um requisito rígido ou contexto?
`risk`	safety_critical, security, compliance, financial, contractual, advisory, informational	Quanto isso importa?
`type`	requirement, definition, reference, constraint, narrative, data	Que tipo de conteúdo é este?
`irreducible`	true/false	Deve ser preservado literalmente?
`attention`	0.0 - 10.0	Quanto de computação o agente deve gastar aqui?
`entities`	standards, codes, regulations	Quais referências formais são citadas?
`actionable`	true/false	Alguém precisa fazer algo?

O Que Construir Com Isso

Decompose não é o destino. É o passo antes do LLM que a maioria dos desenvolvedores pula — não porque é difícil, mas porque ninguém mostrou que ele existe. Documentos têm estrutura. Essa estrutura é classificável. E a classificação deve acontecer antes do raciocínio.

Without:  document → chunk → embed → retrieve → LLM → answer  (100% of tokens)
With:     document → decompose → filter/route → LLM → answer  (20-40% of tokens)

Filtro: pré-filtro LLM integrado

filter_for_llm() mantém unidades obrigatórias, críticas de segurança, financeiras e de conformidade — descarta texto padrão antes que chegue ao seu LLM ou armazenamento vetorial.

from decompose import decompose_text, filter_for_llm

result = decompose_text(open("contract.md").read())
filtered = filter_for_llm(result, max_tokens=4000)

# filtered["text"] = high-value units only, ready for LLM
# filtered["meta"]["reduction_pct"] = how much was dropped (typically 60-80%)

# Or use the units directly for embedding
for unit in filtered["units"]:
    embed_and_store(unit["text"], metadata={
        "authority": unit["authority"],
        "risk": unit["risk"],
        "attention": unit["attention"],
    })

Rota: processamento baseado em risco

Conteúdo crítico de segurança vai para uma cadeia. Conteúdo financeiro vai para outra. Texto padrão é ignorado.

from decompose import decompose_text

result = decompose_text(spec_text)

for unit in result["units"]:
    if unit["risk"] == "safety_critical":
        safety_chain.process(unit)       # Full analysis + human review
    elif unit["risk"] == "financial":
        audit_chain.process(unit)         # Flag for finance team
    elif unit["attention"] < 0.5:
        pass                              # Skip boilerplate
    else:
        general_chain.process(unit)       # Standard LLM analysis

Medir: redução de custo de tokens

from decompose import decompose_text

result = decompose_text(spec_text)
total = len(result["units"])
high = [u for u in result["units"] if u["attention"] >= 1.0]

print(f"{len(high)}/{total} units need LLM analysis")
print(f"{100 - len(high) * 100 // total}% token reduction")

Veja examples/ para scripts executáveis.

Por Que Sem LLM?

Decompose roda com regex e heurísticas puras. Sem Ollama, sem chave de API, sem GPU, sem custo de inferência.

Isso é intencional:

Rápido: <500ms para uma especificação de 50 páginas
Determinístico: A mesma entrada sempre produz a mesma saída
Offline: Funciona sem conexão, em um avião, no CI
Componível: O LLM do seu agente raciocina sobre a saída estruturada — decompose cuida do pré-processamento

O LLM é o que seu agente usa. Decompose faz qualquer modelo que você esteja executando funcionar melhor.

Construído pela Echology

Decompose é construído pela Echology e extraído do AECai, uma plataforma de inteligência documental para empresas de Arquitetura, Engenharia e Construção. Os padrões de classificação, extração de entidades e detecção de irredutibilidade são testados em batalha contra milhares de documentos AEC reais — especificações, contratos, RFIs, relatórios de inspeção, aplicações de pagamento.

Decompose conquistou sua independência — começou como módulo de classificação de texto do AECai, provou ser geral o suficiente para funcionar em vários domínios (seguros, negociação, regulatório) e foi lançado de forma independente. Gratuito, licenciado sob MIT.

Estudo de Caso: Open Scripture Intelligence

Os mesmos padrões de divisão em blocos e extração de entidades que classificam especificações de engenharia também estruturam a Bíblia. Open Scripture Intelligence usa o divisor de blocos ciente de Markdown do Decompose e a extração de entidades por regex para transformar 31,100 versículos em um grafo de conhecimento com 344,799 arestas de referência cruzada e embeddings semânticos — provando que a metodologia é independente de domínio.

Blog

Quando Regex Vence um LLM — Decompose classifica a especificação MCP em 3.78ms
Por Que Seu Agente Precisa de uma Primitiva Cognitiva — pontuação de atenção, irredutibilidade e roteamento
O Que "Ciente de Simulação" Realmente Significa — a arquitetura por trás do AECai