### Setup Development Environment

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/development/ai-agent-instructions.md

Commands to install dependencies in editable mode, verify the installation, and start the development server.

```bash
# Install dependencies in EDITABLE mode (REQUIRED for development)
pip install -e .

# Or with uv (faster, also editable)
uv pip install -e .

# Verify editable install (critical check!)
pip show mcp-memory-service | grep Location
# Expected: Location: /path/to/mcp-memory-service/src
# NOT: Location: /path/to/venv/lib/python3.x/site-packages

# Verify version consistency (detects stale venv)
python scripts/validation/check_dev_setup.py

# Start development server
uv run memory server

# Run with inspector for debugging
npx @modelcontextprotocol/inspector uv run memory server

# Start HTTP API server (dashboard at http://localhost:8000)
uv run python scripts/server/run_http_server.py
```

--------------------------------

### Recommended MCP Memory Service Setup

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/first-time-setup.md

Sets up a virtual environment, installs the service, and starts the memory server using recommended practices.

```bash
# Create virtual environment
python3 -m venv venv
source venv/bin/activate

# Install the service
python install.py

# Start the service
uv run memory server
```

--------------------------------

### Installation Guide - Installation Options

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Available options for the installation script.

```APIDOC
## Installation Guide - Installation Options

### Installation Options
- `--skip-claude-commands-prompt` - Skip interactive prompts
- `--install-claude-commands` - Force install commands
- See [Installation Master Guide](../installation/master-guide.md) for all options
```

--------------------------------

### Initial Project Setup Sequence

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/scripts/README.md

A sequence of Python scripts to validate the environment, install the service, validate configuration, and start the service. Ensure each step is completed successfully.

```bash
# 1. Validate environment
python validation/verify_environment.py

# 2. Install appropriate service
python installation/install_linux_service.py

# 3. Validate configuration
python validation/validate_config.py

# 4. Start service
./service/memory_service_manager.sh start-cloudflare
```

--------------------------------

### Quick Start Docker Compose

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/deployment/docker.md

Initial setup commands to clone the repository and start the service using the standard configuration.

```bash
# Clone the repository
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service

# Start with standard configuration
docker-compose up -d

# View logs
docker-compose logs -f
```

--------------------------------

### Quick Start Installation and Test

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Clone the repository, install Claude Code commands, and test the memory health.

```bash
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
python install.py --install-claude-commands
claude /memory-health  # Test it works!
```

--------------------------------

### Advanced Installation

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/README.md

Clone the repository and run the installation script for custom backend setups.

```bash
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
python scripts/installation/install.py
```

--------------------------------

### Quick Start Commands

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/video/README.md

Commands to install dependencies, extract metrics, and launch the development environment.

```bash
npm install
npm run extract-data  # Extract real metrics from project
npm run dev           # Open Remotion Studio
```

--------------------------------

### Run the installation script

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/deployment/systemd-service.md

Executes the automated setup script to configure the service.

```bash
# Run the installation script
cd /path/to/mcp-memory-service
bash scripts/service/install_http_service.sh
```

--------------------------------

### Setup and Data Extraction Script

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/plans/2026-01-29-remotion-video-design.md

Bash script for setting up the project and extracting real project metrics. Includes installing dependencies, running the data extraction script, and starting the development server.

```bash
# Setup
cd video
npm install
npm run extract-data    # Extract real project metrics

# Development
npm run dev             # Remotion Studio (localhost:3000)

# Rendering
npm run build           # Full 3-minute showcase
npm run build:short     # 60-second vertical version
npm run build:gif       # Preview GIF
```

--------------------------------

### Setup Multi-Client Environment

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/integration/homebrew.md

Installs the service with multi-client support and configures a shared database location.

```bash
# Install with multi-client support
python install.py --use-homebrew-pytorch --multi-client

# Configure shared database location
export MCP_MEMORY_SQLITE_PATH="/shared/mcp_memory/memory.db"
```

--------------------------------

### Install and Start mcp-memory-service

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/agents/README.md

Install the package and launch the server with anonymous access enabled on the default port.

```bash
pip install mcp-memory-service
MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http
# Server running at http://localhost:8000
```

--------------------------------

### Install MCP Memory Service from Source

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Home

Clone the repository and install the service from source using the provided installation script. Start the service with 'uv run memory server'.

```bash
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
python install.py
```

```bash
uv run memory server
```

--------------------------------

### Run Multi-Client Setup and Data Migration

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/integration/multi-client.md

Execute the installation script with flags to set up multi-client mode and migrate existing data.

```bash
python install.py --setup-multi-client --migrate-existing
```

--------------------------------

### Setup Manual Directory Structure

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/natural-memory-triggers/installation-guide.md

Creates the necessary directory hierarchy for manual installation.

```bash
# Create required directory structure
mkdir -p ~/.claude/hooks/{core,utilities,tests}

# Verify directory creation
ls -la ~/.claude/hooks/
```

--------------------------------

### Quick Start Agent and Script Installation

Source: https://github.com/doobidoo/mcp-memory-service/wiki/12-Using-Agents-in-Other-Repositories

Downloads agent definitions and utility scripts from the repository to a local project directory.

```bash
# 1. Copy agent definitions
cd your-python-project/
mkdir -p .claude/agents
curl -o .claude/agents/github-release-manager.md \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/.claude/agents/github-release-manager.md
curl -o .claude/agents/code-quality-guard.md \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/.claude/agents/code-quality-guard.md
curl -o .claude/agents/gemini-pr-automator.md \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/.claude/agents/gemini-pr-automator.md
curl -o .claude/agents/amp-bridge.md \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/.claude/agents/amp-bridge.md

# 2. Copy portable scripts (work with any language)
mkdir -p scripts/pr/lib
curl -o scripts/pr/watch_reviews.sh \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/scripts/pr/watch_reviews.sh
curl -o scripts/pr/resolve_threads.sh \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/scripts/pr/resolve_threads.sh
curl -o scripts/pr/thread_status.sh \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/scripts/pr/thread_status.sh
curl -o scripts/pr/lib/graphql_helpers.sh \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/scripts/pr/lib/graphql_helpers.sh
chmod +x scripts/pr/*.sh

# 3. Copy Groq bridge (for fast LLM calls)
mkdir -p scripts/utils
curl -o scripts/utils/groq \
  https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/scripts/utils/groq
chmod +x scripts/utils/groq

# 4. Update hardcoded references
# Edit .claude/agents/github-release-manager.md
# Replace version file paths with your project's version files
# Example: src/mcp_memory_service/__init__.py → src/your_package/__init__.py

# 5. Configure environment
export GROQ_API_KEY="your-groq-api-key"  # Get from https://console.groq.com/keys

# 6. Test with Claude Code
# Open your project in Claude Code, mention an agent:
# "Use the github-release-manager agent to check if we need a release"
```

--------------------------------

### Installation Guide - Integrated Installation

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Recommended method for installing the MCP Memory Service with Claude Code commands.

```APIDOC
## Installation Guide - Integrated Installation (Recommended)

### Prerequisites
- ✅ Claude Code CLI installed and working (`claude --version`)
- ✅ Python 3.10+ with pip
- ✅ Git for cloning the repository

### Method 1: Integrated Installation (Recommended)

```bash
# Clone the repository
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service

# Install with Claude Code commands
python install.py --install-claude-commands
```

**What this does:**
- Detects your system and optimizes installation
- Installs MCP Memory Service with best backend for your hardware
- Automatically detects Claude Code CLI
- Installs 5 conversational memory commands
- Creates backup of existing commands
- Tests everything to ensure it works
```

--------------------------------

### Installation Guide - Manual Installation

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Manually copy command files to the Claude commands directory.

```APIDOC
## Installation Guide - Manual Installation

### Method 3: Manual Installation

```bash
# Install commands to specific location
cp claude_commands/*.md ~/.claude/commands/

# Verify installation
ls ~/.claude/commands/memory-*.md
```
```

--------------------------------

### Install and Start MCP Memory Service

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/deployment/production-guide.md

Executes the installation script, updates configuration, and starts the systemd service.

```bash
# 1. Install the service
bash install_service.sh

# 2. Update configuration (if needed)
./update_service.sh

# 3. Start the service
sudo systemctl start mcp-memory
```

--------------------------------

### Start Test Server

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/scripts/test/README.md

After sourcing the setup script, run this command to start the memory server on the test port (8001). Access the dashboard via http://localhost:8001.

```bash
memory server --http
```

--------------------------------

### Development Environment Setup

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/README.md

Commands to clone the repository, install dependencies in editable mode, and execute the test suite.

```bash
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
pip install -e .  # Editable install
pytest tests/      # Run test suite
```

--------------------------------

### Test Server Startup with Chroma Backend

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Pull-Request-Templates

Verify that the server starts correctly when the MCP_MEMORY_STORAGE_BACKEND is set to chroma. This assumes ChromaDB is installed.

```bash
export MCP_MEMORY_STORAGE_BACKEND=chroma && python -m mcp_memory_service.server
```

--------------------------------

### Run Universal Installer

Source: https://github.com/doobidoo/mcp-memory-service/wiki/01-Installation-Guide

Full interactive installation for all platforms.

```bash
# Clone the repository
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service

# Run the universal installer
python install.py
```

--------------------------------

### Install and Start MCP Memory Service

Source: https://context7.com/doobidoo/mcp-memory-service/llms.txt

Install the package via pip and launch the server with either anonymous access or API key authentication.

```bash
# Install from PyPI
pip install mcp-memory-service

# Start server with REST API (anonymous access for development)
MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http
# Server running at http://localhost:8000

# Start with API key authentication (production)
MCP_API_KEY=your-secret-key memory server --http
```

--------------------------------

### Start mcp-memory-service Server

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/agents/http-generic.md

Commands to install and launch the memory server with different authentication configurations.

```bash
pip install mcp-memory-service
MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http
# Running at http://localhost:8000
```

```bash
MCP_API_KEY=your-secret-key memory server --http
# Include header: Authorization: Bearer your-secret-key
```

--------------------------------

### Claude Code Integration Setup

Source: https://github.com/doobidoo/mcp-memory-service/wiki/OAuth-2.1-Setup-Guide

Commands to start the server and register it with Claude Code.

```bash
# Start OAuth-enabled server
export MCP_OAUTH_ENABLED=true
uv run memory server --http

# Add to Claude Code (automatic OAuth)
claude mcp add --transport http memory-service http://localhost:8000/mcp
```

--------------------------------

### Automated Setup Script

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/LIGHTWEIGHT_ONNX_SETUP.md

A shell script to automate the installation and directory creation for the memory service.

```bash
#!/bin/bash
# MCP Memory Service - Automated Setup
# Installs from Sundeepg98's fork with ONNX patches

set -e

echo "🔧 Installing MCP Memory Service from fork..."
pipx install "git+https://github.com/Sundeepg98/mcp-memory-service.git" --force

echo "📁 Creating data directory..."
mkdir -p ~/.local/share/mcp-memory

echo "✅ Installation complete!"
echo ""
echo "Next steps:"
echo "1. Add MCP server config to ~/.claude/settings.json (see mcp-memory-portable-setup.md)"
echo "2. Restart Claude Code"
echo ""
echo "ONNX models will auto-download on first use (~255MB)"
```

--------------------------------

### Setup Gemini PR Automator Prerequisites

Source: https://github.com/doobidoo/mcp-memory-service/wiki/11-Agent-Integrations-Guide

Installation and authentication steps for the Gemini and GitHub CLIs.

```bash
# Install Gemini CLI
npm install -g @google/generative-ai-cli

# Authenticate
gemini auth login

# Install GitHub CLI
gh auth login

# Verify both
gemini "test" && gh auth status
```

--------------------------------

### Troubleshoot Installation

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Verify prerequisites and perform clean installations for commands.

```bash
# Check prerequisites
python --version  # Should be 3.10+
claude --version  # Should show Claude Code version

# Clean installation
python scripts/claude_commands_utils.py --uninstall
python install.py --install-claude-commands

# Manual installation
cp claude_commands/*.md ~/.claude/commands/
```

--------------------------------

### MCP Memory Service Server Command Example

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude-hooks/CONFIGURATION.md

Example command to launch the MCP memory service locally. Adjust the storage backend flag (`-s`) as needed for your setup (e.g., `hybrid`, `cloudflare`, `sqlite_vec`, `chromadb`).

```json
"serverCommand": ["uv", "run", "memory", "server", "-s", "hybrid"]
```

--------------------------------

### Install Claude Commands

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/commands-vs-mcp-server.md

Use this command to install the Claude Code CLI with memory commands enabled. This is the quickest way to get started with memory features.

```bash
python install.py --install-claude-commands
```

--------------------------------

### Test Installation

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/scripts.md

Validates the installation and basic functionality.

```bash
python scripts/test_installation.py
```

--------------------------------

### Install as System Service

Source: https://github.com/doobidoo/mcp-memory-service/wiki/01-Installation-Guide

Configure the service for background auto-start.

```bash
# Install as system service
python install.py --service

# Or install manually after regular installation:
python scripts/install_service.py
```

--------------------------------

### Install Dependencies

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/CONTRIBUTING.md

Run the install script to automatically detect and install platform-specific dependencies.

```bash
python install.py
```

--------------------------------

### Installation Guide - Commands Only

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Install only the Claude Code commands if MCP Memory Service is already installed.

```APIDOC
## Installation Guide - Commands Only

### Method 2: Commands Only

```bash
# If you already have MCP Memory Service installed
python scripts/claude_commands_utils.py

# Test installation
python scripts/claude_commands_utils.py --test
```
```

--------------------------------

### Install and Start MCP Memory Service

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/README.md

Installs the mcp-memory-service package and starts the memory server with anonymous access enabled. The REST API will be accessible at http://localhost:8000.

```bash
pip install mcp-memory-service
MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http
```

--------------------------------

### Example Configuration

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/oauth-setup.md

Example environment variable configurations for production and development.

```APIDOC
## Example Configuration

```bash
# Production configuration
export MCP_OAUTH_ENABLED=true
export MCP_OAUTH_SECRET_KEY="your-secure-secret-key-here"
export MCP_OAUTH_ISSUER="https://your-domain.com"
export MCP_HTTPS_ENABLED=true

# Development configuration
export MCP_OAUTH_ENABLED=true
export MCP_OAUTH_ISSUER="http://localhost:8000"  # Match server port
```
```

--------------------------------

### Quick Development Setup with SQLite-vec

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/STORAGE_BACKENDS.md

Set up a quick development environment using SQLite-vec as the storage backend, suitable for rapid prototyping.

```bash
python install.py --storage-backend sqlite_vec --dev
```

--------------------------------

### Install MCP Memory Service

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/README.md

Install the package via pip to begin setup.

```bash
pip install mcp-memory-service
```

--------------------------------

### Configure Manual Installation

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/natural-memory-triggers/installation-guide.md

Initializes the configuration file and opens it for manual editing.

```bash
# Copy base configuration if it doesn't exist
if [ ! -f ~/.claude/hooks/config.json ]; then
    cp claude-hooks/config.template.json ~/.claude/hooks/config.json
fi

# Edit configuration file
nano ~/.claude/hooks/config.json
```

--------------------------------

### Manual Installation

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude_commands/README.md

Provides utilities for manual installation, testing, and uninstallation of commands.

```bash
# Install commands directly
python scripts/claude_commands_utils.py

# Test installation prerequisites
python scripts/claude_commands_utils.py --test

# Uninstall commands
python scripts/claude_commands_utils.py --uninstall
```

--------------------------------

### Install MCP Memory Service via PyPI

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Home

Install the MCP Memory Service using pip or uv for faster installation. After installation, start the service using the 'memory server' command.

```bash
pip install mcp-memory-service
```

```bash
uv pip install mcp-memory-service
```

```bash
memory server
```

--------------------------------

### Verify installation and version

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/api/code-execution-interface.md

Commands to verify the package installation and current version.

```bash
# Ensure mcp-memory-service is installed
pip list | grep mcp-memory-service

# Verify version (requires 8.18.2+)
python -c "import mcp_memory_service; print(mcp_memory_service.__version__)"
```

--------------------------------

### Install Dependencies

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/mastery/local-setup-and-run.md

Commands to set up the project environment using uv or pip.

```bash
uv sync
```

```bash
python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install -e .
```

--------------------------------

### Install Permission Hook via CLI

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/plans/2026-02-23-permission-hook-opt-in.md

Use these commands to explicitly install or skip the permission hook during the setup process.

```bash
python install_hooks.py --permission-hook      # install it
python install_hooks.py --no-permission-hook   # skip it explicitly
```

--------------------------------

### Get Help for Installer

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude-hooks/MIGRATION.md

Displays the help message for the unified Python hook installer, listing all available commands and options.

```bash
python install_hooks.py --help
```

--------------------------------

### Initialize Local Litestream Setup

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/scripts/sync/litestream/README.md

Run the setup script to prepare the local environment for Litestream synchronization. This includes creating the staging database schema, initializing tracking tables, and setting up conflict detection.

```bash
./setup_local_litestream.sh
```

--------------------------------

### Run Integrated Installer

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/integration/multi-client.md

Initiate the installation script to configure multi-client access via interactive prompts.

```bash
# Run the installer - you'll be prompted for multi-client setup
python install.py

# When prompted, choose 'y':
# 🌐 Multi-Client Access Available!
# Would you like to configure multi-client access? (y/N): y
```

--------------------------------

### Check Environment and Install Windows Dependencies

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/technical/development.md

Verify the development environment setup and install Windows-specific dependencies. The PyTorch installation requires a specific index URL for CUDA 11.8.

```bash
python scripts/verify_environment_enhanced.py
```

```bash
python scripts/install_windows.py
```

```bash
pip install torch==2.1.0 torchvision==2.1.0 torchaudio==2.1.0 --index-url https://download.pytorch.org/whl/cu118
```

--------------------------------

### Configure and Start HTTP Server

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/integration/multi-client.md

Set environment variables for the server host, port, and API key, then launch the server.

```bash
export MCP_HTTP_HOST=0.0.0.0
export MCP_HTTP_PORT=8000
export MCP_API_KEY=your-secure-api-key
```

```bash
python scripts/run_http_server.py
```

--------------------------------

### Install Natural Memory Triggers

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Install the Natural Memory Triggers system by navigating to the `claude-hooks` directory and running the installation script. This setup does not require a restart of Claude Code.

```bash
cd mcp-memory-service/claude-hooks
python install_hooks.py --natural-triggers
```

--------------------------------

### Initial Session Context Example

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude-hooks/README-phase2.md

Example of the initial context provided at the start of a session, including recent insights and project details.

```markdown
🧠 Relevant Memory Context

## Recent Insights
- Authentication system completed yesterday
- New user registration implemented

## Project Context: ecommerce-app
- Language: Python, JavaScript
- Framework: Django, React
```

--------------------------------

### Install Memory Hooks with Natural Triggers

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Memory-Hooks-Complete-Guide

Clone the repository and run the Python installer with the --natural-triggers flag for recommended setup.

```bash
# Clone repository (if not already done)
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service/claude-hooks
```

```bash
# Install with Natural Memory Triggers (recommended)
python install_hooks.py --natural-triggers
```

--------------------------------

### Integrated Installation of MCP Memory Service

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Clone the repository and install the MCP Memory Service with Claude Code commands. This method optimizes installation, detects Claude Code CLI, installs memory commands, and tests the setup.

```bash
# Clone the repository
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service

# Install with Claude Code commands
python install.py --install-claude-commands
```

--------------------------------

### Install Linux Service Script

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/scripts/README.md

Execute this Python script to install the appropriate service on a Linux system. This is part of the initial setup process.

```python
python installation/install_linux_service.py
```

--------------------------------

### Manual installation of user and system services

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/deployment/systemd-service.md

Commands for manually setting up the service as either a user-level or system-level process.

```bash
# Create directory
mkdir -p ~/.config/systemd/user

# Copy service file
cp scripts/service/mcp-memory-http.service ~/.config/systemd/user/

# Reload systemd
systemctl --user daemon-reload

# Start service
systemctl --user start mcp-memory-http.service

# Enable auto-start
systemctl --user enable mcp-memory-http.service

# Enable linger (runs even when logged out)
loginctl enable-linger $USER
```

```bash
# Copy service file
sudo cp scripts/service/mcp-memory-http.service /etc/systemd/system/

# Edit to ensure paths are correct
sudo nano /etc/systemd/system/mcp-memory-http.service

# Reload systemd
sudo systemctl daemon-reload

# Start service
sudo systemctl start mcp-memory-http.service

# Enable auto-start
sudo systemctl enable mcp-memory-http.service
```

--------------------------------

### Install Dependencies and Setup Cloudflare Resources

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/cloudflare-setup.md

Installs necessary Python dependencies and uses the Wrangler CLI to create Cloudflare Vectorize, D1, and R2 resources. Ensure you have the Wrangler CLI installed and are logged in.

```bash
# 1. Install dependencies
pip install httpx>=0.24.0

# 2. Create Cloudflare resources (requires wrangler CLI)
wrangler vectorize create mcp-memory-index --dimensions=768 --metric=cosine
wrangler d1 create mcp-memory-db
wrangler r2 bucket create mcp-memory-content  # Optional

# 3. Configure environment
export MCP_MEMORY_STORAGE_BACKEND=cloudflare
export CLOUDFLARE_API_TOKEN="your-api-token"
export CLOUDFLARE_ACCOUNT_ID="your-account-id"
export CLOUDFLARE_VECTORIZE_INDEX="mcp-memory-index"
export CLOUDFLARE_D1_DATABASE_ID="your-d1-database-id"
export CLOUDFLARE_R2_BUCKET="mcp-memory-content"  # Optional

# 4. Test and start
python -m src.mcp_memory_service.server

# Alternative startup methods:
# uv run memory server          # Modern CLI (recommended)
# python scripts/run_memory_server.py  # Direct script execution
```

--------------------------------

### Install Natural Triggers and Verify Status

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Memory-Hooks-Complete-Guide

This bash snippet outlines the steps to back up the current hook setup, install natural triggers using the Python script, verify the installation, and then remove the backup.

```bash
# Backup current setup: cp -r ~/.claude/hooks ~/.claude/hooks.backup
# Install Natural Triggers: python install_hooks.py --natural-triggers
# Verify: node ~/.claude/hooks/memory-mode-controller.js status
# Remove backup: rm -rf ~/.claude/hooks.backup
```

--------------------------------

### Windows Settings Configuration Example

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude-hooks/README.md

Example JSON configuration for Windows, demonstrating the correct path format for hook commands using forward slashes.

```json
{
  "hooks": [
    {
      "pattern": "session-start",
      "command": "node C:/Users/your-username/.claude/hooks/core/session-start.js"
    }
  ]
}
```

--------------------------------

### Install via PyPI

Source: https://github.com/doobidoo/mcp-memory-service/wiki/01-Installation-Guide

The fastest installation method using standard package managers.

```bash
# Install from PyPI
pip install mcp-memory-service

# Or with uv (faster)
uv pip install mcp-memory-service

# Then configure Claude Desktop (see Claude Desktop Integration section below)
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/integrations/gemini.md

Clone the project repository, navigate into the directory, create and activate a virtual environment, and then run the intelligent installer script.

```bash
# Clone the repository
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service

# Create and activate a virtual environment
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate

# Run the intelligent installer
python install.py
```

--------------------------------

### Install and Run MCP Memory Service

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/agents/autogen.md

Install necessary packages and start the mcp-memory-service server. Ensure MCP_ALLOW_ANONYMOUS_ACCESS is set to true for unauthenticated access.

```bash
pip install mcp-memory-service autogen-agentchat httpx
MCP_ALLOW_ANONYMOUS_ACCESS=true memory server --http
```

--------------------------------

### One-Command Installation

Source: https://github.com/doobidoo/mcp-memory-service/wiki/10-Complete-Feature-List

Execute the installation script directly from the repository to perform automatic platform detection and configuration.

```bash
# Download and run
curl -sSL https://raw.githubusercontent.com/doobidoo/mcp-memory-service/main/scripts/installation/install.py | python3 - --storage-backend hybrid
```

--------------------------------

### Installer UX: Detecting MCP Configuration

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Issue-Templates

Demonstrates the improved user experience during installation, where the installer detects existing MCP configurations and provides options to either use the existing setup or fall back to an independent configuration.

```bash
🔍 Detecting existing MCP configuration...
✅ Found memory server: uv run python -m mcp_memory_service.server
✅ Backend: Cloudflare (healthy)
✅ Connection: Local stdio

📋 Installation Options:
  [1] Use existing MCP setup (recommended) - DRY principle ✨
  [2] Create independent hooks setup - legacy fallback

Choose option [1]:
```

--------------------------------

### Test Server Startup with SQLite Backend

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Pull-Request-Templates

Verify that the server starts correctly when the MCP_MEMORY_STORAGE_BACKEND is set to sqlite_vec.

```bash
export MCP_MEMORY_STORAGE_BACKEND=sqlite_vec && python -m mcp_memory_service.server
```

--------------------------------

### Configure Installer via Command Line

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/integration/multi-client.md

Use command line flags to automate or skip multi-client configuration during installation.

```bash
# Automatic multi-client setup (no prompts)
python install.py --setup-multi-client

# Skip the multi-client prompt entirely
python install.py --skip-multi-client-prompt

# Combined with other options
python install.py --storage-backend sqlite_vec --setup-multi-client
```

--------------------------------

### Install mcp-memory-service

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/blog/remote-mcp-tutorial.html

Clone the repository, set up a virtual environment, and install the package dependencies.

```bash
# Clone the repository
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service

# Create virtual environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
# or: venv\Scripts\activate  # Windows

# Install dependencies
pip install -e .
```

--------------------------------

### Example Workflow

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude_commands/README.md

Demonstrates a typical sequence of commands for starting a session and storing decisions.

```bash
# Start a development session (automatically tagged with machine hostname)
claude /memory-context --summary "Starting work on mDNS integration"

# Store important decisions (includes source:machine-name tag)
claude /memory-store --tags "mDNS,architecture" "Decided to use zeroconf library for service discovery"

# Continue development...
```

--------------------------------

### Complete Configuration Examples

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude-hooks/CONFIGURATION.md

Full configuration objects for different operational modes, including memory service, scoring weights, and git analysis settings.

```json
{
  "memoryService": {
    "maxMemoriesPerSession": 8,
    "recentFirstMode": true,
    "recentMemoryRatio": 0.6,
    "recentTimeWindow": "last-month",
    "fallbackTimeWindow": "last-3-months"
  },
  "memoryScoring": {
    "weights": {
      "timeDecay": 0.40,
      "tagRelevance": 0.25,
      "contentRelevance": 0.15,
      "contentQuality": 0.20,
      "conversationRelevance": 0.25
    },
    "minRelevanceScore": 0.4,
    "timeDecayRate": 0.05,
    "enableConversationContext": true
  },
  "gitAnalysis": {
    "enabled": true,
    "commitLookback": 14,
    "maxCommits": 20,
    "includeChangelog": true,
    "maxGitMemories": 3,
    "gitContextWeight": 1.8
  }
}
```

```json
{
  "memoryService": {
    "recentTimeWindow": "last-month",
    "fallbackTimeWindow": "last-3-months"
  },
  "memoryScoring": {
    "weights": {
      "timeDecay": 0.25,
      "tagRelevance": 0.35,
      "contentRelevance": 0.20,
      "contentQuality": 0.30,
      "conversationRelevance": 0.20
    },
    "minRelevanceScore": 0.3,
    "timeDecayRate": 0.03
  },
  "gitAnalysis": {
    "gitContextWeight": 1.0
  }
}
```

--------------------------------

### Go Project Configuration

Source: https://github.com/doobidoo/mcp-memory-service/wiki/12-Using-Agents-in-Other-Repositories

Example configuration for a Go project in .claude/project.json.

```json
{
  "projectType": "go",
  "versionFiles": [],
  "versioningStrategy": "git-tags",
  "lockFile": "go.sum",
  "lockCommand": "go mod tidy",
  "testCommand": "go test ./...",
  "fileExtensions": [".go"],
  "apiPaths": ["pkg/api/", "internal/"]
}
```

--------------------------------

### Install MCP Memory Service as a macOS System Service

Source: https://github.com/doobidoo/mcp-memory-service/wiki/02-Platform-Setup-Guide

Install the MCP Memory Service as a system-level daemon, which starts automatically on system boot. This requires administrator privileges (sudo).

```bash
sudo python scripts/install_service.py --system
```

```bash
sudo launchctl load /Library/LaunchDaemons/com.mcp.memory-service.plist
```

--------------------------------

### Initialize New Installation

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/architecture/graph-database-design.md

Set the storage mode before installing the service for new deployments.

```bash
export MCP_GRAPH_STORAGE_MODE=graph_only
pip install mcp-memory-service
```

--------------------------------

### Run Unified Installer

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/claude-hooks/README.md

Execute the unified installer to set up all available memory hook features.

```bash
cd claude-hooks
python install_hooks.py  # Installs all features
```

--------------------------------

### Quick Docker Setup

Source: https://github.com/doobidoo/mcp-memory-service/wiki/01-Installation-Guide

Commands to launch the service using Docker Compose for either MCP protocol or HTTP API modes.

```bash
docker-compose up -d
```

```bash
docker-compose -f docker-compose.http.yml up -d
curl http://localhost:8000/api/health
```

--------------------------------

### Verify Syntax and Installation

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/scripts/quality/README_PHASE1.md

Commands to verify code syntax, run unit tests, and perform manual installation checks.

```bash
python -m py_compile scripts/installation/install.py
```

```bash
pytest tests/unit/test_installation.py -v
```

```bash
python scripts/installation/install.py --storage-backend sqlite_vec
cat ~/.claude/claude_desktop_config.json | grep mcp-memory-service
```

```bash
pyscn analyze . --output .pyscn/reports/
```

--------------------------------

### Run Initial System Tests

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/natural-memory-triggers/installation-guide.md

Execute the test suite and verify component loading.

```bash
cd ~/.claude/hooks
node test-natural-triggers.js
```

```bash
node memory-mode-controller.js status
```

```bash
node -e "
const { TieredConversationMonitor } = require('./utilities/tiered-conversation-monitor');
const monitor = new TieredConversationMonitor();
console.log('✅ TieredConversationMonitor loaded successfully');
"
```

--------------------------------

### Count-Up Component Example

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/plans/2026-01-29-remotion-video-design.md

A React component that animates a number from a starting value to an ending value. It supports an optional suffix and a delay before the animation starts. Useful for displaying counts or financial figures.

```typescript
export const CountUp: React.FC<{ 
  from: number;
  to: number;
  suffix?: string;
  delay?: number;
}> = ({ from, to, suffix = '', delay = 0 }) => { 
  const frame = useCurrentFrame();
  const adjustedFrame = Math.max(0, frame - delay);

  const progress = spring({ 
    frame: adjustedFrame,
    config: { damping: 20, stiffness: 80 },
  });

  const value = interpolate(progress, [0, 1], [from, to]);
  const formatted = Math.floor(value).toLocaleString();

  return <div>{formatted}{suffix}</div>;
};
```

--------------------------------

### Install MCP Memory Service as a macOS User Service

Source: https://github.com/doobidoo/mcp-memory-service/wiki/02-Platform-Setup-Guide

Install the MCP Memory Service as a user-level LaunchAgent, which starts automatically on user login. The service configuration file will be located in `~/Library/LaunchAgents/`.

```bash
python scripts/install_service.py
```

--------------------------------

### Example: Claude Code MCP Configuration

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Issue-Templates

Illustrates the current Claude Code MCP memory configuration, showing the scope, status, type, command, and environment details. This is an example of the configuration that the installer should detect.

```bash
$ claude mcp get memory
memory:
  Scope: Local config (private to you in this project)
  Status: ✓ Connected
  Type: stdio
  Command: uv run python -m mcp_memory_service.server
  Environment: [Cloudflare backend configuration]
```

--------------------------------

### Startup Time Comparison

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/STORAGE_BACKENDS.md

Visual comparison of startup times between SQLite-vec and ChromaDB.

```text
SQLite-vec:  2-3 seconds     ████████████████████████████████
ChromaDB:    15-30 seconds   ████████
```

--------------------------------

### Install MCP Memory Service

Source: https://github.com/doobidoo/mcp-memory-service/wiki/14-Memory-Quality-System-Guide

Installs the MCP Memory Service using pip. The quality system is enabled by default with local SLM, requiring no API keys or external calls for basic setup.

```bash
# Install MCP Memory Service (if not already installed)
pip install mcp-memory-service

# Quality system is enabled by default with local SLM
# No API keys needed, no external calls
```

--------------------------------

### Configure Storage Backends for Docker

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/deployment/docker.md

Examples for running the service with either ChromaDB or SQLite-vec backends using Docker volumes.

```bash
# ChromaDB backend
docker run -d \
  -e MCP_MEMORY_STORAGE_BACKEND=chromadb \
  -e MCP_MEMORY_CHROMA_PATH=/app/chroma_db \
  -v $(pwd)/data/chroma_db:/app/chroma_db \
  mcp-memory-service

# SQLite-vec backend (recommended for containers)
docker run -d \
  -e MCP_MEMORY_STORAGE_BACKEND=sqlite_vec \
  -e MCP_MEMORY_SQLITE_PATH=/app/sqlite_data/memory.db \
  -v $(pwd)/data/sqlite_data:/app/sqlite_data \
  mcp-memory-service
```

--------------------------------

### Start ChromaDB Server with Authentication

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/guides/STORAGE_BACKENDS.md

Use this command to start a ChromaDB server with token-based authentication enabled. Ensure the volume mount path for Chroma data is correctly specified.

```bash
docker run -p 8000:8000 \
  -e CHROMA_SERVER_AUTH_CREDENTIALS_PROVIDER="chromadb.auth.token.TokenConfigServerAuthCredentialsProvider" \
  -e CHROMA_SERVER_AUTH_PROVIDER="chromadb.auth.token.TokenAuthServerProvider" \
  -e CHROMA_SERVER_AUTH_TOKEN_TRANSPORT_HEADER="X_CHROMA_TOKEN" \
  -e CHROMA_SERVER_AUTH_CREDENTIALS="test-token" \
  -v /path/to/chroma-data:/chroma/chroma \
  chromadb/chroma
```

--------------------------------

### Initialize MCP Memory Service Server

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/examples/README.md

Commands to install dependencies, configure environment variables, and start the HTTP server.

```bash
# On your server machine
cd mcp-memory-service
python install.py --server-mode --storage-backend sqlite_vec
export MCP_HTTP_HOST=0.0.0.0
export MCP_API_KEY="your-secure-key"
python scripts/run_http_server.py
```

--------------------------------

### Expose Service with Cloudflare Tunnel

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/blog/remote-mcp-tutorial.html

Install the cloudflared utility and start a temporary tunnel to expose the local server to the internet.

```bash
# macOS
brew install cloudflared

# Linux
wget https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb
sudo dpkg -i cloudflared-linux-amd64.deb

# Start tunnel
cloudflared tunnel --url http://localhost:8765
```

--------------------------------

### Setup Code Quality Guard Agent

Source: https://github.com/doobidoo/mcp-memory-service/wiki/10-Complete-Feature-List

Install the pre-commit hook and configure the LLM environment for automated quality analysis.

```bash
# Install hook
ln -s ../../scripts/hooks/pre-commit .git/hooks/pre-commit

# Configure LLM (Groq recommended)
export GROQ_API_KEY="your-groq-api-key"
# Falls back to Gemini CLI if Groq unavailable
```

--------------------------------

### Configure Groq API for Code Quality Guard

Source: https://github.com/doobidoo/mcp-memory-service/wiki/11-Agent-Integrations-Guide

Setup instructions for the recommended Groq API integration.

```bash
# Get API key from https://console.groq.com/keys
export GROQ_API_KEY="your-groq-api-key"

# Add to .env (persistent)
echo 'GROQ_API_KEY="your-groq-api-key"' >> .env

# Test
./scripts/utils/groq "What is 2+2?"
```

--------------------------------

### Setup Remote MCP for claude.ai

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/README.md

Commands to start the server in HTTP mode and expose it via a tunnel for browser-based access.

```bash
# 1. Start server with Remote MCP
MCP_STREAMABLE_HTTP_MODE=1 python -m mcp_memory_service.server

# 2. Expose publicly (Cloudflare Tunnel)
cloudflared tunnel --url http://localhost:8765

# 3. Add connector in claude.ai Settings → Connectors with the tunnel URL
```

--------------------------------

### Verify Development Environment

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/CONTRIBUTING.md

Execute this script after installation to ensure all necessary components are correctly set up.

```bash
python scripts/verify_environment.py
```

--------------------------------

### MCP Memory Service - Quick Start

Source: https://github.com/doobidoo/mcp-memory-service/wiki/Claude-Code-Commands-Wiki

Quick steps to clone the repository, install Claude Code commands, and test the memory health.

```APIDOC
## Quick Start

```bash
git clone https://github.com/doobidoo/mcp-memory-service.git
cd mcp-memory-service
python install.py --install-claude-commands
claude /memory-health  # Test it works!
```
```

--------------------------------

### Locate installation logic in main

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/plans/2026-02-23-permission-hook-opt-in.md

Identifies the existing installation logic block in the main function for context.

```python
install_all = not (args.basic or args.natural_triggers or args.auto_capture) or args.all
install_basic = args.basic or install_all
install_natural_triggers = args.natural_triggers or install_all
install_auto_capture = args.auto_capture or install_all
```

--------------------------------

### Migrate memory_quality tool parameters

Source: https://github.com/doobidoo/mcp-memory-service/blob/main/docs/MIGRATION.md

Examples show the transformation of parameters for the memory_quality tool. Use these to update calls to rate, get, and analyze memory quality.

```json
{"content_hash": "abc", "rating": 1} → {"action": "rate", "content_hash": "abc", "rating": 1}
```

```json
{"content_hash": "abc"} → {"action": "get", "content_hash": "abc"}
```

```json
{"min_quality": 0.5} → {"action": "analyze", "min_quality": 0.5}
```