deepthinking-mcp 6.1.1 → 7.4.0

package/README.md

@@ -4,11 +4,17 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-green.svg)](https://modelcontextprotocol.io)
 
-A comprehensive Model Context Protocol (MCP) server featuring **21 advanced reasoning modes** including meta-reasoning for strategic oversight, with intelligent mode recommendation, taxonomy-based classification, enterprise security, and production-ready features for complex problem-solving, analysis, and decision-making.
+A comprehensive Model Context Protocol (MCP) server featuring **33 reasoning modes** (29 with dedicated thought types, 4 advanced runtime modes) including meta-reasoning for strategic oversight, with intelligent mode recommendation, taxonomy-based classification, enterprise security, and production-ready features for complex problem-solving, analysis, and decision-making.
 
-> 📋 **Latest Release**: v6.0.0 - See [CHANGELOG](CHANGELOG.md) for updates and improvements.
+> 📋 **Latest Release**: v7.4.0 - See [CHANGELOG](CHANGELOG.md) for updates and improvements.
 >
-> 🎉 **New in v6.0.0**: Meta-Reasoning mode for strategic oversight! Monitor reasoning effectiveness, get adaptive mode-switching recommendations, and assess quality metrics across 6 dimensions.
+> 🎉 **New in v7.4.0**: Phase 13 Academic Research Modes for PhD students! Synthesis (literature review), Argumentation (Toulmin model), Critique (peer review), and Analysis (qualitative methods) modes.
+>
+> ✨ **v7.3.0**: Phase 12 Algorithmic Reasoning Mode with comprehensive CLRS coverage! 100+ named algorithms, complexity analysis, design patterns.
+>
+> ✨ **v7.2.0**: Phase 11 Historical Computing Extensions! Computability mode (Turing machines), Cryptanalytic mode (deciban evidence system), extended Game Theory (von Neumann).
+>
+> ✨ **v7.0.0**: Phase 8 Proof Decomposition System with native SVG export! Break proofs into atomic statements, detect gaps and implicit assumptions, track assumption chains.
 
 ## Table of Contents
 
@@ -16,6 +22,7 @@ A comprehensive Model Context Protocol (MCP) server featuring **21 advanced reas
 - [Installation](#installation)
 - [Quick Start](#quick-start)
 - [Reasoning Modes](#reasoning-modes)
+- [Proof Decomposition](#proof-decomposition)
 - [Usage Examples](#usage-examples)
 - [Production Features](#production-features)
 - [API Documentation](#api-documentation)
@@ -24,12 +31,17 @@ A comprehensive Model Context Protocol (MCP) server featuring **21 advanced reas
 
 ## Features
 
-- **21 Specialized Reasoning Modes** - From sequential thinking to game theory, formal logic, and meta-reasoning
-- **Meta-Reasoning (NEW!)** - Strategic oversight that monitors effectiveness, recommends mode switches, and assesses quality
+- **33 Specialized Reasoning Modes** - From sequential thinking to game theory, formal logic, and meta-reasoning (29 with full thought types, 4 advanced runtime modes)
+- **Academic Research Modes (NEW!)** - Synthesis (literature review), Argumentation (Toulmin), Critique (peer review), Analysis (qualitative methods)
+- **Algorithmic Reasoning (v7.3.0)** - Comprehensive CLRS coverage with 100+ named algorithms, complexity analysis, design patterns
+- **Historical Computing Extensions** - Computability (Turing machines), Cryptanalytic (decibans), extended Game Theory (von Neumann)
+- **Proof Decomposition** - Break proofs into atomic statements, detect gaps, track assumption chains
+- **Native SVG Export** - Direct SVG generation without external tools for proof visualizations
+- **Meta-Reasoning** - Strategic oversight that monitors effectiveness, recommends mode switches, and assesses quality
 - **Adaptive Mode Switching** - Automatic evaluation-based mode switching when effectiveness drops below thresholds
 - **Intelligent Mode Recommendation** - Automatic mode selection based on problem characteristics
-- **Taxonomy Classifier** - 110+ reasoning types across 12 categories for intelligent task classification
-- **Visual Exports** - Generate Mermaid diagrams, DOT graphs, ASCII art, and LaTeX documents with meta-insights
+- **Taxonomy Classifier** - 69 reasoning types across 12 categories for intelligent task classification (110 planned)
+- **Visual Exports** - Generate Mermaid diagrams, DOT graphs, ASCII art, SVG graphics, and LaTeX documents
 - **Production-Ready** - Search engine, templates, batch processing, caching, backup/restore
 - **Enterprise Security** - Input validation (Zod), rate limiting, path sanitization, PII redaction
 - **High Performance** - LRU caching with auto-eviction, async I/O, 4-5x validation speedups
@@ -49,7 +61,7 @@ npm install deepthinking-mcp
 ### From Source
 
 ```bash
-git clone https://github.com/yourusername/deepthinking-mcp.git
+git clone https://github.com/danielsimonjr/deepthinking-mcp.git
 cd deepthinking-mcp
 npm install
 npm run build
@@ -72,43 +84,89 @@ Add to your MCP settings file:
 
 ## Quick Start
 
-### Basic Usage
-
-```typescript
-import { DeepThinkingServer } from 'deepthinking-mcp';
+### MCP Tool Usage
 
-const server = new DeepThinkingServer();
+DeepThinking MCP provides 10 focused tools for different reasoning domains:
 
-// Start a sequential reasoning session
-const session = await server.startThinking({
-  mode: 'sequential',
-  problem: 'Analyze the scalability challenges of a distributed system'
-});
+| Tool | Modes | Description |
+|------|-------|-------------|
+| `deepthinking_core` | inductive, deductive, abductive | Fundamental reasoning |
+| `deepthinking_standard` | sequential, shannon, hybrid | Standard workflow modes |
+| `deepthinking_math` | mathematics, physics | Mathematical/scientific reasoning |
+| `deepthinking_temporal` | temporal | Time-based reasoning |
+| `deepthinking_probabilistic` | bayesian, evidential | Probabilistic reasoning |
+| `deepthinking_causal` | causal, counterfactual | Cause-effect analysis |
+| `deepthinking_strategic` | gametheory, optimization | Strategic reasoning |
+| `deepthinking_analytical` | analogical, firstprinciples, metareasoning | Analytical reasoning |
+| `deepthinking_scientific` | scientificmethod, systemsthinking, formallogic | Scientific reasoning |
+| `deepthinking_session` | - | Session management (summarize, export, switch_mode) |
 
-// Add thoughts iteratively
-await server.addThought(session.id, {
-  content: 'First, identify the main bottlenecks...'
-});
+### Example: Sequential Reasoning
 
-// Export results
-const markdown = await server.exportSession(session.id, 'markdown');
+```json
+{
+  "tool": "deepthinking_standard",
+  "arguments": {
+    "mode": "sequential",
+    "thought": "First, identify the main bottlenecks in the distributed system",
+    "thoughtNumber": 1,
+    "totalThoughts": 5,
+    "nextThoughtNeeded": true
+  }
+}
 ```
 
-### MCP Tool Usage
+### Example: Causal Analysis
 
-```typescript
-// Use via MCP protocol
+```json
 {
-  "tool": "start_thinking",
+  "tool": "deepthinking_causal",
   "arguments": {
     "mode": "causal",
-    "problem": "What caused the service outage?"
+    "thought": "Analyzing the root cause of the service outage",
+    "thoughtNumber": 1,
+    "totalThoughts": 3,
+    "nextThoughtNeeded": true,
+    "causalGraph": {
+      "nodes": [
+        {"id": "n1", "name": "High Load", "type": "cause"},
+        {"id": "n2", "name": "Memory Exhaustion", "type": "mediator"},
+        {"id": "n3", "name": "Service Crash", "type": "effect"}
+      ],
+      "edges": [
+        {"from": "n1", "to": "n2", "strength": 0.9},
+        {"from": "n2", "to": "n3", "strength": 0.95}
+      ]
+    }
+  }
+}
+```
+
+### Example: Session Export
+
+```json
+{
+  "tool": "deepthinking_session",
+  "arguments": {
+    "action": "export",
+    "sessionId": "session-123",
+    "exportFormat": "markdown"
   }
 }
 ```
 
 ## Reasoning Modes
 
+The server supports 33 reasoning modes organized into categories:
+
+- **Core Modes (5)**: Sequential, Shannon, Mathematics, Physics, Hybrid
+- **Historical Computing (2)**: Computability (Turing), Cryptanalytic (Turing) - *v7.2.0*
+- **Algorithmic (1)**: Algorithmic (CLRS) - *v7.3.0*
+- **Academic Research (4)**: Synthesis, Argumentation, Critique, Analysis - *v7.4.0*
+- **Advanced Runtime Modes (6)**: Metareasoning, Recursive, Modal, Stochastic, Constraint, Optimization
+- **Fundamental Modes (2)**: Inductive, Deductive
+- **Experimental Modes (13)**: Abductive, Causal, Bayesian, Counterfactual, Analogical, Temporal, Game Theory (+ von Neumann extensions), Evidential, First Principles, Systems Thinking, Scientific Method, Formal Logic, Engineering
+
 ### Core Modes
 
 #### Sequential
@@ -227,7 +285,7 @@ mode: 'first-principles'
 // Use for: Fundamental analysis, conceptual understanding, basic truths
 ```
 
-#### Meta-Reasoning ⭐ NEW
+#### Meta-Reasoning
 Strategic oversight of reasoning process - monitors effectiveness, recommends mode switches, assesses quality.
 
 ```typescript
@@ -271,334 +329,496 @@ mode: 'formal-logic'
 // Use for: Proof verification, logical analysis, formal methods
 ```
 
-## Usage Examples
+### Advanced Runtime Modes
 
-### Example 1: Debugging with Abductive Reasoning
+#### Recursive
+Recursive problem decomposition - break complex problems into smaller subproblems.
 
 ```typescript
-const session = await server.startThinking({
-  mode: 'abductive',
-  problem: 'Users report intermittent 500 errors on checkout'
-});
-
-await server.addThought(session.id, {
-  content: 'Observed: Errors occur during high traffic periods',
-  type: 'observation'
-});
+mode: 'recursive'
+// Use for: Divide-and-conquer, tree-structured problems, recursive algorithms
+```
 
-await server.addThought(session.id, {
-  content: 'Hypothesis 1: Database connection pool exhaustion',
-  type: 'hypothesis',
-  likelihood: 0.8
-});
+#### Modal
+Possibility and necessity reasoning using modal logic.
 
-const analysis = await server.analyzeSession(session.id);
-// Returns ranked hypotheses with supporting evidence
+```typescript
+mode: 'modal'
+// Use for: What's possible vs necessary, requirement analysis, constraint exploration
 ```
 
-### Example 2: Impact Analysis with Causal Reasoning
+#### Stochastic
+Probabilistic state transitions and Markov chain reasoning.
 
 ```typescript
-const session = await server.startThinking({
-  mode: 'causal',
-  problem: 'Impact of increasing API rate limits'
-});
+mode: 'stochastic'
+// Use for: Process modeling, state machines, probabilistic sequences
+```
 
-await server.addThought(session.id, {
-  content: 'Build causal graph',
-  causalGraph: {
-    nodes: ['rate_limit', 'server_load', 'response_time', 'user_satisfaction'],
-    edges: [
-      { from: 'rate_limit', to: 'server_load', strength: 0.9 },
-      { from: 'server_load', to: 'response_time', strength: 0.85 }
-    ]
-  }
-});
+#### Constraint
+Constraint satisfaction problem solving.
 
-const intervention = await server.analyzeIntervention(session.id, {
-  variable: 'rate_limit',
-  change: '+50%'
-});
-// Returns predicted effects on downstream variables
+```typescript
+mode: 'constraint'
+// Use for: Scheduling, resource allocation, constraint propagation
 ```
 
-### Example 3: Strategic Analysis with Game Theory
+### Fundamental Modes
+
+#### Inductive
+Reasoning from specific observations to general principles.
 
 ```typescript
-const session = await server.startThinking({
-  mode: 'game-theory',
-  problem: 'Pricing strategy in competitive market'
-});
+mode: 'inductive'
+// Use for: Pattern recognition, generalization, empirical reasoning
+```
 
-await server.addThought(session.id, {
-  content: 'Define game structure',
-  game: {
-    players: ['us', 'competitor'],
-    strategies: {
-      us: ['premium', 'competitive', 'discount'],
-      competitor: ['premium', 'competitive', 'discount']
-    },
-    payoffs: {
-      // Payoff matrix for each strategy combination
-    }
-  }
-});
+#### Deductive
+Reasoning from general principles to specific conclusions.
 
-const equilibria = await server.findNashEquilibria(session.id);
-// Returns Nash equilibria and dominant strategies
+```typescript
+mode: 'deductive'
+// Use for: Logical proofs, applying rules, deriving conclusions
 ```
 
-## Production Features
+### Historical Computing Modes (v7.2.0)
 
-### Search Engine
+Tributes to Alan Turing and John von Neumann's foundational work.
 
-Full-text search with faceted filtering, autocomplete, and relevance ranking.
+#### Computability
+Turing machines, decidability proofs, reductions, and diagonalization arguments.
 
 ```typescript
-const results = await server.search({
-  query: 'machine learning optimization',
-  facets: ['mode', 'tags'],
-  filters: {
-    modes: ['optimization', 'mathematics'],
-    dateRange: { from: new Date('2024-01-01') }
-  }
-});
+mode: 'computability'
+// Use for: Decidability analysis, algorithm limits, computational complexity
+// Features: Turing machine simulation, reduction chains, halting problem analysis
 ```
 
-### Template System
-
-Pre-built templates for common reasoning patterns.
+#### Cryptanalytic
+Turing's deciban evidence system from Bletchley Park.
 
 ```typescript
-const templates = await server.listTemplates({
-  category: 'problem-solving',
-  difficulty: 'beginner'
-});
-
-const session = await server.instantiateTemplate(templates[0].id, {
-  title: 'My Analysis',
-  context: 'Specific problem details...'
-});
+mode: 'cryptanalytic'
+// Use for: Evidence quantification, hypothesis testing, code-breaking analysis
+// Features: Deciban accumulation (10 db ≈ 10:1 odds), frequency analysis, Banburismus
 ```
 
-### Batch Processing
-
-Process multiple sessions concurrently with job tracking.
+#### Extended Game Theory (v7.2.0)
+Von Neumann's minimax theorem, cooperative games, and Shapley values.
 
 ```typescript
-const jobId = await server.submitBatchJob({
-  type: 'export',
-  sessionIds: ['session-1', 'session-2', 'session-3'],
-  format: 'latex'
-});
-
-const status = await server.getJobStatus(jobId);
+mode: 'gametheory'
+// Enhanced with: Minimax analysis, cooperative game theory, coalition analysis
+// Use for: Zero-sum games, fair value distribution, strategic decision-making
 ```
 
-### Backup & Restore
+### Algorithmic Mode (v7.3.0)
 
-Automated backup with compression and local storage.
+#### Algorithmic
+Comprehensive coverage of algorithms from "Introduction to Algorithms" (CLRS) with 100+ named algorithms.
 
 ```typescript
-const backupManager = new BackupManager({
-  provider: 'local',
-  config: { path: './backups' }
-});
-
-const backupId = await backupManager.backup(session);
-const restored = await backupManager.restore(backupId);
+mode: 'algorithmic'
+// Use for: Algorithm design, complexity analysis, correctness proofs
+// Features: Divide-and-conquer, dynamic programming, greedy, graph algorithms
+// Coverage: Sorting, searching, graph, string, computational geometry
 ```
 
-### Session Comparison
+### Academic Research Modes (v7.4.0)
+
+Designed for PhD students and scientific paper writing.
 
-Compare reasoning sessions to analyze differences and similarities.
+#### Synthesis
+Literature review and knowledge integration.
 
 ```typescript
-const comparison = await server.compareSessions(session1, session2);
+mode: 'synthesis'
+// Use for: Literature reviews, theme extraction, knowledge integration
+// Features: Source synthesis, pattern identification, gap analysis
+```
+
+#### Argumentation
+Academic argumentation using the Toulmin model.
 
-console.log(comparison.similarity); // 0-1 scale
-console.log(comparison.differences); // Detailed diff
-console.log(comparison.metrics); // Quantitative metrics
+```typescript
+mode: 'argumentation'
+// Use for: Building arguments, dialectical reasoning, rhetorical analysis
+// Features: Toulmin model (claim, data, warrant, backing), counter-arguments
 ```
 
-### Security & Validation
+#### Critique
+Critical analysis and peer review frameworks.
 
-Enterprise-grade security features with input validation, rate limiting, and PII protection.
+```typescript
+mode: 'critique'
+// Use for: Peer review, methodology evaluation, evidence assessment
+// Features: Systematic critique, strengths/weaknesses analysis
+```
+
+#### Analysis
+Qualitative analysis methods.
 
 ```typescript
-// Input validation with Zod schemas
-import { validateInput, AddThoughtSchema } from 'deepthinking-mcp/validation';
+mode: 'analysis'
+// Use for: Thematic analysis, grounded theory, discourse analysis
+// Features: Multiple qualitative analysis frameworks, coding support
+```
 
-const validated = validateInput(AddThoughtSchema, userInput);
-// Throws ValidationError if invalid
+## Proof Decomposition
 
-// Rate limiting for API protection
-import { RateLimiter } from 'deepthinking-mcp/rate-limit';
+**New in v7.0.0!** The proof decomposition system provides advanced mathematical reasoning capabilities:
 
-const limiter = new RateLimiter({
-  windowMs: 60000,        // 1 minute window
-  maxRequests: 100,       // 100 requests per window
-  keyPrefix: 'api:'
-});
+### Components
 
-await limiter.checkLimit(userId);  // Throws RateLimitError if exceeded
+| Component | Purpose |
+|-----------|---------|
+| **ProofDecomposer** | Breaks proofs into atomic statements with dependency tracking |
+| **GapAnalyzer** | Detects missing steps, unjustified leaps, and implicit assumptions |
+| **AssumptionTracker** | Traces conclusions back to their supporting assumptions |
+| **InconsistencyDetector** | Detects circular dependencies and contradictions |
+| **MathematicsReasoningEngine** | Integrated proof analysis with improvement suggestions |
 
-// Path sanitization prevents directory traversal
-import { sanitizeFilename, validatePath } from 'deepthinking-mcp/utils';
+### Features
 
-const safeFilename = sanitizeFilename(userInput);  // Removes dangerous characters
-validatePath(targetPath, baseDir);  // Prevents path traversal attacks
+- **Atomic Statement Types**: axiom, hypothesis, definition, derived, lemma, conclusion
+- **Inference Rules**: algebraic_manipulation, substitution, modus_ponens, universal_instantiation, etc.
+- **Gap Detection**: Identify missing steps with severity levels (minor, significant, critical)
+- **Rigor Levels**: informal, textbook, rigorous, formal
+- **Visual Export**: Mermaid, DOT, ASCII, and native SVG formats
 
-// Log sanitization for GDPR compliance
-import { sanitizeForLogging } from 'deepthinking-mcp/utils';
+### Example: Proof Analysis
 
-logger.info('User action', sanitizeForLogging({
-  userId: user.id,
-  email: user.email,  // Will be redacted as [REDACTED]
-  action: 'create_session'
-}));
+```json
+{
+  "tool": "deepthinking_math",
+  "arguments": {
+    "mode": "mathematics",
+    "thought": "Analyzing the proof that n² is even when n is even",
+    "thoughtNumber": 1,
+    "totalThoughts": 3,
+    "nextThoughtNeeded": true,
+    "proofDecomposition": {
+      "theorem": "If n is even, then n² is even",
+      "atoms": [
+        {"id": "a1", "content": "n is an even integer", "type": "hypothesis"},
+        {"id": "a2", "content": "n = 2k for some integer k", "type": "definition"},
+        {"id": "a3", "content": "n² = 4k² = 2(2k²)", "type": "derived"},
+        {"id": "a4", "content": "n² is even", "type": "conclusion"}
+      ],
+      "dependencies": {
+        "nodes": ["a1", "a2", "a3", "a4"],
+        "edges": [
+          {"from": "a1", "to": "a2"},
+          {"from": "a2", "to": "a3"},
+          {"from": "a3", "to": "a4"}
+        ]
+      }
+    }
+  }
+}
 ```
 
-### Taxonomy Classifier
+### Visual Export Formats
 
-Intelligent classification of reasoning tasks using 110+ reasoning types across 12 categories.
+Export proof decompositions to multiple visual formats:
 
 ```typescript
-import { TaxonomyClassifier } from 'deepthinking-mcp/taxonomy';
+// Native SVG (no external tools required)
+exportProofDecomposition(decomposition, {
+  format: 'svg',
+  colorScheme: 'default',  // 'default' | 'pastel' | 'monochrome'
+  includeMetrics: true,
+  svgWidth: 1200,
+  svgHeight: 800
+});
+
+// Mermaid diagram
+exportProofDecomposition(decomposition, { format: 'mermaid' });
 
-const classifier = new TaxonomyClassifier();
+// GraphViz DOT
+exportProofDecomposition(decomposition, { format: 'dot' });
+
+// ASCII text
+exportProofDecomposition(decomposition, { format: 'ascii' });
+```
+
+## Usage Examples
 
-const result = classifier.classify(
-  'How can we prove that the sum of two even numbers is always even?'
-);
+### Example 1: Debugging with Abductive Reasoning
 
-console.log(result.primaryCategory);  // 'deductive'
-console.log(result.primaryType);      // 'Mathematical Proof'
-console.log(result.confidence);       // 0.95
-console.log(result.secondaryTypes);   // ['Formal Logic', 'Theorem Proving']
+```json
+// Step 1: Start with observation
+{
+  "tool": "deepthinking_core",
+  "arguments": {
+    "mode": "abductive",
+    "thought": "Observed: Users report intermittent 500 errors on checkout during high traffic periods",
+    "thoughtNumber": 1,
+    "totalThoughts": 4,
+    "nextThoughtNeeded": true,
+    "observations": ["Errors occur during high traffic", "Checkout page affected", "Intermittent pattern"]
+  }
+}
 
-// Use for automatic mode selection
-const mode = result.primaryType.mode;  // Suggests best reasoning mode
+// Step 2: Generate hypothesis
+{
+  "tool": "deepthinking_core",
+  "arguments": {
+    "sessionId": "session-from-step-1",
+    "mode": "abductive",
+    "thought": "Hypothesis: Database connection pool exhaustion under load",
+    "thoughtNumber": 2,
+    "totalThoughts": 4,
+    "nextThoughtNeeded": true,
+    "hypotheses": [{
+      "id": "h1",
+      "explanation": "Connection pool exhausted",
+      "assumptions": ["Fixed pool size", "No connection recycling"],
+      "predictions": ["Errors correlate with traffic spikes"],
+      "score": 0.8
+    }]
+  }
+}
 ```
 
-## API Documentation
+### Example 2: Impact Analysis with Causal Reasoning
 
-### Core Methods
+```json
+{
+  "tool": "deepthinking_causal",
+  "arguments": {
+    "mode": "causal",
+    "thought": "Analyzing impact of increasing API rate limits on system behavior",
+    "thoughtNumber": 1,
+    "totalThoughts": 3,
+    "nextThoughtNeeded": true,
+    "causalGraph": {
+      "nodes": [
+        {"id": "rate_limit", "name": "Rate Limit", "type": "cause", "description": "API rate limit setting"},
+        {"id": "server_load", "name": "Server Load", "type": "mediator", "description": "CPU/Memory usage"},
+        {"id": "response_time", "name": "Response Time", "type": "effect", "description": "API latency"},
+        {"id": "satisfaction", "name": "User Satisfaction", "type": "effect", "description": "User experience"}
+      ],
+      "edges": [
+        {"from": "rate_limit", "to": "server_load", "strength": 0.9, "confidence": 0.85},
+        {"from": "server_load", "to": "response_time", "strength": 0.85, "confidence": 0.9},
+        {"from": "response_time", "to": "satisfaction", "strength": -0.7, "confidence": 0.8}
+      ]
+    }
+  }
+}
+```
 
-#### `startThinking(options)`
+### Example 3: Strategic Analysis with Game Theory
 
-Start a new thinking session.
+```json
+{
+  "tool": "deepthinking_strategic",
+  "arguments": {
+    "mode": "gametheory",
+    "thought": "Analyzing pricing strategy in competitive market using game theory",
+    "thoughtNumber": 1,
+    "totalThoughts": 3,
+    "nextThoughtNeeded": true,
+    "game": {
+      "type": "strategic",
+      "players": ["Company A", "Company B"],
+      "strategies": {
+        "Company A": ["premium", "competitive", "discount"],
+        "Company B": ["premium", "competitive", "discount"]
+      },
+      "payoffMatrix": [
+        [{"A": 10, "B": 10}, {"A": 5, "B": 15}, {"A": 2, "B": 12}],
+        [{"A": 15, "B": 5}, {"A": 8, "B": 8}, {"A": 4, "B": 10}],
+        [{"A": 12, "B": 2}, {"A": 10, "B": 4}, {"A": 6, "B": 6}]
+      ]
+    }
+  }
+}
+```
 
-**Parameters:**
-- `mode` (string): Reasoning mode to use
-- `problem` (string): Problem description
-- `context?` (object): Additional context
+## Production Features
 
-**Returns:** `Promise<ThinkingSession>`
+> **Note**: DeepThinking MCP is an MCP server, not a library. These features are accessed through MCP tools and internal architecture. The examples below describe the internal capabilities.
 
-#### `addThought(sessionId, thought)`
+### Proof Decomposition (v7.0.0)
 
-Add a thought to an existing session.
+Advanced mathematical reasoning with proof analysis:
 
-**Parameters:**
-- `sessionId` (string): Session identifier
-- `thought` (object): Thought content and metadata
+- **ProofDecomposer**: Break proofs into atomic statements with dependency graphs
+- **GapAnalyzer**: Detect missing steps, unjustified leaps, implicit assumptions
+- **AssumptionTracker**: Trace conclusions to their supporting assumptions
+- **InconsistencyDetector**: Find circular dependencies and contradictions
+- **Native SVG Export**: Generate proof visualizations without external tools
 
-**Returns:** `Promise<Thought>`
+### Search Engine
 
-#### `exportSession(sessionId, format)`
+Full-text search with faceted filtering and relevance ranking. Used internally to search across reasoning sessions by mode, tags, date ranges, and content.
 
-Export session to specified format.
+### Template System
 
-**Parameters:**
-- `sessionId` (string): Session identifier
-- `format` ('markdown' | 'latex' | 'json' | 'mermaid' | 'dot' | 'ascii'): Export format
+Pre-built templates for common reasoning patterns, accessible through session creation.
 
-**Returns:** `Promise<string>`
+### Batch Processing
 
-### Advanced Methods
+Process multiple sessions concurrently with 8 operation types:
 
-#### `recommendMode(problem, characteristics)`
+- **export** - Batch export sessions to various formats
+- **import** - Batch import sessions from files
+- **analyze** - Batch taxonomy/quality/pattern analysis
+- **validate** - Batch session validation
+- **transform** - Batch mode switching, merging, splitting
+- **index** - Batch search/analytics indexing
+- **backup** - Batch backup with compression
+- **cleanup** - Batch cleanup of old/incomplete sessions
 
-Get intelligent mode recommendations.
+### Backup & Restore
 
-**Parameters:**
-- `problem` (string): Problem description
-- `characteristics?` (object): Problem characteristics
+Automated backup with compression and local storage, with support for multiple providers (Local, S3, GCS, Azure).
 
-**Returns:** `Promise<ModeRecommendation[]>`
+### Session Comparison
 
-#### `validateSession(sessionId)`
+Compare reasoning sessions to analyze differences and similarities with quantitative metrics.
 
-Validate session structure and content.
+### Security & Validation
 
-**Parameters:**
-- `sessionId` (string): Session identifier
+Enterprise-grade security features built into the MCP server:
 
-**Returns:** `Promise<ValidationResult>`
+- **Input Validation** - Zod schemas validate all 33 mode inputs
+- **Rate Limiting** - Sliding window rate limiter for API protection
+- **Path Sanitization** - Prevents directory traversal attacks
+- **PII Redaction** - GDPR-compliant log sanitization
 
-For complete API documentation, see [API.md](docs/API.md).
+### Taxonomy Classifier
 
-## Architecture
+Intelligent classification of reasoning tasks using 69 reasoning types across 12 categories. Use the `recommend_mode` action in `deepthinking_session` to get mode recommendations based on problem characteristics.
 
-### Taxonomy System
+## API Documentation
 
-Intelligent reasoning type classification and navigation.
+### MCP Tool Interface
 
-```
-taxonomy/
-├── reasoning-types.ts  # 100+ reasoning type definitions
-├── navigator.ts        # Query and exploration
-├── suggestion-engine.ts # Mode recommendations
-└── adaptive-selector.ts # Dynamic mode selection
-```
+All reasoning is done through MCP tools. Each tool accepts arguments and returns JSON responses.
 
-### Export Formats
+#### Common Parameters (all thinking tools)
 
-Multiple visualization and document formats.
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `sessionId` | string | No | Session ID (auto-created if omitted) |
+| `thought` | string | Yes | The reasoning content |
+| `thoughtNumber` | integer | Yes | Current thought number (1-based) |
+| `totalThoughts` | integer | Yes | Estimated total thoughts |
+| `nextThoughtNeeded` | boolean | Yes | Whether more reasoning needed |
+| `mode` | string | Yes | The reasoning mode |
 
-```
-exports/
-├── latex/      # LaTeX document generation
-├── markdown/   # Markdown formatting
-├── mermaid/    # Mermaid diagrams
-├── dot/        # Graphviz DOT graphs
-└── ascii/      # ASCII art visualizations
-```
+#### Session Actions (`deepthinking_session`)
 
-### Production Systems
+| Action | Parameters | Description |
+|--------|------------|-------------|
+| `summarize` | `sessionId` | Generate session summary |
+| `export` | `sessionId`, `exportFormat` | Export to format (json, markdown, latex, html, jupyter, mermaid, dot, ascii, svg) |
+| `get_session` | `sessionId` | Get session details |
+| `switch_mode` | `sessionId`, `newMode` | Switch reasoning mode |
+| `recommend_mode` | `problemType` or `problemCharacteristics` | Get mode recommendations |
 
-Enterprise-ready features for production deployment.
+#### Example Response
 
+```json
+{
+  "sessionId": "session-abc123",
+  "thoughtId": "thought-xyz789",
+  "thoughtNumber": 1,
+  "mode": "sequential",
+  "nextThoughtNeeded": true,
+  "sessionComplete": false,
+  "totalThoughts": 3
+}
 ```
-production/
-├── search/        # Full-text search with facets & autocomplete
-├── templates/     # Session templates with usage tracking
-├── batch/         # Real batch processing (6 operations implemented)
-├── cache/         # LRU caching with auto-eviction
-├── backup/        # Local backup with compression
-├── comparison/    # Session comparison & similarity analysis
-├── validation/    # Zod-based input validation (8 schemas)
-├── rate-limit/    # Sliding window rate limiter
-└── repositories/  # Repository pattern with FileSessionRepository
+
+For architecture details, see [docs/architecture/](docs/architecture/).
+
+## Project Stats
+
+| Metric | Value |
+|--------|-------|
+| TypeScript Files | 183 |
+| Lines of Code | ~62,000 |
+| Test Files | 40 |
+| Passing Tests | 792+ |
+| Thinking Modes | 33 (29 with thought types) |
+| MCP Tools | 10 focused + 1 legacy |
+| Export Formats | 11 (including native SVG) |
+| Visual Formats | 11 (mermaid, dot, ascii, svg, etc.) |
+| Reasoning Types | 69 (110 planned) |
+| Modules | 16 |
+| Total Exports | 970 |
+
+## Architecture
+
+The codebase is organized into 16 modules with clean separation of concerns. See [docs/architecture/DEPENDENCY_GRAPH.md](docs/architecture/DEPENDENCY_GRAPH.md) for the complete dependency graph.
+
+### Core Structure
+
+```
+src/
+├── index.ts           # MCP server entry point (tool handlers)
+├── types/             # Type definitions including 33 mode types
+│   ├── core.ts        # ThinkingMode enum, Thought union type
+│   └── modes/         # One file per reasoning mode (23 files)
+├── services/          # Business logic layer
+│   ├── ThoughtFactory.ts    # Thought creation and validation
+│   ├── ExportService.ts     # Multi-format export handling
+│   └── ModeRouter.ts        # Mode switching and recommendations
+├── session/           # SessionManager, persistence, storage
+├── modes/             # Advanced reasoning implementations (7 files)
+├── proof/             # Proof decomposition system (v7.0.0)
+│   ├── decomposer.ts        # ProofDecomposer class
+│   ├── gap-analyzer.ts      # GapAnalyzer class
+│   └── assumption-tracker.ts # AssumptionTracker class
+├── reasoning/         # Reasoning engines (v7.0.0)
+│   └── inconsistency-detector.ts  # InconsistencyDetector class
+└── tools/             # MCP tool definitions and schemas
+```
+
+### Feature Modules
+
+```
+src/
+├── taxonomy/          # 69 reasoning types, classifier, suggestion engine
+│   ├── reasoning-types.ts   # Full taxonomy definitions
+│   ├── classifier.ts        # Task classification
+│   └── suggestion-engine.ts # Mode recommendations
+├── export/            # Visual and document exporters
+│   ├── visual/        # 21 mode-specific visual exporters + native SVG
+│   │   ├── proof-decomposition.ts  # Proof visualization (v7.0.0)
+│   │   └── [19 mode exporters]     # Mermaid, DOT, ASCII, SVG
+│   └── latex.ts       # LaTeX document generation
+├── search/            # Full-text search with faceted filtering
+├── batch/             # Batch processing (8 operations)
+├── backup/            # Backup manager with provider abstraction
+├── cache/             # LRU/LFU/FIFO caching strategies
+├── rate-limit/        # Sliding window rate limiter
+├── validation/        # Zod schemas (25+ mode validators)
+├── comparison/        # Session comparison & diff generation
+├── templates/         # Session templates with usage tracking
+├── analytics/         # Analytics engine and dashboard
+├── webhooks/          # Event-driven webhook system
+├── collaboration/     # Annotations and conflict resolution
+└── ml/                # Pattern recognition & recommendations
 ```
 
 ### Security Features
 
-Production-grade security and compliance.
+Security is built into multiple modules:
 
-```
-security/
-├── validation/      # Input validation with Zod schemas
-├── sanitization/    # Path sanitization & traversal prevention
-├── rate-limiting/   # Per-key rate limiting with sliding windows
-├── log-redaction/   # PII redaction for GDPR compliance
-└── error-handling/  # Standardized error hierarchy with context
-```
+- **validation/** - Input validation with Zod schemas for all 33 modes
+- **utils/sanitization.ts** - Path sanitization & traversal prevention
+- **utils/log-sanitizer.ts** - PII redaction for GDPR compliance
+- **rate-limit/** - Per-key rate limiting with sliding windows
+- **utils/errors.ts** - Standardized error hierarchy with context
 
 ## Contributing
 
-We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+We welcome contributions! Please open an issue or pull request on [GitHub](https://github.com/danielsimonjr/deepthinking-mcp).
 
 ### Adding New Reasoning Modes
 
@@ -627,7 +847,7 @@ cat docs/ADDING_NEW_MODE.md
 
 ```bash
 # Clone repository
-git clone https://github.com/yourusername/deepthinking-mcp.git
+git clone https://github.com/danielsimonjr/deepthinking-mcp.git
 cd deepthinking-mcp
 
 # Install dependencies
@@ -669,9 +889,8 @@ MIT License - see [LICENSE](LICENSE) file for details.
 ## Support
 
 - 📚 [Documentation](docs/)
-- 🐛 [Issue Tracker](https://github.com/yourusername/deepthinking-mcp/issues)
-- 💬 [Discussions](https://github.com/yourusername/deepthinking-mcp/discussions)
-- 📧 Email: support@example.com
+- 🐛 [Issue Tracker](https://github.com/danielsimonjr/deepthinking-mcp/issues)
+- 💬 [Discussions](https://github.com/danielsimonjr/deepthinking-mcp/discussions)
 
 ---