MindKit 🧠

A Rust library for structured sequential thinking and reasoning patterns for LLMs. MindKit provides a framework-agnostic implementation for organizing thoughts, tracking reasoning processes, and applying different analytical lenses to problems.

Overview

MindKit allows you to integrate structured, reflective reasoning into any MCP (Model Context Protocol) server or other AI application. It's designed to make thinking processes transparent, traceable, and systematic.

Features

• Multiple Thinking Modes: Analytical, Critical, Synthesis, and Validation
• Revision Tracking: Track when thoughts are revised and what they revise
• Branching Thoughts: Create alternate reasoning paths
• Custom Lenses: Apply domain-specific analysis (e.g., "Rust best practices", "security")
• Confidence Levels: Track reasoning confidence (0.0-1.0)
• Visual Feedback: Intuitive emoji indicators for different thought types
• Dynamic Adjustment: Automatically adjusts total thoughts as reasoning expands
• Framework Agnostic: Use with any MCP server implementation

Installation

Add MindKit to your Cargo.toml:

[dependencies]
mindkit = "0.1.0"

Quick Start

use mindkit::{ThinkInput, process_thinking};

// Create a basic analytical thought
let input = ThinkInput {
    thought: "Breaking down this problem into smaller components...".to_string(),
    next_thought_needed: true,
    thought_number: 1,
    total_thoughts: 5,
    thought_type: Some("analytical".to_string()),
    is_revision: None,
    revises_thought: None,
    branch_from_thought: None,
    branch_id: None,
    needs_more_thoughts: None,
    custom_lens: None,
    confidence: None,
};

let result = process_thinking(input);
println!("{}", result.formatted_output);
// Output: 💭 1/5 [analytical] | Breaking down this problem into smaller components...

Thought Types

Analytical (default)

Standard reasoning mode for breaking down problems and exploring ideas.

thought_type: Some("analytical".to_string())  // Icon: 💭

Critical

Actively looks for flaws, assumptions, and potential issues. Automatically adds warnings for detected assumptions, absolute statements, and implicit biases.

thought_type: Some("critical".to_string())  // Icon: 🔍
// Example output: "This will always work [⚠️ ABSOLUTE STATEMENT: Consider edge cases]"

Synthesis

Combines multiple perspectives and ideas into cohesive insights.

thought_type: Some("synthesis".to_string())  // Icon: 🔗

Validation

Verifies conclusions and checks reasoning validity.

thought_type: Some("validation".to_string())  // Icon: ✓

Advanced Features

Revising Previous Thoughts

let revision = ThinkInput {
    thought: "Actually, I need to reconsider my approach...".to_string(),
    next_thought_needed: true,
    thought_number: 3,
    total_thoughts: 5,
    is_revision: Some(true),
    revises_thought: Some(2),  // Revising thought #2
    // ... other fields as None
};
// Output: 🔄 3/5 | Actually, I need to reconsider my approach... ↺#2

Branching Thoughts

let branch = ThinkInput {
    thought: "Alternative approach: what if we tried...".to_string(),
    next_thought_needed: true,
    thought_number: 4,
    total_thoughts: 6,
    branch_from_thought: Some(3),
    branch_id: Some("alt-1".to_string()),
    // ... other fields as None
};
// Output: 🌿 4/6 | Alternative approach: what if we tried... └#3[alt-1]

Custom Analytical Lenses

Apply domain-specific analysis to your thoughts:

let security_lens = ThinkInput {
    thought: "Examining the input validation logic...".to_string(),
    next_thought_needed: true,
    thought_number: 2,
    total_thoughts: 4,
    custom_lens: Some("security".to_string()),
    // ... other fields as None
};
// Output: 🎯 2/4 🔎security | Examining the input validation logic... [🔎 SECURITY: Validate and sanitize all inputs]

Supported lenses include:

• Rust: Adds reminders about ownership, borrowing, and error handling
• Security: Highlights input validation and authentication concerns
• Performance: Points out algorithmic complexity and memory usage
• Custom: Any other lens applies a generic perspective marker

Confidence Tracking

let confident_thought = ThinkInput {
    thought: "Based on the evidence, the solution is clear.".to_string(),
    next_thought_needed: false,
    thought_number: 5,
    total_thoughts: 5,
    confidence: Some(0.95),
    // ... other fields as None
};
// Output: 💭 5/5 95% | Based on the evidence, the solution is clear.

Integration Examples

With FTL SDK

use ftl_sdk::{tool, ToolResponse};
use mindkit::{ThinkInput, process_thinking};

#[tool]
fn sequential_thinking(input: ThinkInput) -> ToolResponse {
    let result = process_thinking(input);
    if result.is_error {
        ToolResponse::error(result.formatted_output)
    } else {
        ToolResponse::text(result.formatted_output)
    }
}

Visual Indicators

The formatted output includes visual indicators for quick understanding:

• 💭 Analytical thinking
• 🔍 Critical analysis
• 🔗 Synthesis of ideas
• ✓ Validation check
• 🔄 Revision of previous thought
• 🌿 Branching to alternate path
• 🎯 Custom lens applied
• (+) Expanding beyond initial estimate
• ↺#N Revising thought number N
• └#N Branching from thought number N

API Reference

Core Types

ThinkInput

The main input structure for the thinking process. All fields except the first four are optional.

ThinkResult

The result of processing a thinking input.

Functions

process_thinking(input: ThinkInput) -> ThinkResult

Main function that processes a thinking input and returns formatted output.

Use Cases

• AI Assistants: Structure reasoning for transparent decision-making
• Problem Solving: Break down complex problems systematically
• Code Review: Apply different analytical lenses to code analysis
• Decision Systems: Track confidence and reasoning paths
• Learning Tools: Make thinking processes visible and traceable
• Debugging: Systematic approach to finding and fixing issues

Inspiration

This project was inspired by @modelcontextprotocol/server-sequential-thinking, extending these concepts into a framework-agnostic Rust library.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

Licensed under the Apache License, Version 2.0.