If you use sequential-thinking MCP, you know the power of structured reasoning. But sequential thinking shows you HOW to solve problems step-by-step. Tractatus-Thinking shows you WHAT you're actually dealing with.
Logical concept analysis through structured decomposition
A Model Context Protocol (MCP) server that breaks down complex concepts into their fundamental logical components. Based on Wittgenstein's Tractatus method, it helps AI assistants analyze ideas systematically through hierarchical propositions.
| Sequential-Thinking | Tractatus-Thinking |
|---|---|
| Reveals the process | Reveals the structure |
| Shows HOW to do something | Shows WHAT something IS |
| Linear chain of steps | Hierarchical tree of concepts |
| "First do A, then B, then C" | "A requires (B AND C AND D)" |
| Great for execution | Great for understanding |
| Finds the path forward | Finds hidden requirements |
- Use Tractatus FIRST to understand what you're dealing with - uncover all the hidden requirements and dependencies
- Then use Sequential to plan how to address each requirement systematically
- Together: Complete understanding + perfect execution
Question: "How do I make my startup successful?"
Sequential-Thinking gives you:
1. Identify a problem
2. Build an MVP
3. Find customers
4. Iterate based on feedback
5. Scale when ready
Tractatus-Thinking reveals:
Success = (Value Creation × Market Fit × Execution)
- If ANY factor is zero, success is zero
- Sequential thinking might perfect your execution (steps 1-5)
- But miss that your market doesn't actually exist
This is what sequential-thinking CAN'T do - reveal the multiplicative nature of requirements where missing ANY single factor guarantees failure, no matter how well you execute the steps.
Break through confused thinking - When ideas feel tangled or definitions seem circular, Tractatus reveals the hidden structure beneath, showing you exactly how concepts relate to each other.
Find what's really required - Discover the difference between what must be true (multiplicative requirements) and what just happens to be common (additive features). This clarity transforms decision-making.
Build precise understanding - Move beyond vague intuitions to exact definitions. Perfect for technical documentation, system design, and anywhere precision matters.
When we think in natural language, we unconsciously bundle multiple ideas together: "Good code is clean, maintainable, and scalable." But what exactly makes code "clean"? How does cleanliness relate to maintainability? Are they always connected?
This tool forces you to decompose bundled thoughts into atomic propositions, revealing:
- Hidden assumptions you didn't know you were making
- Logical dependencies between concepts
- Structural relationships that natural language conceals
- Precise definitions instead of vague intuitions
New users: See QUICKSTART.md for detailed setup instructions with examples!
git clone https://gitlab.com/CochainComplex/tractatus-thinking.git
cd tractatus_thinking
npm install
npm run buildnpm install -g tractatus_thinkingUse directly in Claude Desktop config without installing (see step 2)
Find your config file:
- Mac:
~/Library/Application Support/Claude/claude_desktop_config.json - Windows:
%APPDATA%\Claude\claude_desktop_config.json - Linux:
~/.config/Claude/claude_desktop_config.json
Add the appropriate configuration:
For Source Build (Option A):
{
"mcpServers": {
"tractatus_thinking": {
"command": "node",
"args": ["/absolute/path/to/tractatus_thinking/dist/index.js"]
}
}
}For NPM Global (Option B):
{
"mcpServers": {
"tractatus_thinking": {
"command": "tractatus_thinking"
}
}
}For NPX (Option C - no install needed):
{
"mcpServers": {
"tractatus_thinking": {
"command": "npx",
"args": ["-y", "tractatus_thinking@latest"]
}
}
}- Fully restart Claude Desktop
- Look for the plug icon in the input area
- Start analyzing:
"Use Tractatus thinking to analyze what makes code maintainable"
"Help me understand the concept of technical debt using Tractatus"
"Break down what artificial intelligence really is"
Need help? Check QUICKSTART.md for troubleshooting and more examples!
Tractatus Thinking transforms vague concepts into precise logical structures. Instead of circular definitions and bundled ideas, you get:
- Atomic propositions - Each idea expressed as a single, clear statement
- Logical hierarchy - Numbered structure showing exact relationships (1, 1.1, 1.11)
- Hidden dependencies - Reveals which factors must ALL be true vs optional additions
- Precise definitions - No more "you know what I mean" - everything explicit
Natural Thinking produces: Team, funding, market fit, timing, execution...
Tractatus Thinking reveals:
1. Startup success requires value creation
1.1 Value emerges from solving real problems
1.2 Problems must affect enough people
1.3 Solutions must be technically feasible
2. Startup success requires market fit
2.1 Product capabilities match user needs
2.2 Pricing matches perceived value
3. Startup success requires execution capability
3.1 Team can build the solution
3.2 Resources sustain operations
Notice how Tractatus separates three independent requirements (multiplication, not addition) - missing any one means failure, which natural language obscures.
Natural Thinking produces: Awareness, sentience, self-awareness, subjective experience, the "hard problem"...
Tractatus Thinking reveals:
1. Consciousness is subjective experience
1.1 Experience has qualitative properties (qualia)
1.11 Qualia are private and directly known
1.12 Qualia cannot be reduced to physical description
1.2 Experience requires a subject who experiences
1.21 Subject persists through time
1.22 Subject integrates multiple experiences
2. Consciousness exhibits intentionality
2.1 Mental states are about something
2.2 Aboutness creates subject-object relationship
3. Consciousness enables self-awareness
3.1 System can model itself
3.2 Model influences system behavior
This reveals consciousness isn't one thing but THREE distinct phenomena often conflated. The analysis stops at 1.12 because further decomposition hits philosophical silence boundaries - what Wittgenstein called "whereof one cannot speak."
You: "Use Tractatus to analyze what makes code maintainable"
Claude: Starting Tractatus analysis...
1. Maintainable code enables efficient modification
1.1 Modifications require understanding existing code
1.2 Understanding requires clear structure
1.3 Clear structure emerges from consistent patterns
2. Maintainable code minimizes change impact
2.1 Changes isolated through loose coupling
2.2 Dependencies made explicit
You: "Help me understand what makes a good API using Tractatus thinking"
Claude: Let's build this together. What's your first insight about good APIs?
You: "They should be easy to use"
Claude: Added as proposition 1. But "easy to use" bundles multiple concepts.
Can you identify what specifically makes an API easy to use?
You: "Clear naming and consistent patterns"
Claude: Excellent! I'll add these as:
1.1 Clear naming reveals intent
1.2 Consistent patterns reduce cognitive load
# Install dependencies
npm install
# Run in development mode
npm run dev
# Build for production
npm run build
# Run tests
npm test # All 218 tests
npm run test:coverage # With coverage report (67%)
# Type checking
npm run typecheck
# Linting
npm run lintThe tractatus_thinking tool supports these operations:
- start - Begin analyzing a concept
- add - Add propositions to the logical structure
- navigate - Move through the proposition tree
- analyze - Check structure completeness
- export - Export analysis (markdown/json)
- revise - Update proposition content
- move - Restructure propositions
- Tractatus Structure: Propositions numbered 1, 1.1, 1.11 (not 1.1.1)
- Atomic Thoughts: Each proposition expresses exactly one idea
- Logical Independence: Sibling propositions are independent
- Silence Boundaries: Stops at metaphysical/ethical limits
tractatus_thinking/
├── src/ # TypeScript source
│ ├── tractatus/ # Core engine
│ ├── handlers/ # MCP handlers
│ ├── utils/ # Utilities
│ └── index.ts # Entry point
├── tests/ # Test suite (218 tests)
├── dist/ # Built output
└── package.json # Dependencies
- Node.js 18+
- npm 9+
Based on Ludwig Wittgenstein's "Tractatus Logico-Philosophicus" (1921), this tool implements a hierarchical proposition system where complex ideas decompose into atomic truths. The method respects philosophical boundaries - stopping at metaphysical limits where "one must be silent."
MIT License - see LICENSE file for details.
- Ludwig Wittgenstein for the Tractatus Logico-Philosophicus
- The Model Context Protocol team
- Contributors to this implementation
- Inspired by the discovery of structured thinking's power with AI by u/Ok_Pound_176 🎯
A production-ready philosophical thinking tool for the age of AI reasoning.
MIT License - Copyright (c) 2025 Alexander Warth
See LICENSE file for details.