feat(continue): add Continue.dev integration via HTTP context provider (#2213)

Adds hindsight-continue: Hindsight memory for Continue.dev via its native http context provider (@hindsight recall) plus an optional MCP-server + rules setup. Includes the adapter package, tests against Continue's HTTP contract + a gated E2E, CI job, release registration, docs, and registry entry.

Author: DK09876

.github/workflows/test.yml

@@ -37,6 +37,7 @@ jobs:
       integrations-claude-code: ${{ steps.filter.outputs.integrations-claude-code }}
       integrations-cline: ${{ steps.filter.outputs.integrations-cline }}
       integrations-codex: ${{ steps.filter.outputs.integrations-codex }}
+      integrations-continue: ${{ steps.filter.outputs.integrations-continue }}
       integrations-cursor-cli: ${{ steps.filter.outputs.integrations-cursor-cli }}
       integrations-crewai: ${{ steps.filter.outputs.integrations-crewai }}
       integrations-litellm: ${{ steps.filter.outputs.integrations-litellm }}
@@ -136,6 +137,8 @@ jobs:
             - 'hindsight-integrations/cline/**'
           integrations-codex:
             - 'hindsight-integrations/codex/**'
+          integrations-continue:
+            - 'hindsight-integrations/continue/**'
           integrations-cursor-cli:
             - 'hindsight-integrations/cursor-cli/**'
           integrations-crewai:
@@ -3054,6 +3057,45 @@ jobs:
       # (requires_real_llm) needs a live Hindsight server and runs separately.
       run: uv run pytest tests -v -m "not requires_real_llm"
 
+  test-continue-integration:
+    needs: [detect-changes]
+    if: >-
+      (github.event_name == 'workflow_dispatch' ||
+      needs.detect-changes.outputs.integrations-continue == 'true' ||
+      needs.detect-changes.outputs.ci == 'true')
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+    - uses: actions/checkout@v6
+      with:
+        ref: ${{ github.event.pull_request.head.sha || '' }}
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v7
+      with:
+        enable-cache: true
+        prune-cache: false
+
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version-file: ".python-version"
+
+    - name: Build continue integration
+      working-directory: ./hindsight-integrations/continue
+      run: uv build
+
+    - name: Install dependencies
+      working-directory: ./hindsight-integrations/continue
+      run: uv sync --frozen
+
+    - name: Run tests
+      working-directory: ./hindsight-integrations/continue
+      # PR CI runs only the deterministic bucket; the real-LLM E2E bucket
+      # (requires_real_llm) needs a live Hindsight server and runs separately.
+      run: uv run pytest tests -v -m "not requires_real_llm"
+
   test-smolagents-integration:
     needs: [detect-changes]
     if: >-
@@ -4616,6 +4658,7 @@ jobs:
       - test-integration
       - test-ag2-integration
       - test-autogen-integration
+      - test-continue-integration
       - test-smolagents-integration
       - test-dify-integration
       - test-flowise-integration

hindsight-docs/docs-integrations/continue.md

@@ -0,0 +1,54 @@
+---
+sidebar_position: 36
+title: "Continue.dev Persistent Memory with Hindsight | Integration"
+description: "Add long-term memory to the Continue.dev coding assistant with Hindsight. Recall project memory into chat with @hindsight, plus optional automatic recall/retain via the Hindsight MCP server."
+---
+
+# Continue
+
+Long-term memory for the [Continue.dev](https://continue.dev) coding assistant, powered by [Hindsight](https://vectorize.io/hindsight). Recall relevant project memory directly into chat, and optionally let the agent recall and retain automatically in agent mode.
+
+## How It Works
+
+Continue has no hook that runs before a message is sent, but it supports two native extension points that `hindsight-continue` uses:
+
+- **HTTP context provider (precise recall):** type `@hindsight <query>` (or a bare `@hindsight`) in Continue chat and relevant memory is recalled and injected into the model's context **at query time**. The package ships a small adapter server that implements Continue's HTTP context-provider contract (`{query, fullInput, options, workspacePath}` → context items) on top of Hindsight recall.
+- **MCP server + rules (automatic):** point Continue's agent mode at the Hindsight MCP server for `retain`/`recall`/`reflect` tools, with a rules file that instructs the agent to recall at the start of every task and retain durable facts.
+
+Memory is scoped per **bank** — use one bank per project so context from one codebase doesn't leak into another.
+
+## Setup
+
+```bash
+pip install hindsight-continue
+```
+
+Run the adapter, pointing it at your Hindsight instance and bank:
+
+```bash
+export HINDSIGHT_API_KEY=hsk_...
+export HINDSIGHT_CONTINUE_BANK_ID=my-project
+hindsight-continue            # serves on 127.0.0.1:8123
+```
+
+Then register it in Continue's `config.yaml`:
+
+```yaml
+context:
+  - provider: http
+    params:
+      url: "http://127.0.0.1:8123/"
+      title: hindsight
+      displayTitle: Hindsight
+      description: Recall long-term memory from Hindsight
+```
+
+Use a [Hindsight Cloud](https://hindsight.vectorize.io) key, or point at a self-hosted server with `HINDSIGHT_API_URL=http://localhost:8888`.
+
+## Automatic recall (optional)
+
+For hands-off recall and retain in agent mode, wire the Hindsight MCP server into Continue and add a "recall first" rule. See the [`examples/.continue/`](https://github.com/vectorize-io/hindsight/tree/main/hindsight-integrations/continue/examples/.continue) assets in the integration directory.
+
+## Limitation
+
+Continue has no pre-prompt hook, so memory cannot be injected fully passively on every message. The `@hindsight` provider gives precise, query-time recall on demand; the MCP + rules setup gives automatic recall in agent mode, subject to the agent following the rule.

hindsight-docs/src/data/integrations.json

@@ -150,6 +150,16 @@
       "link": "/sdks/integrations/codex",
       "icon": "/img/icons/codex.svg"
     },
+    {
+      "id": "continue",
+      "name": "Continue",
+      "description": "Long-term memory for the Continue.dev coding assistant. Recall relevant project memory into chat with @hindsight, plus optional automatic recall/retain via the Hindsight MCP server.",
+      "type": "official",
+      "by": "hindsight",
+      "category": "tool",
+      "link": "/sdks/integrations/continue",
+      "icon": "/img/icons/continue.png"
+    },
     {
       "id": "cursor",
       "name": "Cursor",

hindsight-docs/static/img/icons/continue.png

@@ -12,6 +12,7 @@ Each integration lives in its own subdirectory with its own README, configuratio
 | [**OpenCode**](./opencode) | TypeScript plugin with retain/recall/reflect tools, auto-retain on idle, memory injection on session start, compaction preservation. | Add `@vectorize-io/opencode-hindsight` to `opencode.json` |
 | [**Codex CLI**](./codex) | Python hook scripts for OpenAI's Codex CLI. Auto-recall on `UserPromptSubmit`, auto-retain on `Stop`. | `curl -fsSL https://hindsight.vectorize.io/get-codex \| bash` |
 | [**Cursor CLI**](./cursor-cli) | Python hook scripts for Cursor CLI. Auto-recall on `beforeSubmitPrompt`, auto-retain on `stop`, final flush on `sessionEnd`. | `./scripts/install.sh` |
+| [**Continue.dev**](./continue) | HTTP context provider for precise `@hindsight` recall in chat, plus optional MCP-server + rules for automatic recall/retain in agent mode. | `pip install hindsight-continue` |
 | [**Roo Code**](./roo-code) | Persistent memory for Roo Code VS Code extension. | See README |
 | [**Hermes (OpenAI Agents SDK)**](./hermes) | Memory layer for OpenAI Agents SDK. | See README |
 | [**Grok Build**](./grok-build) | Hooks for Grok Build (xAI). | See README |

hindsight-integrations/README.md

@@ -0,0 +1,106 @@
+# hindsight-continue
+
+[Continue.dev](https://continue.dev) integration for [Hindsight](https://github.com/vectorize-io/hindsight) — persistent long-term memory for your coding assistant.
+
+Continue has no plugin hook that runs before a message is sent, but it does
+support two native extension points that this integration uses:
+
+1. **HTTP context provider** — type `@hindsight <query>` (or a bare `@hindsight`)
+   in chat and relevant memory is recalled and injected into the model's context
+   **at query time**. This package ships a tiny adapter server that implements
+   Continue's HTTP context-provider contract on top of Hindsight recall.
+2. **MCP server + rules** (optional) — wire the Hindsight MCP server into
+   Continue's agent mode for `retain`/`recall`/`reflect` tools, with a rules file
+   that tells the agent to recall automatically.
+
+## Prerequisites
+
+- A running Hindsight instance ([self-hosted via Docker](https://github.com/vectorize-io/hindsight#quick-start) or [Hindsight Cloud](https://ui.hindsight.vectorize.io/signup))
+- Continue (VS Code or JetBrains extension)
+- Python 3.10+
+
+## Installation
+
+```bash
+pip install hindsight-continue
+```
+
+## Quick start (HTTP context provider)
+
+**1. Run the adapter**, pointing it at your Hindsight instance and bank:
+
+```bash
+export HINDSIGHT_API_KEY=hsk_...            # omit for a local self-hosted server
+export HINDSIGHT_API_URL=http://localhost:8888   # defaults to Hindsight Cloud
+export HINDSIGHT_CONTINUE_BANK_ID=my-project
+
+hindsight-continue            # serves on 127.0.0.1:8123
+```
+
+**2. Register it** in Continue's `config.yaml` (`~/.continue/config.yaml` or a
+workspace `.continue` block):
+
+```yaml
+context:
+  - provider: http
+    params:
+      url: "http://127.0.0.1:8123/"
+      title: hindsight
+      displayTitle: Hindsight
+      description: Recall long-term memory from Hindsight
+```
+
+**3. Use it.** In Continue chat, type `@hindsight` (optionally followed by what
+you want to recall) and the matching memories are added to the model's context.
+
+The adapter receives Continue's request (`{query, fullInput, options, workspacePath}`),
+recalls from Hindsight, and returns context items shaped `{name, description, content}` —
+exactly what Continue expects.
+
+### Per-request bank override
+
+The configured `HINDSIGHT_CONTINUE_BANK_ID` is the default. A request may target
+a different bank by sending `options.bankId`:
+
+```yaml
+context:
+  - provider: http
+    params:
+      url: "http://127.0.0.1:8123/"
+      options:
+        bankId: another-bank
+```
+
+## Optional: automatic recall via MCP + rules
+
+For hands-off recall/retain in **agent mode**, point Continue at the Hindsight
+MCP server and add a rule telling the agent to call it. Example assets are in
+[`examples/.continue/`](./examples/.continue):
+
+- [`examples/.continue/mcpServers/hindsight.yaml`](./examples/.continue/mcpServers/hindsight.yaml) — the MCP server block
+- [`examples/.continue/rules/hindsight.md`](./examples/.continue/rules/hindsight.md) — "always recall first" rule
+
+## Configuration
+
+| Env var | Description | Default |
+| --- | --- | --- |
+| `HINDSIGHT_API_KEY` | Hindsight API key | _(none; required for Cloud)_ |
+| `HINDSIGHT_API_URL` | Hindsight API URL | `https://api.hindsight.vectorize.io` |
+| `HINDSIGHT_CONTINUE_BANK_ID` | Default memory bank to recall against | _(none)_ |
+| `HINDSIGHT_CONTINUE_HOST` | Adapter bind host | `127.0.0.1` |
+| `HINDSIGHT_CONTINUE_PORT` | Adapter listen port | `8123` |
+
+These can also be set programmatically via `configure(...)`. See `hindsight-continue --help`
+for CLI flags.
+
+## Development
+
+```bash
+uv sync
+uv run pytest tests -v -m 'not requires_real_llm'   # deterministic suite
+uv run pytest tests -v -m requires_real_llm          # gated live E2E (needs a Hindsight server)
+```
+
+## License
+
+MIT

hindsight-integrations/continue/README.md

@@ -0,0 +1,19 @@
+name: Hindsight
+version: 0.0.1
+schema: v1
+mcpServers:
+  # Hindsight Cloud (remote HTTP MCP). The bank is the last path segment;
+  # change `my-project` to your bank, and replace the token with your API key.
+  - name: Hindsight
+    type: streamable-http
+    url: https://api.hindsight.vectorize.io/mcp/my-project/
+    requestOptions:
+      headers:
+        Authorization: "Bearer YOUR_HINDSIGHT_API_KEY"
+
+  # Self-hosted / local alternative. Start a local Hindsight first:
+  #   HINDSIGHT_API_LLM_API_KEY=sk-... uvx --from hindsight-api hindsight-local-mcp
+  # then point Continue at its open MCP endpoint (no auth needed by default):
+  # - name: Hindsight (local)
+  #   type: streamable-http
+  #   url: http://localhost:8888/mcp/my-project/

hindsight-integrations/continue/examples/.continue/mcpServers/hindsight.yaml

@@ -0,0 +1,14 @@
+---
+name: Hindsight memory
+alwaysApply: true
+---
+
+You have a persistent long-term memory through the Hindsight MCP server.
+
+- At the start of every task, call the `recall` tool with the user's request to
+  retrieve relevant past decisions, preferences, and project context before you
+  answer. Use what's relevant and ignore the rest.
+- When you learn a durable fact — an architectural decision, a user preference,
+  a convention, or something worth remembering across sessions — call the
+  `retain` tool to store it.
+- Do not mention these memory operations unless the user asks about them.

hindsight-integrations/continue/examples/.continue/rules/hindsight.md

@@ -0,0 +1,43 @@
+"""Hindsight-Continue: persistent memory for Continue.dev.
+
+Exposes Hindsight memory to Continue through its native ``http`` context
+provider. Run the adapter server and point Continue at it; typing
+``@hindsight <query>`` (or a bare ``@hindsight``) recalls relevant long-term
+memory and injects it into the model's context at query time.
+
+Basic usage::
+
+    from hindsight_continue import configure, run
+
+    configure(bank_id="my-project", api_key="hsk_...")
+    run()  # serves the context-provider endpoint on 127.0.0.1:8123
+
+See the README for the matching Continue ``config.yaml`` snippet, plus the
+optional MCP-server + rules setup for automatic recall/retain in agent mode.
+"""
+
+from .config import (
+    HindsightContinueConfig,
+    configure,
+    get_config,
+    reset_config,
+)
+from .errors import HindsightError
+from .provider import ContextItem, build_context_items, serialize
+from .server import build_server, make_handler, run
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "configure",
+    "get_config",
+    "reset_config",
+    "HindsightContinueConfig",
+    "HindsightError",
+    "ContextItem",
+    "build_context_items",
+    "serialize",
+    "build_server",
+    "make_handler",
+    "run",
+]

hindsight-integrations/continue/hindsight_continue/__init__.py

@@ -0,0 +1,42 @@
+"""Shared Hindsight client resolution logic."""
+
+from __future__ import annotations
+
+import os
+from importlib import metadata
+from typing import Any
+
+from hindsight_client import Hindsight
+
+from .config import DEFAULT_HINDSIGHT_API_URL, HINDSIGHT_API_KEY_ENV, get_config
+
+try:
+    _VERSION = metadata.version("hindsight-continue")
+except metadata.PackageNotFoundError:
+    _VERSION = "0.0.0"
+_USER_AGENT = f"hindsight-continue/{_VERSION}"
+
+
+def resolve_client(
+    client: Hindsight | None = None,
+    hindsight_api_url: str | None = None,
+    api_key: str | None = None,
+) -> Hindsight:
+    """Resolve a Hindsight client from explicit args or global config.
+
+    Falls back to the configured/default API URL and the ``HINDSIGHT_API_KEY``
+    env var so the adapter works with nothing but the env var set. The API key
+    is optional at construction time — a missing key only fails when a recall
+    is actually made.
+    """
+    if client is not None:
+        return client
+
+    config = get_config()
+    url = hindsight_api_url or config.hindsight_api_url or DEFAULT_HINDSIGHT_API_URL
+    key = api_key or config.api_key or os.environ.get(HINDSIGHT_API_KEY_ENV)
+
+    kwargs: dict[str, Any] = {"base_url": url, "timeout": 30.0, "user_agent": _USER_AGENT}
+    if key:
+        kwargs["api_key"] = key
+    return Hindsight(**kwargs)