mojo-sequential by Mojo-Solo - MCP Server

Sequential Thinking MCP Server

A Model Context Protocol (MCP) server that facilitates structured, progressive thinking through defined stages. This tool helps break down complex problems into sequential thoughts, track the progression of your thinking process, and generate summaries.

Features

Structured Thinking Framework: Organizes thoughts through standard cognitive stages (Problem Definition, Research, Analysis, Synthesis, Conclusion)
Thought Tracking: Records and manages sequential thoughts with metadata
Related Thought Analysis: Identifies connections between similar thoughts
Progress Monitoring: Tracks your position in the overall thinking sequence
Summary Generation: Creates concise overviews of the entire thought process
Persistent Storage: Automatically saves your thinking sessions with thread-safety
Data Import/Export: Share and reuse thinking sessions
Extensible Architecture: Easily customize and extend functionality
Robust Error Handling: Graceful handling of edge cases and corrupted data
Type Safety: Comprehensive type annotations and validation

Prerequisites

Python 3.10 or higher
UV package manager (Install Guide)

Key Technologies

Pydantic: For data validation and serialization
Portalocker: For thread-safe file access
FastMCP: For Model Context Protocol integration
Rich: For enhanced console output
PyYAML: For configuration management

Project Structure

mcp-sequential-thinking/
├── mcp_sequential_thinking/
│   ├── server.py       # Main server implementation and MCP tools
│   ├── models.py       # Data models with Pydantic validation
│   ├── storage.py      # Thread-safe persistence layer
│   ├── storage_utils.py # Shared utilities for storage operations
│   ├── analysis.py     # Thought analysis and pattern detection
│   ├── testing.py      # Test utilities and helper functions
│   ├── utils.py        # Common utilities and helper functions
│   ├── logging_conf.py # Centralized logging configuration
│   └── __init__.py     # Package initialization
├── tests/              
│   ├── test_analysis.py # Tests for analysis functionality
│   ├── test_models.py   # Tests for data models
│   ├── test_storage.py  # Tests for persistence layer
│   └── __init__.py
├── run_server.py       # Server entry point script
├── debug_mcp_connection.py # Utility for debugging connections
├── README.md           # Main documentation
├── CHANGELOG.md        # Version history and changes
├── example.md          # Customization examples
├── LICENSE             # MIT License
└── pyproject.toml      # Project configuration and dependencies

Quick Start

Set Up Project

# Create and activate virtual environment
uv venv
.venv\Scripts\activate  # Windows
source .venv/bin/activate  # Unix

# Install package and dependencies
uv pip install -e .

# For development with testing tools
uv pip install -e ".[dev]"

# For all optional dependencies
uv pip install -e ".[all]"

Run the Server

# Run directly
uv run -m mcp_sequential_thinking.server

# Or use the installed script
mcp-sequential-thinking

Run Tests

# Run all tests
pytest

# Run with coverage report
pytest --cov=mcp_sequential_thinking

Claude Desktop Integration

Add to your Claude Desktop configuration (%APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "uv",
      "args": [
        "--directory",
        "C:\\path\\to\\your\\mcp-sequential-thinking\\run_server.py",
        "run",
        "server.py"
        ]
      }
    }
  }

Alternatively, if you've installed the package with pip install -e ., you can use:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "mcp-sequential-thinking"
    }
  }
}

You can also run it directly using uvx and skipping the installation step:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/arben-adm/mcp-sequential-thinking",
        "--with",
        "portalocker",
        "mcp-sequential-thinking"
      ]
    }
  }
}

How It Works

The server maintains a history of thoughts and processes them through a structured workflow. Each thought is validated using Pydantic models, categorized into thinking stages, and stored with relevant metadata in a thread-safe storage system. The server automatically handles data persistence, backup creation, and provides tools for analyzing relationships between thoughts.

Usage Guide

The Sequential Thinking server exposes three main tools:

1. `process_thought`

Records and analyzes a new thought in your sequential thinking process.

Parameters:

thought (string): The content of your thought
thought_number (integer): Position in your sequence (e.g., 1 for first thought)
total_thoughts (integer): Expected total thoughts in the sequence
next_thought_needed (boolean): Whether more thoughts are needed after this one
stage (string): The thinking stage - must be one of:
- "Problem Definition"
- "Research"
- "Analysis"
- "Synthesis"
- "Conclusion"
tags (list of strings, optional): Keywords or categories for your thought
axioms_used (list of strings, optional): Principles or axioms applied in your thought
assumptions_challenged (list of strings, optional): Assumptions your thought questions or challenges

Example:

# First thought in a 5-thought sequence
process_thought(
    thought="The problem of climate change requires analysis of multiple factors including emissions, policy, and technology adoption.",
    thought_number=1,
    total_thoughts=5,
    next_thought_needed=True,
    stage="Problem Definition",
    tags=["climate", "global policy", "systems thinking"],
    axioms_used=["Complex problems require multifaceted solutions"],
    assumptions_challenged=["Technology alone can solve climate change"]
)

2. `generate_summary`

Generates a summary of your entire thinking process.

Example output:

{
  "summary": {
    "totalThoughts": 5,
    "stages": {
      "Problem Definition": 1,
      "Research": 1,
      "Analysis": 1,
      "Synthesis": 1,
      "Conclusion": 1
    },
    "timeline": [
      {"number": 1, "stage": "Problem Definition"},
      {"number": 2, "stage": "Research"},
      {"number": 3, "stage": "Analysis"},
      {"number": 4, "stage": "Synthesis"},
      {"number": 5, "stage": "Conclusion"}
    ]
  }
}

3. `clear_history`

Resets the thinking process by clearing all recorded thoughts.

Practical Applications

Decision Making: Work through important decisions methodically
Problem Solving: Break complex problems into manageable components
Research Planning: Structure your research approach with clear stages
Writing Organization: Develop ideas progressively before writing
Project Analysis: Evaluate projects through defined analytical stages

Getting Started

With the proper MCP setup, simply use the process_thought tool to begin working through your thoughts in sequence. As you progress, you can get an overview with generate_summary and reset when needed with clear_history.

Customizing the Sequential Thinking Server

For detailed examples of how to customize and extend the Sequential Thinking server, see . It includes code samples for:

Modifying thinking stages
Enhancing thought data structures with Pydantic
Adding persistence with databases
Implementing enhanced analysis with NLP
Creating custom prompts
Setting up advanced configurations
Building web UI integrations
Implementing visualization tools
Connecting to external services
Creating collaborative environments
Separating test code
Building reusable utilities

License

MIT License