Skip to main content
Glama
tractatus_thinking

tractatus_thinking

by Andreymi

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

MCP Compatible TypeScript Tests Coverage npm version npm downloads

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.

Related MCP server: Sequential Thinking Multi-Agent System

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.

Available Tools

1 tool
tractatus_thinkingA

A powerful tool for logical concept analysis and structured thinking.

This tool helps you break down complex ideas into their fundamental components, revealing the logical structure beneath. Each component can be analyzed, refined, and reorganized as your understanding deepens.

When to use this tool:

  • Breaking down complex concepts into atomic truths

  • Understanding with room for restructuring

  • Analysis where bundled ideas hide the real problem

  • Concepts where the logical structure isn't clear initially

  • Problems that require multiplicative understanding

  • Tasks that need to separate essential from accidental

  • Situations where fuzzy definitions cause confusion

Key features:

  • You can restructure propositions as understanding evolves

  • You can separate bundled concepts at any level

  • You can reveal dependencies between propositions

  • You can express logical relationships precisely

  • Not every proposition needs to decompose further - some are atomic

  • Discovers multiplicative relationships (A × B × C)

  • Reveals what must ALL be true simultaneously

  • Shows the logical architecture beneath surface complexity

  • Provides structural clarity

Benchmark insights - This tool excels at:

  • Revealing multiplicative failures (why ALL factors must align for success)

  • Creating precise definitions that eliminate team confusion

  • Finding the ONE missing element preventing success

  • Understanding logical necessity vs mere correlation

  • Decomposing fuzzy concepts into measurable components

  • Showing WHY things work, not just HOW they work

Strategic sequencing (proven in benchmarks):

  • Use THIS FIRST to understand WHAT you're dealing with

  • Then apply process thinking for HOW to proceed

  • Return here to formalize and verify your solution structure

Complementary to sequential thinking:

  • This tool analyzes WHAT (structure/logic) while sequential thinking handles HOW (process/steps)

  • Start here for conceptual clarity, switch to sequential for implementation planning

  • Together they form a complete thinking system: structure → process → verification

You should:

  1. Start here when concepts feel fuzzy or bundled - structure guides process

  2. Use this BEFORE planning implementation - understanding WHAT enables HOW

  3. Look for multiplicative relationships (A × B × C) that explain persistent failures

  4. Separate what MUST be true from what HAPPENS to be true

  5. Mark propositions that are truly atomic and cannot decompose further

  6. Identify which factors must ALL be present vs which are additive

  7. Generate the logical structure progressively as patterns emerge

  8. Verify you've found the real dependencies, not just correlations

  9. Refine the hierarchy when you discover hidden relationships

  10. Provide structural insight that explains WHY, not just WHAT

  11. Switch to process thinking once structure is clear, return here to verify

Operations: start (reveal structure), add (build understanding), analyze (check completeness), export (capture insights), navigate (explore relationships), revise (refine), undo (reconsider), move (restructure).

Inputs: operation (required), style, format, target, +19 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 1 tool

    Disambiguation5/5

    With only one tool, there is no possibility of confusion or overlap. The tool's purpose is singular, and its description, while broad, does not create ambiguity between different tools.

    Naming Consistency5/5

    A single tool name 'tractatus_thinking' follows a clear snake_case convention and is self-consistent. There are no other tool names to conflict with, so naming consistency is perfect.

    Tool Count1/5

    The server exposes only one tool, yet the description references numerous distinct operations (start, add, analyze, export, navigate, revise, undo, move). This is an extreme mismatch between the claimed functionality and the actual API surface, making the tool count severely inadequate.

    Completeness1/5

    The tool's description promises a rich set of capabilities for logical analysis and restructuring, but these are all bundled into a single tool with no separate callable functions. Agents cannot directly invoke specific operations, and the surface is severely incomplete relative to the described domain.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      C
      quality
      D
      maintenance
      An MCP server implementing the Unified Cognitive Processing Framework for advanced problem-solving, creative thinking, and cognitive analysis through structured tools for knowledge mapping, recursive questioning, and perspective generation.
      3
      16
      -
    • F
      license
      A
      quality
      C
      maintenance
      An advanced MCP server that implements sophisticated sequential thinking using a coordinated team of specialized AI agents (Planner, Researcher, Analyzer, Critic, Synthesizer) to deeply analyze problems and provide high-quality, structured reasoning.
      1
      307
      -
    • A
      license
      A
      quality
      C
      maintenance
      An MCP server that provides a multidimensional philosophical framework for prompt engineering by mapping intent across ten distinct branches of thought. It generates a principled construction basis, including active constructs and spectrum tensions, to guide the creation of structured and intentional prompts.
      4
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      An MCP server that structures AI reasoning as directed acyclic graphs of semantic thoughts, enabling explicit dependencies, assumption tracking, and cascade invalidation for transparent decision-making.
      7 npm
      5
      MIT