Tractatus Thinking

Love Sequential-Thinking? You'll Need Tractatus-Thinking Too

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

What is tractatus_thinking?

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.

Why You Need Both:

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

The Power of Combination:

• 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

Real Example:

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.

What Makes Tractatus Powerful?

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.

The Problem with Natural Language

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?

The Tractatus Solution

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

Quick Start

New users: See QUICKSTART.md for detailed setup instructions with examples!

1. Install (Choose One Method)

Option A: Build from Source

git clone https://gitlab.com/CochainComplex/tractatus-thinking.git
cd tractatus_thinking
npm install
npm run build

Option B: NPM Global

npm install -g tractatus_thinking

Option C: NPX (no installation)

Use directly in Claude Desktop config without installing (see step 2)

2. Configure Claude Desktop

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

3. Restart Claude & Use

1. Fully restart Claude Desktop
2. Look for the plug icon in the input area
3. 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!

What It Does

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

Example: "What Makes a Startup Successful?"

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.

Example 2: "What is Consciousness?"

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

Usage Examples

Basic Analysis

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

Interactive Building

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

Development

# 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 lint

Technical Details

MCP Tool Operations

The 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

Philosophical Foundation

Core Principles

• 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

Project Structure

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

WHEN IN DOUBT Requirements

• Node.js 18+
• npm 9+

About the Method

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

License

MIT License - see LICENSE file for details.

Acknowledgments

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

License

MIT License - Copyright (c) 2025 Alexander Warth

See LICENSE file for details.