Skip to content

CONTINUE_SETUP.md

Latest commit

 

History

History
392 lines (278 loc) · 8.38 KB

CONTINUE_SETUP.md

File metadata and controls

392 lines (278 loc) · 8.38 KB
Raw

MemoryGraph Setup for Continue.dev

Get persistent memory working with Continue in VS Code or JetBrains IDEs.

Prerequisites

  • Continue extension installed (VS Code or JetBrains)
  • Python 3.10+
  • pipx installed (pip install --user pipx && pipx ensurepath)

Choose Your Backend

MemoryGraph supports two backend options:

Feature Local (SQLite) Cloud
Setup Zero-config API key required
Data Location ~/.memorygraph/ memorygraph.dev
Multi-device No Yes
Team sharing No Yes
Offline Yes No
Cost Free Free tier available

New users: We recommend starting with Cloud for multi-device sync, or Local for single-machine use.

Quick Start (Local Backend)

1. Install MemoryGraph

pipx install memorygraphMCP

Verify installation:

memorygraph --version

2. Configure Continue

Continue supports MCP configuration in multiple formats.

Option A: YAML Configuration (Recommended)

Create .continue/config.yaml in your home directory or project:

mcpServers:
  - name: memorygraph
    command: memorygraph
    args: []

Option B: JSON Configuration

Create .continue/config.json:

{
  "mcpServers": [
    {
      "name": "memorygraph",
      "command": "memorygraph",
      "args": []
    }
  ]
}

Option C: Copy from Other Clients

Continue can use JSON configs from Claude Code, Cursor, or Cline. Copy your existing mcp.json to .continue/mcpServers/memorygraph.json:

{
  "command": "memorygraph",
  "args": []
}

3. Enable Agent Mode

MCP servers only work in Continue's Agent mode:

  1. Open Continue sidebar
  2. Look for the mode selector
  3. Switch to Agent mode (not Chat or Edit)

4. Restart Continue

Reload your IDE or restart the Continue extension to load MCP servers.

5. Verify Connection

In Continue (Agent mode), type:

@MCP What memory tools are available?

Or simply ask:

What tools do you have for storing memories?

First Memory

Store a memory:

Store this for later: Always run tests before committing in this repo

Retrieve it:

What should I do before committing code?

Quick Start (Cloud Backend)

Cloud backend syncs memories across all your devices and enables team collaboration.

1. Get Your API Key

  1. Sign up at app.memorygraph.dev
  2. Copy your API key (starts with mg_)

2. Install MemoryGraph

pipx install memorygraphMCP

3. Configure Continue with Cloud Backend

YAML Configuration (recommended):

mcpServers:
  - name: memorygraph
    command: memorygraph
    args:
      - "--backend"
      - "cloud"
    env:
      MEMORYGRAPH_API_KEY: "mg_your_api_key_here"

JSON Configuration:

{
  "mcpServers": [
    {
      "name": "memorygraph",
      "command": "memorygraph",
      "args": ["--backend", "cloud"],
      "env": {
        "MEMORYGRAPH_API_KEY": "mg_your_api_key_here"
      }
    }
  ]
}

4. Restart Continue and Verify

  1. Reload your IDE or restart Continue
  2. Switch to Agent mode
  3. Ask: "What tools do you have for storing memories?"

Migrating from Local to Cloud

Already using local SQLite and want to switch to cloud?

Step 1: Export Local Memories

memorygraph export --output memories-backup.json

Step 2: Import to Cloud

export MEMORYGRAPH_API_KEY=mg_your_key_here
memorygraph import --backend cloud --input memories-backup.json

Step 3: Update Continue Configuration

Update your .continue/config.yaml:

mcpServers:
  - name: memorygraph
    command: memorygraph
    args:
      - "--backend"
      - "cloud"
    env:
      MEMORYGRAPH_API_KEY: "mg_your_api_key_here"

Step 4: Restart Continue

Reload your IDE to apply the new configuration.

See CLOUD_BACKEND.md for detailed migration options.

Configuration Options

Extended Mode with More Tools

mcpServers:
  - name: memorygraph
    command: memorygraph
    args:
      - "--profile"
      - "extended"

Custom Database Path

mcpServers:
  - name: memorygraph
    command: memorygraph
    env:
      MEMORY_SQLITE_PATH: "/path/to/memory.db"

Full Path (Recommended)

mcpServers:
  - name: memorygraph
    command: /Users/yourname/.local/bin/memorygraph
    args: []

Find your path: which memorygraph

Project-Specific Configuration

Create .continue/config.yaml in your project root:

mcpServers:
  - name: memorygraph
    command: memorygraph
    env:
      MEMORY_SQLITE_PATH: "./.continue/memory.db"

Configuration Locations

Continue looks for configuration in this order:

  1. Project: .continue/config.yaml in workspace
  2. User: ~/.continue/config.yaml
  3. MCP Servers Directory: ~/.continue/mcpServers/*.json

Troubleshooting

MCP Tools Not Available

  1. Verify Agent mode - MCP only works in Agent mode, not Chat or Edit
  2. Check configuration syntax - YAML is indent-sensitive
  3. Reload Continue - Use the reload button or restart IDE

Server Not Starting

  1. Test memorygraph directly:

    memorygraph --version

  2. Check PATH:

    which memorygraph

  3. Use full path in configuration if needed

View Logs

  • VS Code: View > Output > Select "Continue" from dropdown
  • JetBrains: View > Tool Windows > Continue > Logs tab

Common Errors

"Command not found"

# Use full path instead
mcpServers:
  - name: memorygraph
    command: /Users/yourname/.local/bin/memorygraph

"Connection refused"

  • Ensure no other process is using the server
  • Check if memorygraph is installed correctly

"MCP protocol error"

  • Update Continue to latest version
  • Verify memorygraph version: memorygraph --version

Tips for Continue Users

  1. Use @MCP mention to explicitly invoke MCP tools
  2. Agent mode is key - Regular chat doesn't have MCP access
  3. Combine with Continue's context - Use @file and @folder with memory
  4. Share configs - Continue configs work across VS Code and JetBrains

Recommended: Memory Protocol

Add this to .continuerules or your Continue config for automatic memory usage:

## Memory Protocol

### REQUIRED: Before Starting Work
You MUST use `recall_memories` before any task. Query by project, tech, or task type.

### REQUIRED: Automatic Storage Triggers
Store memories on ANY of:
- **Git commit** → what was fixed/added
- **Bug fix** → problem + solution
- **Version release** → summarize changes
- **Architecture decision** → choice + rationale
- **Pattern discovered** → reusable approach

### Timing Mode (default: on-commit)
`memory_mode: immediate | on-commit | session-end`

### Memory Fields
- **Type**: solution | problem | code_pattern | fix | error | workflow
- **Title**: Specific, searchable (not generic)
- **Content**: Accomplishment, decisions, patterns
- **Tags**: project, tech, category (REQUIRED)
- **Importance**: 0.8+ critical, 0.5-0.7 standard, 0.3-0.4 minor
- **Relationships**: Link related memories when they exist

Do NOT wait to be asked. Memory storage is automatic.

File locations:

  • Project-specific: .continuerules in project root
  • User-level: ~/.continue/config.yaml under systemMessage

Continue-Specific Features

Continue's MCP integration works well for:

  • Storing code patterns you discover during reviews
  • Remembering debugging solutions across projects
  • Tracking API behaviors and quirks
  • Building project knowledge over time

JetBrains-Specific Notes

For JetBrains IDEs (IntelliJ, PyCharm, WebStorm, etc.):

  1. Install Continue plugin from JetBrains Marketplace
  2. Configuration is the same as VS Code
  3. Config location: ~/.continue/config.yaml
  4. Access via Tools > Continue or the sidebar

Next Steps

Works with: Continue.dev (VS Code and JetBrains) Transport: stdio Profiles: core (9 tools), extended (11 tools) Config formats: YAML, JSON