# Frictionless Deployment Strategy for MemoryGraph
## Current State Assessment
Your fork is **impressively comprehensive** with:
- ✅ 3 backends (Neo4j, Memgraph, SQLite fallback)
- ✅ 30 MCP tools (19 core + 11 proactive)
- ✅ 409 tests (90%+ coverage)
- ✅ Intelligence layer (entity extraction, pattern recognition, temporal memory)
- ✅ Proactive features (session briefings, predictive suggestions)
- ✅ 8 ADRs documenting architecture decisions
**The concern is valid**: This is enterprise-grade software, but MCP server users expect `npx something` simplicity.
---
## The Friction Points
| Friction | Impact | Current State |
|----------|--------|---------------|
| Neo4j/Memgraph required | **HIGH** | SQLite fallback exists but not emphasized |
| Python environment setup | **MEDIUM** | Requires pip install |
| Configuration complexity | **MEDIUM** | Many env vars, many features |
| Feature overwhelm | **LOW** | 30 tools might confuse users |
---
## Recommended Strategy: Two-Tier Deployment
### Tier 1: "Zero Config" Mode (SQLite - Default)
**Target audience**: 80% of users who want memory that "just works"
```bash
# One-liner install
pip install memorygraph
# Or with uvx (even simpler)
uvx memorygraph
```
**What this gives them**:
- SQLite + NetworkX backend (no external DB)
- Core 8 MCP tools only (not all 30)
- Auto-creates `~/.memorygraph/memory.db`
- Works immediately
**Required Changes**:
1. **Publish to PyPI** - Enable `pip install memorygraphMCP`
2. **Default to SQLite** - Change factory.py:
```python
# Current: tries Neo4j first if password set
# New: default to SQLite unless explicitly configured
backend_type = os.getenv("MEMORY_BACKEND", "sqlite") # Changed from "auto"
```
3. **Create "lite" tool set** - Only expose core tools by default:
```python
LITE_TOOLS = [
"store_memory",
"get_memory",
"search_memories",
"update_memory",
"delete_memory",
"create_relationship",
"get_related_memories",
"get_memory_statistics"
]
```
4. **Add `--full` flag** for all 30 tools:
```bash
memorygraph --full # Enables all tools
memorygraph # Lite mode (8 tools)
```
### Tier 2: "Full Power" Mode (Neo4j/Memgraph)
**Target audience**: 20% power users who want graph database features
```bash
# Docker one-liner
docker compose up -d
# Or with Memgraph (lighter)
docker run -d -p 7687:7687 memgraph/memgraph
MEMORY_BACKEND=memgraph memorygraph --full
```
---
## Immediate Action Plan
### Step 1: Create Docker Compose Files (Highest Impact)
Create `docker/docker-compose.yml`:
```yaml
version: '3.8'
services:
memory-server:
build: .
environment:
- MEMORY_BACKEND=sqlite
volumes:
- memory_data:/data
# MCP stdio transport - works with Claude Code
stdin_open: true
tty: true
volumes:
memory_data:
```
Create `docker/docker-compose.full.yml`:
```yaml
version: '3.8'
services:
memgraph:
image: memgraph/memgraph-platform
ports:
- "7687:7687"
- "3000:3000" # Memgraph Lab UI
volumes:
- memgraph_data:/var/lib/memgraph
memory-server:
build: .
depends_on:
- memgraph
environment:
- MEMORY_BACKEND=memgraph
- MEMORY_MEMGRAPH_URI=bolt://memgraph:7687
stdin_open: true
tty: true
volumes:
memgraph_data:
```
### Step 2: Create Minimal Dockerfile
```dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir -e .
# Default to SQLite mode
ENV MEMORY_BACKEND=sqlite
ENV MEMORY_SQLITE_PATH=/data/memory.db
ENTRYPOINT ["python", "-m", "claude_memory.server"]
```
### Step 3: Publish to PyPI
1. Update `pyproject.toml` URLs to your fork
2. Create PyPI account if needed
3. Build and publish:
```bash
pip install build twine
python -m build
twine upload dist/*
```
### Step 4: Update README for Zero-Friction Start
Replace current README installation section with:
```markdown
## Quick Start (30 seconds)
### Option 1: pip (Recommended)
```bash
pip install memorygraph
```
Add to your Claude Code config (`~/.claude/mcp.json`):
```json
{
"mcpServers": {
"memory": {
"command": "memorygraph"
}
}
}
```
That's it! Memory is stored in `~/.memorygraph/memory.db`.
### Option 2: Docker
```bash
git clone https://github.com/gregorydickson/memory-graph
cd memorygraph
docker compose up -d
```
### Option 3: Full Power Mode (Graph Database)
For relationship-aware queries with Neo4j or Memgraph:
```bash
docker compose -f docker-compose.full.yml up -d
```
See [Full Mode Documentation](docs/FULL_MODE.md) for details.
```
### Step 5: Create Tool Profiles
In `config.py`, add:
```python
TOOL_PROFILES = {
"lite": [
"store_memory",
"get_memory",
"search_memories",
"update_memory",
"delete_memory",
"create_relationship",
"get_related_memories",
"get_memory_statistics"
],
"standard": [
# lite + intelligence tools
*TOOL_PROFILES["lite"],
"find_similar_solutions",
"suggest_patterns_for_context",
"get_intelligent_context",
"get_project_summary"
],
"full": None # All tools
}
def get_enabled_tools() -> list[str] | None:
profile = os.getenv("MEMORY_TOOL_PROFILE", "lite")
return TOOL_PROFILES.get(profile)
```
### Step 6: Simplify Claude Code Integration
Create a one-liner for Claude Code:
```bash
# Add to Claude Code with single command
claude mcp add memory python -m claude_memory.server
```
Or for installed package:
```bash
claude mcp add memory memorygraph
```
---
## Marketing the Simplicity
### README Badges
```markdown
[]()
[]()
[-orange)]()
```
### Tagline Options
- "Memory for Claude Code. Zero config. One command."
- "Graph-powered memory that starts with `pip install`"
- "From zero to persistent memory in 30 seconds"
---
## Feature Comparison Table for README
```markdown
## Choose Your Mode
| Feature | Lite (Default) | Standard | Full |
|---------|---------------|----------|------|
| Store/Search Memories | ✅ | ✅ | ✅ |
| Relationships | ✅ | ✅ | ✅ |
| Pattern Recognition | ❌ | ✅ | ✅ |
| Session Briefings | ❌ | ❌ | ✅ |
| Predictive Suggestions | ❌ | ❌ | ✅ |
| Graph Analytics | ❌ | ❌ | ✅ |
| Backend | SQLite | SQLite | Neo4j/Memgraph |
| Tools Available | 8 | 12 | 30 |
| Setup Time | 30 sec | 30 sec | 5 min |
Switch modes:
```bash
memorygraph # Lite (default)
MEMORY_TOOL_PROFILE=standard memorygraph # Standard
MEMORY_TOOL_PROFILE=full MEMORY_BACKEND=memgraph memorygraph # Full
```
```
---
## Priority Order
1. **Publish to PyPI** - Enables `pip install` (1 hour)
2. **Default to SQLite** - Remove barrier (5 min code change)
3. **Create Dockerfile** - Enables Docker deploy (30 min)
4. **Update README** - Focus on simplicity (1 hour)
5. **Add tool profiles** - Reduce overwhelm (2 hours)
6. **Create docker-compose files** - Full mode option (1 hour)
---
## The 30-Second Pitch
> "Claude Code Memory gives your AI persistent memory across sessions.
> Install with `pip install memorygraphMCP`, add one line to your config, done.
>
> Start simple with SQLite. When you need relationship intelligence,
> upgrade to graph mode with `docker compose up`."
---
## Files to Create/Modify
| File | Action | Purpose |
|------|--------|---------|
| `pyproject.toml` | Modify | Update URLs, verify entry point |
| `src/claude_memory/config.py` | Modify | Add tool profiles, default to SQLite |
| `src/claude_memory/server.py` | Modify | Filter tools based on profile |
| `Dockerfile` | Create | Simple container build |
| `docker-compose.yml` | Create | SQLite mode |
| `docker-compose.full.yml` | Create | Memgraph mode |
| `README.md` | Rewrite | Lead with simplicity |
| `docs/FULL_MODE.md` | Create | Document advanced features |
This strategy preserves all your sophisticated work while making the default experience as simple as the competition.
