memgraph-context-graph 0.7.4__tar.gz → 0.8.0__tar.gz

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memgraph-context-graph
-Version: 0.7.4
+Version: 0.8.0
 Summary: Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)
 License: MIT
 License-File: LICENSE
@@ -308,15 +308,23 @@ Hooks never read environment variables for these values, and neither does setup:
 
 The hooks write sessions into Memgraph; recall reads them back. With
 sessions-graph installed, `memgraph-context-graph mcp` serves a `recall(question)`
-tool over stdio MCP, and the Codex and Claude Code plugins bundle that server,
-so installing a plugin is all it takes. The tool returns context, not an answer:
+tool over stdio MCP. The Codex and Claude Code plugins bundle that server, so
+installing a plugin is all it takes; for the other agents, `setup` registers it
+in each one's own user-level MCP config (see
+[every agent](#every-agent-registration-switch-and-session-start)). The tool returns context, not an answer:
 the dated messages and facts from the user's own sessions that match the
 question, behind a header with the rules for reading them. The harness's model
 answers from those rows.
 
-At session start the hook adds one line to the model's context saying the tool
-exists. It never pushes retrieved content; the model calls `recall` when a
-question needs memory.
+At session start the hook adds a line to the model's context saying the tool
+exists, then where the user left off in this project: the last session's date,
+agent, first and last ask and last reply, and the first ask of the two before
+it, quoted from captured turns. Sessions from any agent count, so a session in
+Grok picks up where one in Codex stopped. It is a pointer, not a recall result:
+nothing is ranked against a question, and the model still calls `recall` when
+one needs memory. A session's project is its checkout's key (the same one
+memory folders use), recorded when it starts. Turn it off with
+`memgraph-context-graph config set session_start.resume false`.
 
 A connector may also add a line just before a tool runs
 (`GraphConnector.context_before_tool`) — resources-graph's Nudge that what the
@@ -359,8 +367,9 @@ was benchmarked in; the JSON is what `--json` prints.
 
 ### Memory: Context Graph as the harness's memory
 
-Claude Code and Codex each keep their own memory. Context Graph can replace it
-for a user who opts in:
+Every agent `setup` knows can use Context Graph as its memory. Claude Code and
+Codex each keep their own memory, and Context Graph replaces it for a user who
+opts in:
 
 ```bash
 memgraph-context-graph setup claude-code --memory-backend context-graph
@@ -431,6 +440,34 @@ name is used. See
 [ADR 0006](docs/adr/0006-memory-tool-writes-explicit-memory.md) for why this is
 the one write the model makes over MCP.
 
+#### Every agent: registration, switch and session start
+
+The other five have no plugin, so `setup <runtime>` registers the
+`context-graph` MCP server in the agent's own user-level config: memory belongs
+to the user, not to one project. It adds the server's tools to the agent's
+persistent allow-list where it keeps one, because a headless run refuses a tool
+that needs approval. `--memory-backend context-graph` then turns the agent's
+own memory off, and `uninstall` undoes both. Every edited file keeps the rest of
+its content and is backed up once to `<name>.context-graph.bak`.
+
+| Agent | Built-in memory, and the switch | Server registered in | Session-start text reaches the model through |
+|---|---|---|---|
+| Claude Code | auto memory; `autoMemoryEnabled: false` | the plugin | `SessionStart` `additionalContext` |
+| Codex | memories; three keys in `config.toml` | the plugin | `SessionStart` `additionalContext` (~2,500-token cap) |
+| Copilot CLI | Copilot Memory (on GitHub, not importable); `"memory": false` in `~/.copilot/settings.json` | `~/.copilot/mcp-config.json` (no allow-list: approve once, or `--allow-tool=context-graph`) | `sessionStart` top-level `additionalContext` |
+| Cursor | none (Memories was removed) | `~/.cursor/mcp.json`; allow `Mcp(context-graph:*)` in `~/.cursor/cli-config.json` | `sessionStart` `additional_context` (the IDE's agent window can drop it; untested here) |
+| OpenCode | none | `mcp.servers` in `~/.config/opencode/opencode.json`, `codemode: false`; an allow rule in `permissions` | the plugin's `context` hook, added to the system prompt of every request |
+| Antigravity CLI | none (Knowledge is off in the CLI) | `~/.gemini/config/mcp_config.json`; allow `mcp(context-graph/*)` in `~/.gemini/antigravity-cli/settings.json` | `SessionStart` `injectSteps` system message |
+| Grok Build | topic notes under `~/.grok/memory-v2/`, imported to `/memories/grok/`; `[memory_v2] enabled = false` | `~/.grok/config.toml`; allow `MCPTool(context-graph__*)` | the MCP server's `instructions` (`mcp --session-context`): Grok's start hooks can't reach the model |
+
+Antigravity's hooks carry no prompt or reply text, so its turns are read from
+the transcript its `Stop` payload points at; that is what gives its sessions a
+place in recall and in the next session's "where you left off".
+
+`live-hooks-e2e.sh memory` checks this against each installed agent: a memory
+written, one read back in a new session, and the next session's index and last
+ask.
+
 ### Codex and Claude Code Plugins
 
 Both runtimes have a distributable Runtime Plugin that wires hooks and the MCP server; marketplace

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.8.0}/README.md

@@ -283,15 +283,23 @@ Hooks never read environment variables for these values, and neither does setup:
 
 The hooks write sessions into Memgraph; recall reads them back. With
 sessions-graph installed, `memgraph-context-graph mcp` serves a `recall(question)`
-tool over stdio MCP, and the Codex and Claude Code plugins bundle that server,
-so installing a plugin is all it takes. The tool returns context, not an answer:
+tool over stdio MCP. The Codex and Claude Code plugins bundle that server, so
+installing a plugin is all it takes; for the other agents, `setup` registers it
+in each one's own user-level MCP config (see
+[every agent](#every-agent-registration-switch-and-session-start)). The tool returns context, not an answer:
 the dated messages and facts from the user's own sessions that match the
 question, behind a header with the rules for reading them. The harness's model
 answers from those rows.
 
-At session start the hook adds one line to the model's context saying the tool
-exists. It never pushes retrieved content; the model calls `recall` when a
-question needs memory.
+At session start the hook adds a line to the model's context saying the tool
+exists, then where the user left off in this project: the last session's date,
+agent, first and last ask and last reply, and the first ask of the two before
+it, quoted from captured turns. Sessions from any agent count, so a session in
+Grok picks up where one in Codex stopped. It is a pointer, not a recall result:
+nothing is ranked against a question, and the model still calls `recall` when
+one needs memory. A session's project is its checkout's key (the same one
+memory folders use), recorded when it starts. Turn it off with
+`memgraph-context-graph config set session_start.resume false`.
 
 A connector may also add a line just before a tool runs
 (`GraphConnector.context_before_tool`) — resources-graph's Nudge that what the
@@ -334,8 +342,9 @@ was benchmarked in; the JSON is what `--json` prints.
 
 ### Memory: Context Graph as the harness's memory
 
-Claude Code and Codex each keep their own memory. Context Graph can replace it
-for a user who opts in:
+Every agent `setup` knows can use Context Graph as its memory. Claude Code and
+Codex each keep their own memory, and Context Graph replaces it for a user who
+opts in:
 
 ```bash
 memgraph-context-graph setup claude-code --memory-backend context-graph
@@ -406,6 +415,34 @@ name is used. See
 [ADR 0006](docs/adr/0006-memory-tool-writes-explicit-memory.md) for why this is
 the one write the model makes over MCP.
 
+#### Every agent: registration, switch and session start
+
+The other five have no plugin, so `setup <runtime>` registers the
+`context-graph` MCP server in the agent's own user-level config: memory belongs
+to the user, not to one project. It adds the server's tools to the agent's
+persistent allow-list where it keeps one, because a headless run refuses a tool
+that needs approval. `--memory-backend context-graph` then turns the agent's
+own memory off, and `uninstall` undoes both. Every edited file keeps the rest of
+its content and is backed up once to `<name>.context-graph.bak`.
+
+| Agent | Built-in memory, and the switch | Server registered in | Session-start text reaches the model through |
+|---|---|---|---|
+| Claude Code | auto memory; `autoMemoryEnabled: false` | the plugin | `SessionStart` `additionalContext` |
+| Codex | memories; three keys in `config.toml` | the plugin | `SessionStart` `additionalContext` (~2,500-token cap) |
+| Copilot CLI | Copilot Memory (on GitHub, not importable); `"memory": false` in `~/.copilot/settings.json` | `~/.copilot/mcp-config.json` (no allow-list: approve once, or `--allow-tool=context-graph`) | `sessionStart` top-level `additionalContext` |
+| Cursor | none (Memories was removed) | `~/.cursor/mcp.json`; allow `Mcp(context-graph:*)` in `~/.cursor/cli-config.json` | `sessionStart` `additional_context` (the IDE's agent window can drop it; untested here) |
+| OpenCode | none | `mcp.servers` in `~/.config/opencode/opencode.json`, `codemode: false`; an allow rule in `permissions` | the plugin's `context` hook, added to the system prompt of every request |
+| Antigravity CLI | none (Knowledge is off in the CLI) | `~/.gemini/config/mcp_config.json`; allow `mcp(context-graph/*)` in `~/.gemini/antigravity-cli/settings.json` | `SessionStart` `injectSteps` system message |
+| Grok Build | topic notes under `~/.grok/memory-v2/`, imported to `/memories/grok/`; `[memory_v2] enabled = false` | `~/.grok/config.toml`; allow `MCPTool(context-graph__*)` | the MCP server's `instructions` (`mcp --session-context`): Grok's start hooks can't reach the model |
+
+Antigravity's hooks carry no prompt or reply text, so its turns are read from
+the transcript its `Stop` payload points at; that is what gives its sessions a
+place in recall and in the next session's "where you left off".
+
+`live-hooks-e2e.sh memory` checks this against each installed agent: a memory
+written, one read back in a new session, and the next session's index and last
+ask.
+
 ### Codex and Claude Code Plugins
 
 Both runtimes have a distributable Runtime Plugin that wires hooks and the MCP server; marketplace

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.8.0}/docs/command-hooks.md

@@ -139,15 +139,15 @@ never deletes its session, so those sessions only ever see turn ends.
 Antigravity CLI (`agy`, the successor to Gemini CLI) reads named hook groups
 from `.agents/hooks.json`; `hook init` owns the `memgraph-context-graph` group and
 merges it beside any others. Only the tool events (`PreToolUse`,
-`PostToolUse`) take matcher groups. `PreInvocation` and `Stop` are written as
+`PostToolUse`) take matcher groups. `SessionStart` and `Stop` are written as
 flat handlers, because `agy` rejects the whole file when a lifecycle event is
 nested. Timeouts are in seconds.
 
 ```json
 {
   "memgraph-context-graph": {
-    "PreInvocation": [
-      {"type": "command", "command": "memgraph-context-graph hook run antigravity-cli --event-name PreInvocation", "timeout": 30}
+    "SessionStart": [
+      {"type": "command", "command": "memgraph-context-graph hook run antigravity-cli --event-name SessionStart", "timeout": 30}
     ],
     "PreToolUse": [
       {"hooks": [{"type": "command", "command": "memgraph-context-graph hook run antigravity-cli --event-name PreToolUse", "timeout": 30}]}

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memgraph-context-graph"
-version = "0.7.4"
+version = "0.8.0"
 description = "Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)"
 readme = "README.md"
 license = { text = "MIT" }

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.8.0}/src/memgraph_context_graph/adapters/_identity.py

@@ -101,6 +101,9 @@ class HookConfig:
     #: harness memory to the graph (the ``memory`` tool and session-start index
     #: are on); ``"native"`` or None leaves the harness's own memory in charge.
     memory_backend: str | None = None
+    #: ``[session_start] resume``: whether a session starts with a brief of the
+    #: previous sessions in its project. None (never set) means on.
+    session_resume: bool | None = None
     #: The ``section.key`` names the file actually sets (top-level keys as ``key``), so a check can tell
     #: "left at the default" from "written": Enterprise refuses an explicit ``identity.user_id`` or
     #: ``memgraph.database``, which would quietly override what the login decides.
@@ -222,6 +225,7 @@ def write_config(
     ontology_derive: str | None = None,
     github_token: str | None = None,
     memory_backend: str | None = None,
+    session_resume: bool | None = None,
 ) -> Path:
     """Write or update the config file. Returns the path written to.
 
@@ -243,6 +247,7 @@ def write_config(
         "ontology_derive": ontology_derive,
         "github_token": github_token,
         "memory_backend": memory_backend,
+        "session_resume": session_resume,
     }
     config = replace(_read_config_file(), **{key: value for key, value in updates.items() if value is not None})
     return _write_config_file(_render_config(config))
@@ -261,8 +266,8 @@ def write_full_config(
 ) -> Path:
     """Write a complete config file, resetting identity, Memgraph and LLM settings to what is given.
 
-    Every other section (``[reconcile]``, ``[recall]``, ``[ontology]``, ``[github]``, ``[memory]``) and the
-    edition are kept from the existing file, since only ``config set`` or a hand edit ever sets them.
+    Every other section (``[reconcile]``, ``[recall]``, ``[ontology]``, ``[github]``, ``[memory]``,
+    ``[session_start]``) and the edition are kept from the existing file, since only ``config set`` or a hand edit ever sets them.
     ``auto_reconcile`` is kept likewise unless given here. :func:`write_config` is the partial update.
     """
     existing = _read_config_file()
@@ -313,6 +318,7 @@ def _read_config_file() -> HookConfig:
     ontology = sections.get("ontology", {})
     github = sections.get("github", {})
     memory = sections.get("memory", {})
+    session_start = sections.get("session_start", {})
     auto_reconcile_raw = reconcile.get("auto_reconcile")
 
     return HookConfig(
@@ -331,6 +337,7 @@ def _read_config_file() -> HookConfig:
         ontology_derive=ontology.get("derive") or None,
         github_token=github.get("token") or None,
         memory_backend=memory.get("backend") or None,
+        session_resume=parse_bool_flag(session_start["resume"]) if session_start.get("resume") else None,
         present=frozenset(
             f"{section}.{key}" if section else key
             for section, keys in sections.items()
@@ -379,8 +386,8 @@ def _render_config(config: HookConfig) -> str:
     """Render the full config file content.
 
     ``[reconcile]`` is omitted while ``auto_reconcile`` is ``None`` so a re-read keeps "never configured"
-    distinct from an explicit ``false``; ``[recall]``, ``[ontology]``, ``[github]`` and ``[memory]`` are
-    omitted while they hold nothing.
+    distinct from an explicit ``false``, and ``[session_start]`` likewise while ``session_resume`` is;
+    ``[recall]``, ``[ontology]``, ``[github]`` and ``[memory]`` are omitted while they hold nothing.
     """
     user_id = config.user_id or ""
     lines = [
@@ -419,6 +426,8 @@ def _render_config(config: HookConfig) -> str:
         lines += ["", "[github]", f'token = "{config.github_token}"']
     if config.memory_backend:
         lines += ["", "[memory]", f'backend = "{config.memory_backend}"']
+    if config.session_resume is not None:
+        lines += ["", "[session_start]", f"resume = {'true' if config.session_resume else 'false'}"]
     lines.append("")
     return "\n".join(lines)
 

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.8.0}/src/memgraph_context_graph/adapters/_opencode_plugin.js

@@ -25,6 +25,24 @@ function capture(payload) {
   })
 }
 
+// The hook's stdout, parsed: what the hook wants added to the session, or null.
+function ask(payload) {
+  return new Promise((resolve) => {
+    const child = spawn(command[0], command.slice(1), { stdio: ["pipe", "pipe", "inherit"] })
+    let out = ""
+    child.stdout.on("data", (chunk) => (out += chunk))
+    child.on("error", () => resolve(null))
+    child.on("close", () => {
+      try {
+        resolve(out.trim() ? JSON.parse(out) : null)
+      } catch {
+        resolve(null)
+      }
+    })
+    child.stdin.end(JSON.stringify(payload))
+  })
+}
+
 export default {
   id: "memgraph.memgraph-context-graph",
   async setup(ctx) {
@@ -43,6 +61,24 @@ export default {
       return capture({ hook_event_name: "session.created", session_id: sessionID, cwd, model })
     }
 
+    // The session-start text (memory index, where the user left off), asked for once per session. The context
+    // hook runs before every model request and rebuilds the system prompt each time, so it is re-added from
+    // this cache on each one; compaction and title generation build their own requests and get it too.
+    const sessionContext = new Map()
+    const addSessionContext = async (event) => {
+      if (!sessionContext.has(event.sessionID)) {
+        sessionContext.set(
+          event.sessionID,
+          ask({ hook_event_name: "session.context", session_id: event.sessionID, cwd: ctx.location?.directory }),
+        )
+      }
+      const response = await sessionContext.get(event.sessionID)
+      if (typeof response?.system === "string" && response.system) event.system.push({ type: "text", text: response.system })
+    }
+    for (const name of ["context", "compaction", "generate"]) {
+      registrations.push(await ctx.session.hook(name, addSessionContext))
+    }
+
     registrations.push(await ctx.session.hook("prompt", async (event) => {
       openTurns.add(event.sessionID)
       await start(event.sessionID, ctx.location?.directory)

{memgraph_context_graph-0.7.4 → memgraph_context_graph-0.8.0}/src/memgraph_context_graph/adapters/_spec.py

@@ -103,7 +103,10 @@ class RuntimeSpec:
     hook file, and is ignored. ``context_before_tool`` renders the stdout JSON
     that shows the model a line of context before a tool runs, leaving the call
     itself untouched; None where the runtime can't do that without denying or
-    modifying the call.
+    modifying the call. ``session_context`` renders the stdout JSON that puts
+    the session-start text (memory index, where the user left off) in front of
+    the model when ``session_context_event`` fires; None where no hook output
+    reaches the model at session start.
     """
 
     name: str
@@ -119,6 +122,8 @@ class RuntimeSpec:
     foreign_payload_keys: frozenset[str] = frozenset()
     probe_payload: Mapping[str, Any] = field(default_factory=dict)
     context_before_tool: Callable[[str], Mapping[str, Any]] | None = None
+    session_context: Callable[[str], Mapping[str, Any]] | None = None
+    session_context_event: str = "SessionStart"
 
     def event_name(self, payload: Mapping[str, Any]) -> str:
         """Return *payload*'s canonical event name."""
@@ -202,6 +207,11 @@ class SpecAdapter(RuntimeAdapter):
         return ""
 
 
+def hook_specific_session_context(text: str) -> dict[str, Any]:
+    """``SessionStart`` output that adds *text* to the model's context; Claude Code and Codex both read it."""
+    return {"hookSpecificOutput": {"hookEventName": "SessionStart", "additionalContext": text}}
+
+
 def pre_tool_use_context(text: str) -> dict[str, Any]:
     """``PreToolUse`` output that adds *text* to the model's context and leaves the call alone.
 
@@ -247,6 +257,21 @@ class SpecPlugin:
         render = self.spec.context_before_tool
         return None if render is None else dict(render(text))
 
+    def session_context_response(
+        self, payload: Mapping[str, Any], text: Callable[[], str | None]
+    ) -> dict[str, Any] | None:
+        """The stdout JSON that shows the model ``text()`` at session start; None for any other payload.
+
+        *text* is only called for this runtime's own session-start payload, since building it queries Memgraph.
+        """
+        render = self.spec.session_context
+        if render is None or self.spec.event_name(payload) != self.spec.session_context_event:
+            return None
+        if self.spec.foreign_payload_keys & payload.keys():
+            return None
+        content = text()
+        return dict(render(content)) if content else None
+
     def build_hooks_config(self, command: str, *, timeout: int = 30) -> dict[str, Any]:
         """Render the runtime's hook map using *command*."""
         return build_hooks_config(self.spec, command, timeout=timeout)