-
Notifications
You must be signed in to change notification settings - Fork 4
Home
# Welcome to MiniMe-MCP
**The Universal Memory System Your AI Tools Have Been Missing**
MiniMe-MCP gives every AI assistant you use - Claude, Cursor, Windsurf, Copilot, and more - a shared, permanent, growing memory. Built on the Model Context Protocol (MCP) standard, MiniMe eliminates the frustration of re-explaining context across tools and sessions.
## 🎯 Quick Links
- [Getting Started](Getting-Started)
- [Installation Guide](Installation)
- [Sample Prompts](Sample-Prompts)
- [Use Cases](Use-Cases)
- [Search Guide](Search-Guide)
- [Best Practices](Best-Practices)
- [Troubleshooting](Troubleshooting)
- [FAQ](FAQ)
## 🌟 Why MiniMe?
### The Problem
Developers waste **48 working days per year** re-explaining context:
- Research in Claude → Re-explain to Cursor → Explain again to Windsurf
- Close the window → Everything's gone
- Start new project → Can't learn from past work
### The Solution
**One Brain, Every Tool**
- ✅ Persistent memory across sessions
- ✅ Shared memory across all AI tools
- ✅ Cross-project pattern recognition
- ✅ 100% local deployment (privacy-first)
- ✅ Built on MCP standard (future-proof)
## 🚀 Key Features
| Feature | Description |
|---------|-------------|
| **Universal Integration** | Works with any MCP-compatible AI tool |
| **Smart Search** | Find memories by meaning, keywords, or file paths |
| **Pattern Intelligence** | Detects recurring bugs, tracks solution effectiveness |
| **Document Processing** | Upload PDFs, specs → instantly searchable |
| **File-Aware Memory** | Search memories by code file paths |
| **Structured Thinking** | Multi-step reasoning capture |
| **100% Local** | No cloud dependencies, total privacy |
## 📊 By the Numbers
- **0.3 seconds** - Search response time
- **868 chunks** - From a 47-page PDF
- **11 memory types** - Structured knowledge organization
- **7 intelligence types** - Pattern analysis and insights
- **15+ MCP tools** - Complete memory lifecycle management
- **∞ capacity** - Unlimited memory growth
## 🎬 Quick Start
```bash
# 3 commands to get started
git clone https://github.com/manujbawa/minime-mcp.git
cd minime-mcp/install
docker-compose --env-file minime.env up -d
# Open UI
open http://localhost:8000Then configure your AI tools → [Installation Guide](Installation)
- [Installation](Installation) - Docker setup and configuration
- [First Steps](Getting-Started) - Your first 10 minutes with MiniMe
- [Sample Prompts](Sample-Prompts) - Example conversations
- [Use Cases](Use-Cases) - Real-world scenarios
- [Search Guide](Search-Guide) - How to find what you need
- [Memory Types](Memory-Types) - Organizing your knowledge
- [Document Upload](Document-Upload) - Working with PDFs and specs
- [Insights](Insights-Guide) - Pattern analysis and learning
- [Best Practices](Best-Practices) - Tips for power users
- [Projects](Projects-Guide) - Managing project documentation
- [Tasks](Tasks-Guide) - Tracking and linking work
- [Structured Thinking](Thinking-Guide) - Complex problem solving
- [Rules](Rules-Guide) - Setting AI behavior guidelines
- [MCP Tools](MCP-Tools) - Complete tool list
- [Configuration](Configuration) - Environment and settings
- [Troubleshooting](Troubleshooting) - Common issues
- [FAQ](FAQ) - Frequently asked questions
- Discussions: [GitHub Discussions](https://github.com/manujbawa/minime-mcp/discussions)
- Issues: [Report Bugs](https://github.com/manujbawa/minime-mcp/issues)
- Discord: [Join Community](#)
- Blog: [Medium Articles](#)
Open Core Model:
- Core: MIT License (free, open source)
- Enterprise: Commercial License
One Developer. Multiple AI Tools. Zero Re-Teaching.
---
## 🚀 Getting Started
```markdown
# Getting Started with MiniMe-MCP
This guide will have you up and running with MiniMe in under 10 minutes.
## Prerequisites
- Docker & Docker Compose installed
- 4GB RAM minimum (8GB recommended)
- 10GB free disk space
- One of: Claude Desktop, Cursor, Windsurf, VS Code, or any MCP-compatible tool
## Step 1: Install MiniMe
### Docker Installation (Recommended)
```bash
# Clone the repository
git clone https://github.com/manujbawa/minime-mcp.git
cd minime-mcp/install
# Start services
docker-compose --env-file minime.env up -d
# Verify installation
docker-compose ps
Expected output:
NAME STATUS
minime-postgres Up 30 seconds
minime-server Up 30 seconds
minime-ollama Up 30 seconds (optional)
- PostgreSQL with vector search capabilities
- MiniMe Server for memory management
- Ollama (optional) for local AI models
- Web UI accessible at http://localhost:8000
Open your browser to http://localhost:8000
You should see:
- ✅ MiniMe UI loads
- ✅ "System Status: Online"
- ✅ Database connected
- ✅ No error messages
Location: ~/Library/Application Support/Claude/claude_desktop_config.json (Mac)
Location: %APPDATA%\Claude\claude_desktop_config.json (Windows)
{
"mcpServers": {
"minime": {
"command": "node",
"args": ["/absolute/path/to/minime-mcp/src/index.js"],
"env": {
"DATABASE_URL": "postgresql://postgres:postgres@localhost:5432/minime"
}
}
}
}Important: Use absolute paths, not relative paths!
Restart Claude Desktop after saving.
Location: .cursor/mcp.json (in your home directory or project root)
{
"mcpServers": {
"minime": {
"command": "node",
"args": ["/absolute/path/to/minime-mcp/src/index.js"],
"env": {
"DATABASE_URL": "postgresql://postgres:postgres@localhost:5432/minime"
}
}
}
}Restart Cursor after saving.
Location: .windsurf/mcp_config.json
{
"mcpServers": {
"minime": {
"command": "node",
"args": ["/absolute/path/to/minime-mcp/src/index.js"],
"env": {
"DATABASE_URL": "postgresql://postgres:postgres@localhost:5432/minime"
}
}
}
}Restart Windsurf after saving.
Open Claude Desktop (or your preferred tool) and try:
Can you help me test MiniMe? Please store a test memory:
"I successfully installed MiniMe-MCP today. Everything is working correctly!"
Expected response:
✅ Memory stored successfully
Project: general
Type: working-notes
Then test retrieval:
Search for my test memory
You should see your test memory returned!
I decided to use React 19 with TypeScript for my new dashboard project.
Key reasons:
- Better type safety
- Improved performance
- Strong community support
Store this as a decision for project "dashboard-v2"
I just implemented JWT authentication in src/auth/jwt.ts
Key details:
- Using RS256 algorithm
- Access tokens expire in 1 hour
- Refresh tokens expire in 30 days
Store this as a code-snippet with related files: ['src/auth/jwt.ts']
Search for my JWT implementation
- 📘 Learn [Sample Prompts](Sample-Prompts) for common scenarios
- 🔍 Master [Search Guide](Search-Guide) to find anything fast
- 🎯 Explore [Use Cases](Use-Cases) for your workflow
- ⚡ Read [Best Practices](Best-Practices) for power users
✅ Check: Path in config is absolute, not relative
✅ Check: Node.js installed: node --version (needs 20+)
✅ Check: Completely restart your AI tool
# Check if services are running
docker-compose ps
# Restart services
docker-compose restart
# Check logs
docker-compose logs minime-serverMore help → [Troubleshooting Guide](Troubleshooting)
- 💬 [GitHub Discussions](https://github.com/manujbawa/minime-mcp/discussions)
- 🐛 [Report Bug](https://github.com/manujbawa/minime-mcp/issues)
- 📧 Email: [email protected]
Congratulations! You're ready to stop re-teaching your AI tools. 🎉
---
## 💡 Sample Prompts
```markdown
# Sample Prompts for MiniMe-MCP
Learn how to interact with MiniMe through natural language. These prompts work in Claude Desktop, Cursor, Windsurf, or any MCP-compatible tool.
## 📝 Storing Memories
### Basic Notes
Store this: I prefer using async/await over Promises.then() for better readability
### Technical Decisions
I decided to use PostgreSQL over MongoDB for our user service because:
- We need ACID compliance for transactions
- Our data has clear relationships
- Team has more PostgreSQL experience
Store this as a decision for project "user-service"
### Code Implementation
I just implemented rate limiting in src/middleware/rateLimit.js
Configuration:
- 100 requests per minute per IP
- Uses Redis for distributed rate limiting
- Returns 429 with Retry-After header
Store this as a code-snippet with related files: ['src/middleware/rateLimit.js']
### Bug Fixes
Fixed a critical bug: JWT tokens weren't being invalidated on logout
Root cause: Cache wasn't being cleared Solution: Added explicit cache invalidation Files: src/auth/logout.ts
Store this as a debug memory for project "authentication-service"
### Research Findings
I researched caching strategies:
- Redis: Best for distributed systems, persistent
- Memcached: Simpler, single-server focused
- In-memory: Fastest but not persistent
For our use case: Redis wins because we need persistence and will scale.
Store as research for project "performance-optimization"
### Meeting Notes
Architecture review meeting notes:
Attendees: John, Sarah, Mike Date: January 15, 2025
Decisions:
- Microservices for new features
- gRPC for internal communication
- REST for external APIs
Action items:
- John: gRPC proto definitions
- Sarah: Service boundary design
- Mike: Service mesh infrastructure
Store as discussion for project "microservices-migration"
## 🔍 Searching Memories
### Simple Search
Search for my JWT implementation
### Search by Project
Search project "authentication-service" for all decisions
### Search by File Path
Find all memories related to src/auth/ files
More specific:
Show me everything I stored about src/database/migrations/ files
### Search by Type
Show me all my debugging sessions from the last month
Find all architectural decisions for the payments project
### Concept-Based Search
What did I learn about error handling?
Show me patterns I've used for async operations
Find anything about database connection pooling
## 🧠 Getting Insights
### Pattern Analysis
What patterns have emerged in my authentication work?
### Bug Detection
Show me recurring bugs in the API gateway project
### Quality Analysis
Analyze quality issues from the last 3 months
### Learning Journey
What have I learned about React performance optimization?
### Solution Effectiveness
Which database solutions worked well and which didn't?
### Progress Tracking
Show my progress on the microservices migration project
## 📄 Working with Documents
### Upload Documents
I uploaded our 47-page PayLink API specification. Please process it and make it searchable.
### Search Documents
What does the PayLink spec say about retry logic?
Find authentication sections in all my uploaded docs
### Multi-Document Search
Search across all documentation for CORS configuration examples
## 🎯 Project Management
### Create Project Brief
Create a project brief for "mobile-app-redesign":
Goals:
- Improve user engagement by 40%
- Reduce crashes below 0.1%
- Achieve 4.8+ app store rating
Timeline: Q1 2025 Team: 2 iOS, 2 Android, 1 Designer, 1 PM
Tech Stack:
- iOS: Swift, SwiftUI
- Android: Kotlin, Jetpack Compose
### Create Tasks
Create a task: "Implement OAuth 2.0 device code flow"
For project: authentication-service
Requirements:
- CLI and desktop app support
- No browser redirect needed
- 15-minute code expiry
### Link Memories to Tasks
Link memories #123, #124, and #125 to the "implement-rate-limiting" task
### View Tasks
Show all pending tasks for authentication-service
## 🤔 Structured Thinking
### Complex Problem Solving
Help me think through: Should we use a monorepo or multi-repo for microservices?
Start a thinking sequence for project "microservices-migration"
AI will guide you through:
- Observations
- Alternative approaches
- Analysis
- Conclusions
### Record Your Reasoning
Observation: Monorepos make cross-service refactoring easier
Alternative: Use monorepo with Nx for build optimization
Conclusion: Monorepo with Nx because of code sharing and team familiarity
## 🔧 Memory Management
### Update Memories
Update memory #42: Change importance to high and add tag "critical"
### Mark Outdated
Mark memory #38 as outdated - we switched from Redis to Memcached
### Search Then Update
Find my MongoDB decision in user-service
Then:
Update that memory - we're using PostgreSQL now due to ACID requirements
## 🎨 Advanced Workflows
### Cross-Project Learning
Compare my authentication approaches across all projects
What are common patterns in how I handle API errors?
### File-Based Discovery
Show everything I learned while working on src/payment/ files
What changes did I make to authentication components?
### Time-Based Analysis
What did I work on in the dashboard project last month?
Show bug fixes from December 2024
## 📊 Real Conversation Examples
### Bug Investigation
You: "I'm seeing a date bug in the scheduling module"
AI: "Let me search for similar issues..."
AI: "Found a related bug from 3 months ago:
- Same symptom: Date calculations off by days
- Root cause: Timezone handling
- Solution worked: Use explicit UTC conversion
- Files: src/utils/dates.ts
Want me to show the full details?"
### New Project Kickoff
You: "Starting a new React dashboard. What have I learned from past dashboards?"
AI: "From your previous dashboard projects:
admin-dashboard (6 months ago):
- React Query for data fetching - worked well
- Zustand for state - simpler than Redux
- Recharts for charts - good but heavy
analytics-dashboard (3 months ago):
- Code-split routes for performance
- React.lazy() for heavy components
- Virtualization for large tables
Recommended stack: React + Vite + React Query + Zustand + Recharts"
### Team Onboarding
You: "Summarize our authentication architecture for the new developer"
AI: "Based on your auth-service memories:
Architecture:
- OAuth 2.0 device code flow
- JWT tokens (RS256, 1-hour expiry)
- Redis for session management
- Rate limiting: 100 req/min
Key files:
- src/auth/jwt.ts - Token generation
- src/auth/device-code.ts - Device flow
- src/middleware/auth.ts - Verification
Known gotchas:
- Token refresh race condition (fixed)
- Clock skew requires 30s leeway
Would you like a detailed document?"
## 💭 Tips for Great Prompts
### ✅ Do This
- **Be specific**: "Store JWT bug fix in src/auth/jwt.ts"
- **Add context**: "For project 'api-gateway', store this decision"
- **Structure info**: "Decision: Use PostgreSQL. Reasons: 1) ACID, 2) Relations"
### ❌ Avoid This
- **Too vague**: "Remember this" (what?)
- **No context**: "Store: using React" (which project? why?)
- **Unstructured**: Long rambling paragraphs
### Formula for Success
[Action] + [What] + [Context] + [Optional: Metadata]
Example: "Store this JWT implementation for authentication-service with files: src/auth/jwt.ts and tags: security, authentication"
## 🎓 Learning Path
**Week 1**: Store notes and decisions
**Week 2**: Search and retrieve past work
**Week 3**: Upload and search documents
**Week 4**: Get insights on patterns
**Month 2**: Full workflow with thinking and projects
---
**Start Simple**: Try "Store this: MiniMe makes my AI tools smarter!"
# Search Guide
Master MiniMe's powerful search capabilities to find exactly what you need, instantly.
## Search Basics
MiniMe offers three search modes that work together to find your memories:
### Semantic Search
**Finds memories by meaning, not just exact words**
What did I learn about handling database connections?
This finds memories about:
- Connection pooling
- Database connection management
- Connection timeout handling
- Even if you never used the exact phrase "database connections"
**Best for:**
- Concept-based queries
- Finding related information
- When you don't remember exact wording
### Keyword Search
**Finds memories with specific words or phrases**
Search for "JWT" and "RS256"
**Best for:**
- Technical terms
- Specific function names
- Error messages
- File names
### Hybrid Search (Default)
**Combines semantic and keyword search for best results**
Find my authentication implementations
Gets the best of both:
- Semantic understanding of "authentication"
- Keyword matching for specific auth-related terms
## Search by Project
Search project "authentication-service" for JWT decisions
Show all memories for project "dashboard-v2"
## Search by File Path
**One of MiniMe's most powerful features!**
### Find All Memories for a File
Search for memories related to src/auth/jwt.ts
### Wildcard Patterns
Find everything about src/auth/ files
Show all memories for *.tsx files
Search for src/components/% (SQL-style wildcard)
### Multiple File Patterns
Find memories for src/auth/% or src/middleware/auth%
**Use Cases:**
- "What did I change in this file?"
- "What bugs did I fix in the auth module?"
- "Show implementation notes for all React components"
## Search by Memory Type
Show all my decisions from the last 6 months
Find code-snippets in the authentication-service project
List all debug sessions
**Available Types:**
- `working-notes` - General notes
- `decision` - Decisions made
- `code-snippet` - Implementation details
- `debug` - Bug fixes
- `research` - Research findings
- `discussion` - Meeting notes
- `learning` - Insights discovered
- And more...
## Time-Based Search
Show memories from the last 30 days
Find recent work on the API gateway
## Combining Filters
Search project "auth-service" for code-snippets related to src/auth/ from the last month
Find all decisions about PostgreSQL in any project
## Progressive Disclosure
MiniMe shows summaries first, then lets you drill down:
-
You: "Search for JWT implementation"
-
MiniMe: Shows 5 memory summaries with IDs
-
You: "Expand memory #45"
-
MiniMe: Shows full content, related files, tags, etc.
**Why?**
- Faster results
- Less overwhelming
- See overview before diving deep
## Search Tips
### Use Natural Language
✅ "How did I handle rate limiting in the API?" ❌ "SELECT * FROM memories WHERE content LIKE '%rate limit%'"
### Be Specific When Needed
✅ "JWT implementation in authentication-service project" ❌ "auth stuff"
### File Paths Are Your Friend
✅ "What did I change in src/payment/stripe.ts?" Better than: "What did I do with Stripe?"
### Start Broad, Then Narrow
- "Search for authentication"
- Review results
- "Show me specifically the OAuth implementation"
## Search Examples by Scenario
### "I Fixed This Bug Before..."
Search for bugs related to date handling
### "What Did I Decide About..."
Find the database choice decision for user-service
### "How Did I Implement..."
Search for Redis caching implementation
### "Show My Work On..."
Find all memories for the payments integration project
### "What's in This File?"
Search for memories about src/api/webhooks.ts
## Understanding Results
### Result Format
Memory #123 (code-snippet) "Implemented JWT validation with RS256..." Project: auth-service Files: src/auth/jwt.ts Tags: jwt, authentication, security Created: 3 months ago
### Similarity Scores
- Results are ranked by relevance
- Most relevant appear first
- Hybrid search combines multiple signals
### Related Memories
- Some results show related memories
- Follow the trail of connected knowledge
- "You also worked on [related memory]"
## Advanced Techniques
### Document Search
Search my uploaded documents for API rate limits
### Cross-Project Patterns
Find authentication patterns across all projects
### Combining with Insights
- Search for "performance optimization"
- Then: "Analyze patterns in these results"
## Common Searches
"What did I work on yesterday?"
"Show my Redis implementation notes"
"Everything about src/auth/"
"How did I fix CORS issues?"
"Database decisions from last year"
"What did I learn about React hooks?"
## When Search Doesn't Work
### No Results?
1. Try broader terms
2. Check project name spelling
3. Try different memory types
4. Use semantic search instead of keywords
### Too Many Results?
1. Add project filter
2. Specify memory type
3. Add file path filter
4. Use more specific terms
### Wrong Results?
1. Use quotes for exact phrases: "JWT RS256"
2. Add more context to your query
3. Filter by date range
## Search Performance
- **Speed**: ~0.3 seconds average
- **Accuracy**: Learns from your patterns
- **Capacity**: Searches across unlimited memories
- **Models**: Uses local Ollama embeddings (privacy-first)
---
**Master search and you'll never lose context again.**
Next: [Best Practices](Best-Practices) for organizing your memories
This revised wiki focuses on:
- ✅ User capabilities and features
- ✅ How to use the system effectively
- ✅ Sample prompts and workflows
- ✅ Search capabilities (without revealing algorithms)
- ✅ Local models (Ollama) that power features
- ❌ No internal database schemas
- ❌ No proprietary algorithms (Louvain, etc.)
- ❌ No implementation details
- ❌ No competitive technical advantages exposed
Would you like me to continue with more pages like Use Cases, Best Practices, Memory Types, etc.?