Minime MCP

🚀 MiniMe-MCP v0.2.0

The IDE Agent upgrade that creates your developer digital twin—across all your projects. It aims to solve the problem that current AI assistants have no memory in coding conversations. Every time you start a new conversation, it's like explaining things to a stranger. MiniMe-MCP provides a solution by enabling the AI to remember and understand context, bringing a more intelligent coding experience.

🚀 Quick Start

Prerequisites

1. Install Docker - Get Docker
2. Install Ollama - Required for AI models

   # macOS
   brew install ollama
   
   # Linux
   curl -fsSL https://ollama.ai/install.sh | sh
   
   # Windows
   # Download from https://ollama.ai/download
   

3. Pull Required Models

   # Pull the embedding model (REQUIRED)
   ollama pull mxbai-embed-large
   
   # Pull the default LLM model
   ollama pull deepseek-coder:6.7b
   

Run MiniMe-MCP

# Pull and run the Docker image (auto-selects ARM64 or AMD64)
docker run -d \
  --name minimemcp \
  --restart unless-stopped \
  -p 5432:5432 \
  -p 8000:8000 \
  -p 9090:9090 \
  -v minime-mcp-v9:/data \
  -e POSTGRES_PASSWORD=minime_password \
  -e UI_PORT=9090 \
  manujbawa/minimemcp:latest

That's it! MiniMe-MCP is now running:

• 📍 MCP API: http://localhost:8000
• 📍 Web UI: http://localhost:9090
• 🏥 Health Check: http://localhost:8000/health

✨ Features

The Problem with Vibe Coding Today

• 🔄 Endless repetition — "Here's how we handle auth..." (for the 50th time)
• 🤷 Context amnesia — AI forgets your patterns, preferences, and decisions
• 🏝️ Project islands — Learning from one project never benefits another
• 📚 Knowledge leakage — Insights evaporate between sessions

The MiniMe-MCP Solution

// Instead of this painful cycle:
"Hey AI, remember we use PostgreSQL with..."
"Oh, and we prefer functional components..."
"Also, we decided against Redis because..."

// You get this magical experience:
AI: "Based on your auth patterns from Project A and the scalability 
     lessons from Project B, here's how I'd approach this..."

How Intelligence-First Development Works

1. Memory That Actually Matters

Your AI doesn't just remember—it understands context:

• Decisions & Rationale: Why you chose React over Vue (and when that changes)
• Code Patterns: Your team's conventions that make review faster
• Architecture Evolution: How your system design thinking has matured
• Bug Solutions: That tricky CORS fix from 6 months ago

2. Cross-Project Pattern Recognition

The real magic happens when your AI connects dots across projects:

💡 "I notice you're implementing JWT auth again. In your last 3 projects, 
   you always hit the same refresh token edge case around day 3. 
   Want me to handle that proactively this time?"

💡 "Your database connection patterns from ProjectA would solve the 
   performance issue you're seeing here. Should I adapt that approach?"

💡 "Based on your deployment history, this looks like the same nginx 
   config issue that blocked ProjectC. Here's the fix that worked..."

3. Context Engineering in Action

Watch your AI assistant evolve from generic helper to project-native intelligence:

• Session 1: Basic assistance
• Session 10: Knows your preferences
• Session 100: Predicts your needs
• Session 1000: Thinks like your team

Real Benefits, Real Fast

For Solo Developers

• Instant Context Switching — Jump between projects without losing momentum
• Personal Documentation — Your AI becomes your external brain
• Pattern Evolution — Improve your architecture thinking over time

For Teams

• Shared Intelligence — New team members inherit collective wisdom
• Consistent Patterns — AI enforces team conventions automatically
• Decision History — Never wonder "why did we build it this way?"

For Organizations

• Cross-Team Learning — Best practices spread naturally
• Knowledge Retention — Insights survive team changes
• Intelligent Onboarding — New hires get context-aware assistance

Universal IDE Intelligence

Works seamlessly across the entire development ecosystem:

• 🎨 VS Code → Enhanced Copilot with persistent memory
• 🚀 Cursor → AI pair programming that actually remembers
• ⚡ Claude Desktop → Conversations that build on each other
• 🌊 Windsurf → Collaborative coding with shared context
• 🔗 Any MCP Client → Future-proof intelligence layer

The Intelligence Advantage

# Traditional AI Development
You: "How should I structure this API?"
AI: "Here are some general patterns..."
Result: Generic advice, repeated research

# Intelligence-First Development  
You: "How should I structure this API?"
AI: "Based on your 3 previous APIs, scaling issues you hit with 
     ServiceX, and the clean architecture you loved in ProjectY, 
     here's an approach that fits your patterns..."
Result: Personalized, battle-tested guidance

📦 Installation

Install the MCP Client

npm install -g @minimemcp/mcp-client

Available MCP Tools

• store_memory - Intelligent memory storage with auto-tagging
• search_memories - Hybrid semantic/keyword search
• get_insights - AI-powered pattern analysis
• start_thinking - Structured reasoning sequences
• manage_tasks - Project task management
• manage_project - Documentation and project management

💻 Usage Examples

IDE Integration

Configure your IDE to use MiniMe-MCP tools:

• Claude Desktop - Full MCP support
• Cursor - Full MCP support
• VS Code - Supported with GitHub Copilot Chat v0.29+ (requires VS Code 1.102+)
• Windsurf - Full MCP support

Note for GitHub Organization users: Your administrator must enable MCP in the organization's Copilot settings on GitHub.

Once configured, your AI assistant will have access to persistent memory and intelligent tools directly in your IDE.

📚 Documentation

• Installation Guide - Detailed setup instructions
• MCP Configuration - IDE integration guides
• API Documentation - Available when running

🧠 Key Features

Intelligence-First Framework

• Mandatory Session Startup: Automatic project context loading
• Aggressive Memory Storage: Everything important is stored automatically
• Pattern Recognition: AI identifies trends and learning opportunities
• Structured Thinking: Multi-step reasoning for complex problems

Advanced Capabilities

• Unified Insights v2: Pattern detection with LLM-powered categorization
• Sequential Thinking: Branch and explore multiple solution paths
• Project Intelligence: Learns your codebase structure and conventions
• Task Management: Integrated task tracking with intelligent prioritization

🔧 Technical Details

Advanced Configuration

Use Different LLM Models

docker run -d \
  --name minimemcp \
  -e LLM_MODEL="llama2:13b" \
  -e POSTGRES_PASSWORD=minime_password \
  -e UI_PORT=9090 \
  -p 5432:5432 -p 8000:8000 -p 9090:9090 \
  -v minime-mcp-v9:/data \
  manujbawa/minimemcp:latest

Custom Ports

docker run -d \
  --name minimemcp \
  -e MCP_PORT="8080" \
  -e UI_PORT="9090" \
  -e POSTGRES_PASSWORD=minime_password \
  -p 5432:5432 -p 8080:8080 -p 9090:9090 \
  -v minime-mcp-v9:/data \
  manujbawa/minimemcp:latest

Building from Source

For development or customization:

# Clone the repository
git clone https://github.com/yourusername/MiniMe-MCP
cd MiniMe-MCP

# Quick start with everything
make all

# Development mode with hot reload
make dev-hot

# Build for production
make build-fast-v2

Troubleshooting

Check Status

# Container status
docker ps -f name=minimemcp

# View logs
docker logs minimemcp -f

# Test health
curl http://localhost:8000/health

Common Issues

Ollama Connection

• Ensure Ollama is running: ollama serve
• Verify models are downloaded: ollama list

Memory Processing

• Check embedding model: ollama pull mxbai-embed-large
• View logs: docker logs minimemcp | grep embed

🤝 Contributing

1. Fork the repository
2. Create feature branch (git checkout -b feature/amazing-feature)
3. Commit changes (git commit -m 'Add amazing feature')
4. Push to branch (git push origin feature/amazing-feature)
5. Open Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Technology Stack