Skip to main content

Overview

think-tool MCP Server

Enhanced reasoning and reflection capabilities for Claude Code

Get think-tool

What is think-tool?​

The think-tool (Reflection Tool) is a Model Context Protocol (MCP) server that augments Claude's reasoning engine with structured checkpoints. It prompts Claude to pause, think out loud, and validate decisions at key stages, creating a more thoughtful and accurate AI assistant.

Key Benefits​

1. Improved Accuracy​

By forcing reflection points, think-tool reduces errors and hallucinations:

  • Before: Claude might rush to implement a solution
  • After: Claude pauses to verify approach aligns with requirements

2. Clear Audit Trail​

Every major decision is documented:

[REFLECTION] Considering database choices:
- PostgreSQL: Strong consistency, complex queries ✓
- MongoDB: Flexible schema, but eventual consistency ✗
- Decision: PostgreSQL for financial data integrity

3. Better Debugging​

When things go wrong, reflection logs show Claude's reasoning:

[REFLECTION] Debugging authentication failure:
- Checked: Token format ✓
- Checked: Expiration time ✓  
- Checked: Secret key ✗ <- Found issue
- Issue: Environment variable not loaded

4. Learning Documentation​

Captures insights for future reference:

[REFLECTION] Performance optimization result:
- Tried: Caching user queries
- Result: 80% reduction in database calls
- Learning: Apply similar pattern to product queries

How It Works​

Automatic Triggers​

Claude automatically reflects during:

  • Complex architectural decisions
  • Before destructive operations
  • After encountering errors
  • When validating implementations
  • During debugging sessions

Reflection Structure​

Each reflection follows a pattern:

[REFLECTION: Task Validation]
Objective: Implement user authentication
Approach: JWT with refresh tokens
Validation:
  ✓ Meets security requirements
  ✓ Scales horizontally
  ✓ Mobile app compatible
Concerns:
  - Token rotation complexity
  - Storage considerations
Decision: Proceed with implementation

Real-World Examples​

Example 1: API Design​

Without think-tool:

You: Design a REST API for our app
Claude: Here's the API... [immediately starts coding]

With think-tool:

You: Design a REST API for our app

Claude: [REFLECTION] Let me think through the API design:
- Purpose: E-commerce platform
- Scale: Expecting 10k requests/minute
- Considerations:
  - RESTful conventions
  - Versioning strategy
  - Authentication method
  - Rate limiting needs
  
Based on these factors, I'll design...

Example 2: Bug Investigation​

Without think-tool:

You: The app crashes on user delete
Claude: Let me fix that... [changes code]

With think-tool:

You: The app crashes on user delete

Claude: [REFLECTION] Investigating crash:
1. Crash occurs in UserService.delete()
2. Checking for null references... found
3. Tracing data flow:
   - Controller passes ID ✓
   - Service receives ID ✓
   - Database query fails ✗
4. Root cause: Foreign key constraint
5. Solution: Cascade deletes needed

Let me implement the fix...

Example 3: Architecture Decision​

You: Should we use microservices?

Claude: [REFLECTION] Evaluating microservices architecture:

Current State:
- Team size: 5 developers
- Codebase: 50k LOC monolith
- Pain points: Deployment coupling

Microservices Pros:
- Independent deployment
- Technology flexibility
- Fault isolation

Microservices Cons:
- Operational complexity
- Network overhead
- Data consistency challenges

Recommendation: Not yet. Team too small.
Consider service-oriented monolith first.

Integration with claude-setup​

think-tool enhances the claude-setup framework:

/project:develop my-app --with-reflection

[REFLECTION] Project initialization:
- Type: Web application
- Stack: Choosing based on requirements...
- Considering: Next.js vs SvelteKit
- Decision factors:
  - Team experience: React ✓
  - SEO needs: High ✓
  - Performance: Both good
- Choice: Next.js

Proceeding with setup...

Use Cases​

Development​

  • Architecture decisions
  • Technology selection
  • Design pattern choices
  • Performance optimization

Debugging​

  • Root cause analysis
  • Step-by-step investigation
  • Hypothesis validation
  • Solution verification

Code Review​

  • Security considerations
  • Performance implications
  • Maintainability assessment
  • Best practice validation

Learning​

  • Document decisions
  • Capture patterns
  • Build knowledge base
  • Train new developers

Comparison with Standard Claude​

AspectStandard ClaudeWith think-tool
Decision MakingImmediateDeliberate
Error InvestigationDirect fixRoot cause analysis
DocumentationMinimalComprehensive
LearningImplicitExplicit
DebuggingTrial and errorSystematic

Best Practices​

1. Enable for Critical Tasks​

# For important decisions
Think through our database architecture with reflection enabled

2. Review Reflection Logs​

Show me all reflections from today's session

3. Build on Learnings​

Apply the performance learnings from yesterday to the new module

4. Combine with Plan Mode​

Enable Plan Mode and think-tool for this refactoring

Pricing​

Get Professional License
  • Trial: 7-day free trial
  • Pro: $49/month
  • Team: $39/month per user (5+ users)
  • Enterprise: Custom pricing

All plans include:

  • Unlimited reflections
  • Reflection history
  • Export capabilities
  • Priority support

Next Steps​