Decompose MCP server
✓ VerifiedDecomposes text into classified semantic units like authority, risk, and attention without using an LLM.
Also known as echology-io/decompose, decompose-mcp
- Stars
- 10
- Tools
- —
- Downloads, 30 days
- 186
- Latest version
- 0.1.1
- Last commit
- May 24, 2026
- License
- MIT
What is Decompose MCP?
Decompose decomposes text into classified semantic units like authority, risk, and attention without using an LLM.
Summary generated from the project's README
About Decompose MCP server
Decompose provides deterministic text classification for AI agents by breaking down text into structured semantic units. Unlike many processing tools, it operates without an LLM, using regex and heuristics to ensure fast, offline, and predictable results. This makes it suitable for developers building agents that need to process large documents like contracts, specifications, or regulatory texts without incurring high inference costs or latency.
Users can integrate this server into clients like Claude Code, Cursor, or Windsurf using the uvx command. The server provides two primary tools: decompose_text for analyzing raw strings and decompose_url to fetch and process web content. It categorizes information into specific fields such as authority, risk, type, and attention scores, while also identifying entities like standards or regulations.
By identifying high-value units, the tool allows developers to filter out boilerplate and reduce token usage before sending data to a reasoning model. This preprocessing step helps in routing specific risks, such as safety-critical or financial content, to specialized processing chains.
What you can do with it
- 1Reduce LLM token consumptionAn AI agent can use the built-in filter to keep only high-value units and drop boilerplate text.
- 2Route content based on riskDevelopers can direct different types of information to specific processing pipelines based on their classification.
- 3Analyze web content directlyAn agent can fetch a URL and immediately receive a decomposed semantic structure of the page.
Written from the project's README. Every use case is checked against a quote from it.
How to install Decompose MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Decompose MCP in Claude Code
$ claude mcp add decompose -- uvx decompose-mcpInstall Decompose MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"decompose": {
"command": "uvx",
"args": [
"decompose-mcp"
]
}
}
}Install Decompose MCP in VS Code
.vscode/mcp.json
{
"servers": {
"decompose": {
"type": "stdio",
"command": "uvx",
"args": [
"decompose-mcp"
]
}
}
}Install Decompose MCP in VS Code CLI
$ code --add-mcp '{"name":"decompose","type":"stdio","command":"uvx","args":["decompose-mcp"]}'Install Decompose MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"decompose": {
"command": "uvx",
"args": [
"decompose-mcp"
]
}
}
}Install Decompose MCP in Codex
$ codex mcp add decompose -- uvx decompose-mcpInstall Decompose MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.decompose] command = "uvx" args = ["decompose-mcp"]
Install Decompose MCP in Gemini CLI
$ gemini mcp add -s user decompose uvx -- decompose-mcpInstall Decompose MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"decompose": {
"command": "uvx",
"args": [
"decompose-mcp"
]
}
}
}Automated checks
Ran Nov 15, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachableechology-io/decompose is public and reachablegithub.com/echology-io/decompose ↗Pass
- Package names this repository as its sourcedecompose-mcp names echology-io/decompose as sourcepypi.org/project/decompose-mcp/ ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for decompose-mcppypi.org/project/decompose-mcp/ ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-05-24github.com/echology-io/decompose ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from decompose-mcpPass
- No critical advisory in the package or its dependencies29 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubDecompose
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-mcp
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 --compact
Use 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 LLM
What Each Field Means
| Field | Values | What It Tells Your Agent |
|---|---|---|
authority |
mandatory, prohibitive, directive, permissive, conditional, informational | Is this a hard requirement or background? |
risk |
safety_critical, security, compliance, financial, contractual, advisory, informational | How much does this matter? |
type |
requirement, definition, reference, constraint, narrative, data | What kind of content is this? |
irreducible |
true/false | Must this be preserved verbatim? |
attention |
0.0 - 10.0 | How much compute should the agent spend here? |
entities |
standards, codes, regulations | What formal references are cited? |
actionable |
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 analysis
Measure: 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.
Decompose MCP questions
How do I add Decompose MCP to Claude Code?
Run claude mcp add decompose -- uvx decompose-mcp in your terminal. Add --scope user to make it available in every project.
How do I add Decompose MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Does Decompose require an LLM or API key?
No, it runs on pure regex and heuristics, meaning it requires no LLM, no API key, and no GPU.
Can I use it to reduce LLM token costs?
Yes, you can use the built-in filter to keep only high-value units, which typically results in 60-80% token reduction.
What tools are available in the MCP server?
The agent is provided with two tools: decompose_text for any text and decompose_url to fetch and decompose content from a URL.