Decompose

Descompone texto en unidades semánticas clasificadas — autoridad, riesgo, atención, entidades. Sin LLM. Determinista.

Documentación

Decompose

Deja de preguntar. Empieza a descomponer.

Clasificación de texto determinista para agentes de IA. Decompose convierte cualquier texto en unidades semánticas clasificadas y estructuradas — al instante. Sin LLM. Sin configuración. Una sola llamada a función.

Antes: tu agente lee esto

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...

Después: tu agente lee esto

[
  {
    "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 unidad clasificada. Cada estándar extraído. Cada riesgo puntuado. Tu agente sabe qué importa.

Instalación

pip install decompose-mcp

Uso como servidor MCP

Añádelo a la configuración MCP de tu agente (Claude Code, Cursor, Windsurf, etc.):

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

Tu agente obtiene dos herramientas:

decompose_text — descompone cualquier texto
decompose_url — obtiene una URL y descompone su contenido

OpenClaw

Instala la habilidad desde ClawHub o configúrala directamente:

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

O instala la habilidad: 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

Qué Significa Cada Campo

Campo	Valores	Qué le dice a tu agente
`authority`	obligatorio, prohibitivo, directivo, permisivo, condicional, informativo	¿Es un requisito estricto o información de contexto?
`risk`	crítico_para_seguridad, seguridad, cumplimiento, financiero, contractual, consultivo, informativo	¿Cuánta importancia tiene?
`type`	requisito, definición, referencia, restricción, narrativa, datos	¿Qué tipo de contenido es?
`irreducible`	verdadero/falso	¿Debe conservarse textualmente?
`attention`	0.0 - 10.0	¿Cuánto cómputo debería invertir el agente aquí?
`entities`	estándares, códigos, regulaciones	¿Qué referencias formales se citan?
`actionable`	verdadero/falso	¿Alguien necesita hacer algo?

Qué Construir con Esto

Decompose no es el destino. Es el paso previo al LLM que la mayoría de los desarrolladores omiten — no porque sea difícil, sino porque nadie les mostró que existe. Los documentos tienen estructura. Esa estructura es clasificable. Y la clasificación debería ocurrir antes del razonamiento.

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

Filtro: pre-filtro LLM integrado

filter_for_llm() conserva unidades obligatorias, críticas para seguridad, financieras y de cumplimiento — elimina el texto de relleno antes de que llegue a tu LLM o almacén vectorial.

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"],
    })

Enrutamiento: procesamiento basado en riesgo

El contenido crítico para seguridad va a una cadena. El contenido financiero va a otra. El texto de relleno se omite.

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

Medición: reducción del costo 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")

Consulta examples/ para ver scripts ejecutables.

¿Por Qué Sin LLM?

Decompose funciona con expresiones regulares puras y heurísticas. Sin Ollama, sin clave de API, sin GPU, sin costo de inferencia.

Esto es intencional:

Rápido: <500ms para una especificación de 50 páginas
Determinista: La misma entrada siempre produce la misma salida
Sin conexión: Funciona en entornos aislados, en un avión, en CI
Componible: El LLM de tu agente razona sobre la salida estructurada — Decompose maneja el preprocesamiento

El LLM es lo que tu agente usa. Decompose hace que cualquier modelo que estés ejecutando funcione mejor.

Creado por Echology

Decompose está creado por Echology y extraído de AECai, una plataforma de inteligencia documental para firmas de Arquitectura, Ingeniería y Construcción. Los patrones de clasificación, la extracción de entidades y la detección de irreductibilidad están probados contra miles de documentos AEC reales — especificaciones, contratos, RFIs, informes de inspección, solicitudes de pago.

Decompose ganó su independencia — comenzó como el módulo de clasificación de texto de AECai, demostró ser lo suficientemente general para funcionar en distintos dominios (seguros, trading, regulación) y se publicó de forma independiente. Gratuito, con licencia MIT.

Caso de estudio: Open Scripture Intelligence

Los mismos patrones de fragmentación y extracción de entidades que clasifican especificaciones de ingeniería también estructuran la Biblia. Open Scripture Intelligence usa el fragmentador consciente de Markdown y la extracción de entidades por expresiones regulares de Decompose para transformar 31,100 versículos en un grafo de conocimiento con 344,799 aristas de referencias cruzadas y embeddings semánticos — demostrando que la metodología es independiente del dominio.

Blog

Cuando una Expresión Regular Supera a un LLM — Decompose clasifica la especificación MCP en 3.78ms
Por Qué Tu Agente Necesita una Primitiva Cognitiva — puntuación de atención, irreductibilidad y enrutamiento
Qué Significa Realmente "Consciente de la Simulación" — la arquitectura detrás de AECai