feat(zed): add Zed editor integration (MCP context server + recall/retain rule) (#2153)

MCP-only Zed integration: hindsight-zed init wires the Hindsight MCP server into Zed's settings.json (via mcp-remote) plus a recall/retain rule in AGENTS.md. Validated end-to-end in real Zed.

Author: DK09876

.github/workflows/test.yml

@@ -50,6 +50,7 @@ jobs:
       integrations-paperclip: ${{ steps.filter.outputs.integrations-paperclip }}
       integrations-opencode: ${{ steps.filter.outputs.integrations-opencode }}
       integrations-cursor: ${{ steps.filter.outputs.integrations-cursor }}
+      integrations-zed: ${{ steps.filter.outputs.integrations-zed }}
       integrations-n8n: ${{ steps.filter.outputs.integrations-n8n }}
       integrations-zapier: ${{ steps.filter.outputs.integrations-zapier }}
       integrations-cloudflare-oauth-proxy: ${{ steps.filter.outputs.integrations-cloudflare-oauth-proxy }}
@@ -166,6 +167,8 @@ jobs:
             - 'hindsight-integrations/opencode/**'
           integrations-cursor:
             - 'hindsight-integrations/cursor/**'
+          integrations-zed:
+            - 'hindsight-integrations/zed/**'
           integrations-n8n:
             - 'hindsight-integrations/n8n/**'
           integrations-zapier:
@@ -488,6 +491,37 @@ jobs:
       working-directory: ./hindsight-integrations/cursor
       run: python -m pytest tests/ -v
 
+  test-zed-integration:
+    needs: [detect-changes]
+    if: >-
+      github.event_name != 'pull_request_review' &&
+      (github.event_name == 'workflow_dispatch' ||
+      needs.detect-changes.outputs.integrations-zed == 'true' ||
+      needs.detect-changes.outputs.ci == 'true')
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v6
+      with:
+        ref: ${{ github.event.pull_request.head.sha || '' }}
+
+    - name: Set up Python
+      uses: actions/setup-python@v6
+      with:
+        python-version: '3.11'
+
+    - name: Install package and pytest
+      working-directory: ./hindsight-integrations/zed
+      # Installs the package (incl. the zstandard runtime dep) so the threads.db
+      # reader tests can decompress Zed's zstd blobs.
+      run: pip install -e . pytest
+
+    - name: Run tests
+      working-directory: ./hindsight-integrations/zed
+      # PR CI runs only the deterministic bucket; the real-LLM E2E bucket
+      # (requires_real_llm) needs a live Hindsight server and runs separately.
+      run: python -m pytest tests/ -v -m "not requires_real_llm"
+
   test-omo-integration:
     needs: [detect-changes]
     if: >-

hindsight-docs/docs-integrations/zed.md

@@ -0,0 +1,43 @@
+---
+sidebar_position: 7
+title: "Zed Persistent Memory with Hindsight | Integration"
+description: "Add long-term memory to the Zed editor's AI assistant with Hindsight via MCP. One command wires up the Hindsight MCP server plus a recall/retain rule, so memory works automatically in the Agent Panel."
+---
+
+# Zed
+
+Long-term memory for the [Zed](https://zed.dev) editor's AI assistant, powered by [Hindsight](https://vectorize.io/hindsight). One command connects Zed's Agent Panel to the Hindsight MCP server and adds a rule telling the agent to use it — so it recalls relevant memory at the start of a task and retains durable facts as it goes. Recall happens at query time against your actual message, and from your seat it's automatic.
+
+## How It Works
+
+Zed has no pre-prompt hook, but it supports two things this integration uses:
+
+- **MCP context servers:** Zed runs MCP servers configured under `context_servers` in `settings.json` and surfaces their tools in the Agent Panel. `hindsight-zed` registers the Hindsight MCP server there, giving the agent `recall` / `retain` / `reflect` tools.
+- **A global instructions file** (`~/.config/zed/AGENTS.md`) that Zed includes in every conversation. The integration adds a small rule there telling the agent to recall first and retain what it learns.
+
+Zed doesn't yet have native HTTP-MCP transport, so the server is connected through the [`mcp-remote`](https://www.npmjs.com/package/mcp-remote) stdio bridge (run via `npx`), which means Node.js must be installed.
+
+## Setup
+
+```bash
+pip install hindsight-zed
+hindsight-zed init --api-token YOUR_HINDSIGHT_API_KEY --bank-id my-memory
+```
+
+`init` adds the `hindsight` MCP server to `~/.config/zed/settings.json` and the recall/retain rule to `~/.config/zed/AGENTS.md`. Restart Zed, open the Agent Panel, and the `hindsight` server should show a green dot.
+
+Use a [Hindsight Cloud](https://hindsight.vectorize.io) key, or point at a self-hosted server with `--api-url http://localhost:8888` (no token needed for an open local server). If your `settings.json` has comments (JSONC), `init` prints the entry to paste rather than rewriting the file — or run `hindsight-zed init --print-only` anytime.
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `hindsight-zed init` | Add the MCP server + recall/retain rule |
+| `hindsight-zed status` | Show whether the server + rule are configured |
+| `hindsight-zed uninstall` | Remove the server + rule |
+
+## Note
+
+Recall and retain run through MCP tools the agent calls, guided by the always-on rule. This makes recall query-time precise (no lag), with the tradeoff that it relies on the agent following the "recall first" instruction rather than the editor enforcing it.
+
+See the [package README](https://github.com/vectorize-io/hindsight/tree/main/hindsight-integrations/zed) for full configuration options.

hindsight-docs/src/data/integrations.json

@@ -180,6 +180,16 @@
       "link": "/sdks/integrations/cursor",
       "icon": "/img/icons/cursor.svg"
     },
+    {
+      "id": "zed",
+      "name": "Zed",
+      "description": "Long-term memory for the Zed editor's AI assistant via the Hindsight MCP server. One command wires up the MCP context server plus a recall/retain rule, so memory works automatically in the Agent Panel.",
+      "type": "official",
+      "by": "hindsight",
+      "category": "tool",
+      "link": "/sdks/integrations/zed",
+      "icon": "/img/icons/zed.svg"
+    },
     {
       "id": "cline",
       "name": "Cline",

hindsight-docs/static/img/icons/zed.svg

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+*.pyc

hindsight-integrations/zed/.gitignore

@@ -0,0 +1,99 @@
+# hindsight-zed
+
+Long-term memory for the [Zed](https://zed.dev) editor's AI assistant, powered by
+[Hindsight](https://github.com/vectorize-io/hindsight).
+
+`hindsight-zed init` wires Zed's Agent Panel to the Hindsight **MCP server** and
+adds a rule telling the agent to use it — so it recalls relevant memory at the
+start of a task and retains durable facts as it goes. Recall happens at query
+time against your actual message (no lag), and from your seat it's automatic.
+
+## How it works
+
+Zed has no pre-prompt hook, but it does support two things this integration uses:
+
+- **MCP context servers** — Zed runs MCP servers configured under
+  `context_servers` in `settings.json` and exposes their tools in the Agent
+  Panel. We register the Hindsight MCP server there, giving the agent
+  `recall` / `retain` / `reflect` tools.
+- **A global instructions file** (`~/.config/zed/AGENTS.md`) that Zed includes in
+  every conversation. We add a small rule there telling the agent to recall
+  first and retain what it learns.
+
+Zed doesn't yet have native HTTP-MCP transport, so the server is connected
+through the [`mcp-remote`](https://www.npmjs.com/package/mcp-remote) stdio bridge
+(run via `npx`) — that means you need Node.js installed.
+
+## Install
+
+```bash
+pip install hindsight-zed
+hindsight-zed init --api-token YOUR_HINDSIGHT_API_KEY --bank-id my-memory
+```
+
+`init` adds the `hindsight` MCP server to `~/.config/zed/settings.json` and the
+recall/retain rule to `~/.config/zed/AGENTS.md`. Restart Zed, open the Agent
+Panel, and the `hindsight` server should show a green dot.
+
+Use a [Hindsight Cloud](https://hindsight.vectorize.io) key, or point at a
+self-hosted server with `--api-url http://localhost:8888` (no token needed for an
+open local server).
+
+> If your `settings.json` contains comments (JSONC), `init` won't rewrite it —
+> it prints the exact `context_servers` entry for you to paste instead. Use
+> `hindsight-zed init --print-only` any time to see the snippet without writing.
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `hindsight-zed init` | Add the MCP server + recall/retain rule |
+| `hindsight-zed status` | Show whether the server + rule are configured |
+| `hindsight-zed uninstall` | Remove the server + rule |
+| `hindsight-zed init --print-only` | Print the config to add manually |
+
+## What gets written
+
+`~/.config/zed/settings.json`:
+
+```jsonc
+{
+  "context_servers": {
+    "hindsight": {
+      "source": "custom",
+      "command": "npx",
+      "args": [
+        "-y", "mcp-remote",
+        "https://api.hindsight.vectorize.io/mcp/my-memory/",
+        "--header", "Authorization: Bearer YOUR_HINDSIGHT_API_KEY"
+      ]
+    }
+  }
+}
+```
+
+`~/.config/zed/AGENTS.md` (inside a fenced `<!-- HINDSIGHT -->` block that leaves
+the rest of the file untouched): a short rule telling the agent to `recall` at
+the start of each task and `retain` durable facts.
+
+## Configuration
+
+| Setting | Env var | Default |
+| --- | --- | --- |
+| API URL | `HINDSIGHT_API_URL` | `https://api.hindsight.vectorize.io` |
+| API token | `HINDSIGHT_API_TOKEN` | _(none; required for Cloud)_ |
+| Bank id | `HINDSIGHT_ZED_BANK_ID` | `zed` |
+
+These can also live in `~/.hindsight/zed.json` (written by `init`).
+
+## 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 MCP-endpoint check
+```
+
+## License
+
+MIT

hindsight-integrations/zed/README.md

@@ -0,0 +1,3 @@
+"""Hindsight memory integration for the Zed editor."""
+
+__version__ = "0.1.0"