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

<p align="center">
  <img src="robot-thinker.gif" alt="Tractatus Thinking - Where AI meets philosophical analysis" width="400">
</p>

[![MCP Compatible](https://img.shields.io/badge/MCP-compatible-blue)](https://modelcontextprotocol.io/)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue)](https://www.typescriptlang.org/)
[![Tests](https://img.shields.io/badge/tests-218%20passing-brightgreen)](./tests)
[![Coverage](https://img.shields.io/badge/coverage-67%25-yellow)](./coverage)
[![npm version](https://badge.fury.io/js/tractatus_thinking.svg)](https://www.npmjs.com/package/tractatus_thinking)
[![npm downloads](https://img.shields.io/npm/dm/tractatus_thinking.svg)](https://www.npmjs.com/package/tractatus_thinking)


## 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](QUICKSTART.md) for detailed setup instructions with examples!**

### 1. Install (Choose One Method)

#### Option A: Build from Source
```bash
git clone https://gitlab.com/CochainComplex/tractatus-thinking.git
cd tractatus_thinking
npm install
npm run build
```

#### Option B: NPM Global
```bash
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):**
```json
{
  "mcpServers": {
    "tractatus_thinking": {
      "command": "node",
      "args": ["/absolute/path/to/tractatus_thinking/dist/index.js"]
    }
  }
}
```

**For NPM Global (Option B):**
```json
{
  "mcpServers": {
    "tractatus_thinking": {
      "command": "tractatus_thinking"
    }
  }
}
```

**For NPX (Option C - no install needed):**
```json
{
  "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](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

```bash
# 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](./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](https://www.reddit.com/r/ChatGPTPro/comments/1k35mdb/i_accidentally_invented_a_new_kind_of_ai_prompt/) 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](LICENSE) file for details.