decompose
OfficialClick on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@decomposeDecompose this contract for mandatory requirements and risks."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Decompose
Stop prompting. Start decomposing.
Deterministic text classification for AI agents. Decompose turns any text into classified, structured semantic units — instantly. No LLM. No setup. One function call.
Before: your agent reads this
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...After: your agent reads this
[
{
"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"]
}
]Every unit classified. Every standard extracted. Every risk scored. Your agent knows what matters.
Install
pip install decompose-mcpRelated MCP server: Intake-Triage
Use as MCP Server
Add to your agent's MCP config (Claude Code, Cursor, Windsurf, etc.):
{
"mcpServers": {
"decompose": {
"command": "uvx",
"args": ["decompose-mcp", "--serve"]
}
}
}Your agent gets two tools:
decompose_text— decompose any textdecompose_url— fetch a URL and decompose its content
OpenClaw
Install the skill from ClawHub or configure directly:
{
"mcpServers": {
"decompose": {
"command": "python3",
"args": ["-m", "decompose", "--serve"]
}
}
}Or install the skill: clawdhub install decompose-mcp
Use as 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 --compactUse as Library
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 LLMWhat Each Field Means
Field | Values | What It Tells Your Agent |
| mandatory, prohibitive, directive, permissive, conditional, informational | Is this a hard requirement or background? |
| safety_critical, security, compliance, financial, contractual, advisory, informational | How much does this matter? |
| requirement, definition, reference, constraint, narrative, data | What kind of content is this? |
| true/false | Must this be preserved verbatim? |
| 0.0 - 10.0 | How much compute should the agent spend here? |
| standards, codes, regulations | What formal references are cited? |
| true/false | Does someone need to do something? |
What to Build With This
Decompose is not the destination. It's the step before the LLM that most developers skip — not because it's hard, but because nobody showed them it exists. Documents have structure. That structure is classifiable. And classification should happen before reasoning.
Without: document → chunk → embed → retrieve → LLM → answer (100% of tokens)
With: document → decompose → filter/route → LLM → answer (20-40% of tokens)Filter: built-in LLM pre-filter
filter_for_llm() keeps mandatory, safety-critical, financial, and compliance units — drops boilerplate before it reaches your LLM or vector store.
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"],
})Route: risk-based processing
Safety-critical content goes to one chain. Financial content goes to another. Boilerplate gets skipped.
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 analysisMeasure: token cost reduction
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")See examples/ for runnable scripts.
Why No LLM?
Decompose runs on pure regex and heuristics. No Ollama, no API key, no GPU, no inference cost.
This is intentional:
Fast: <500ms for a 50-page spec
Deterministic: Same input always produces same output
Offline: Works air-gapped, on a plane, on CI
Composable: Your agent's LLM reasons over the structured output — decompose handles the preprocessing
The LLM is what your agent uses. Decompose makes whatever model you're running work better.
Built by Echology
Decompose is built by Echology and extracted from AECai, a document intelligence platform for Architecture, Engineering, and Construction firms. The classification patterns, entity extraction, and irreducibility detection are battle-tested against thousands of real AEC documents — specs, contracts, RFIs, inspection reports, pay applications.
Decompose earned its independence — it started as AECai's text classification module, proved general enough to work across domains (insurance, trading, regulatory), and was released standalone. Free, MIT-licensed.
Case Study: Open Scripture Intelligence
The same chunking and entity extraction patterns that classify engineering specs also structure the Bible. Open Scripture Intelligence uses Decompose's Markdown-aware chunker and regex entity extraction to transform 31,100 verses into a knowledge graph with 344,799 cross-reference edges and semantic embeddings — proving the methodology is domain-agnostic.
Blog
When Regex Beats an LLM — Decompose classifies the MCP spec in 3.78ms
Why Your Agent Needs a Cognitive Primitive — attention scoring, irreducibility, and routing
What "Simulation-Aware" Actually Means — the architecture behind AECai
License: MIT — Copyright (c) 2025-2026 Echology, Inc.
This server cannot be installed
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Latest Blog Posts
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/echology-io/decompose'
If you have feedback or need assistance with the MCP directory API, please join our Discord server