Shannon Thinking

🚀 shannon-thinking

An MCP server based on Claude Shannon's systematic problem-solving methodology. This server provides a tool to break down complex problems into structured thinking steps, following Shannon's systematic approach through problem definition, mathematical modeling, and practical implementation.

🚀 Quick Start

Claude Shannon, known as the father of information theory, solved complex problems through the following systematic methodology:

1. Problem Definition: stripping the problem to its fundamental elements
2. Constraints: Identify system limitations and boundaries
3. Model Building: Develop a mathematical/theoretical framework
4. Proof/Verification: Validate through formal proof or experimental testing
5. Implementation/Experiment: Design and test practical solutions

This MCP server implements this methodology as a tool to guide systematic problem-solving.

📦 Installation

npm install @modelcontextprotocol/server-shannon-thinking

💻 Usage Examples

Basic Usage

The server provides a single tool named shannonthinking to structure problem-solving thinking steps according to Shannon's methodology.

Each thought must contain:

• The actual content of the thought
• Type (problem_definition/constraints/model/proof/implementation)
• Thought number and an estimate of the total number of thoughts
• Confidence level (uncertainty: 0 - 1)
• Dependencies on previous thoughts
• Explicit assumptions
• Whether another thinking step is needed

Additional features:

• Revision: Thoughts can revise earlier steps as understanding evolves.
• Recheck: Mark steps that need to be revisited for new information.
• Experimental Verification: Support experimental verification combined with formal proof.
• Implementation Notes: Practical constraints and proposed solutions.

const thought = {
  thought: "核心问题可以定义为一个信息流优化的问题",
  thoughtType: "problem_definition",
  thoughtNumber: 1,
  totalThoughts: 5,
  uncertainty: 0.2,
  dependencies: [],
  assumptions: ["系统具有有限容量", "信息流是连续的"],
  nextThoughtNeeded: true,
  // Optional: Mark as a revision of an earlier definition
  isRevision: false,
  // Optional: Indicate that a step needs to be rechecked
  recheckStep: {
    stepToRecheck: "constraints",
    reason: "发现新的容量限制",
    newInformation: "系统显示非线性扩展"
  }
};

// Use the MCP client
const result = await client.callTool("shannonthinking", thought);

✨ Features

• Iterative Problem Solving: Support revision and recheck as understanding evolves.
• Flexible Verification: Combine formal proof with experimental verification.
• Dependency Tracking: Clearly record dependencies on previous steps.
• Assumption Management: Require clear recording of assumptions.
• Confidence Level: Quantify the uncertainty of each step.
• Rich Feedback: Formatted console output with color coding, symbols, and verification results.

🔧 Technical Details

# Install dependencies
npm install

# Build
npm run build

# Run tests
npm test

# Development mode
npm run watch

📚 Documentation

The tool accepts thoughts with the following structure:

interface ShannonThought {
  thought: string;
  thoughtType: "problem_definition" | "constraints" | "model" | "proof" | "implementation";
  thoughtNumber: number;
  totalThoughts: number;
  uncertainty: number; // 0-1
  dependencies: number[];
  assumptions: string[];
  nextThoughtNeeded: boolean;
  
  // Optional revision field
  isRevision?: boolean;
  revisesThought?: number;
  
  // Optional recheck field
  recheckStep?: {
    stepToRecheck: ThoughtType;
    reason: string;
    newInformation?: string;
  };
  
  // Optional verification field
  proofElements?: {
    hypothesis: string;
    validation: string;
  };
  experimentalElements?: {
    testDescription: string;
    results: string;
    confidence: number; // 0-1
    limitations: string[];
  };
  
  // Optional implementation field
  implementationNotes?: {
    practicalConstraints: string[];
    proposedSolution: string;
  };
}

Use Cases

This tool is particularly useful in the following scenarios:

• Complex system analysis
• Information processing problems
• Engineering design challenges
• Problems requiring a theoretical framework
• Optimization problems
• Systems requiring practical implementation
• Problems requiring iterative refinement
• Situations where experimental verification complements theory

📄 License

MIT