memgraph-context-graph 0.7.0__tar.gz → 0.7.2__tar.gz

{memgraph_context_graph-0.7.0 → memgraph_context_graph-0.7.2}/CONTEXT.md

@@ -85,7 +85,7 @@ _Avoid_: MCP tool (the protocol it is served over, not the thing), Graph Connect
 - **Claude Code Plugin** installs Claude Code hook wiring invoking the Claude Code runtime adapter command.
 - **Event Protocol** carries agent activity, not graph semantics.
 - **Agent Session** may be persisted as a session node by a graph component; **Event Protocol** only carries the session identifier.
-- Tool/message events carry `agent_name` when runtime identifies a subagent. Memgraph Context Graph only transports this id; Graph Connectors decide how to use it. Codex adapter doesn't yet handle subagent lifecycle/ids ([#275](https://github.com/memgraph/ai-toolkit/issues/275)).
+- Tool/message events carry `agent_name` when runtime identifies a subagent. Memgraph Context Graph only transports this id; Graph Connectors decide how to use it. The Codex adapter emits no subagent lifecycle events.
 - Runtime Plugin's generated command calls `hook run <name>`. CLI resolves name via Runtime Registration; plugin never names an adapter class directly.
 - Built-in Runtime Registrations: `codex`, `claude-code`, `copilot-cli`, `cursor`, `opencode`, `antigravity-cli`, and `grok`. Other packages may publish more.
 
@@ -110,4 +110,4 @@ _Avoid_: MCP tool (the protocol it is served over, not the thing), Graph Connect
 - "Session" = activity or graph state? Use **Agent Session** for activity, "session node" for persisted state.
 - "Plugin" can sound like a graph extension. Use **Runtime Plugin** for host-specific distribution; Graph Connectors own graph interpretation.
 - Entry-point discovery = **Runtime Registration**, not a runtime/CLI plugin ([#269](https://github.com/memgraph/ai-toolkit/issues/269)).
-- Code hasn't fully caught up to **Runtime Adapter** terminology: Event Protocol's `source_sdk` field (`events.py`, set by all 4 adapters, read by Actions Graph's connector) still names the rejected term (ADR 0001). Rename to e.g. `source_adapter` tracked, not done.
+- Code hasn't fully caught up to **Runtime Adapter** terminology: Event Protocol's `source_sdk` field (`events.py`, set by every adapter, read by Actions Graph's connector) still names the rejected term (ADR 0001); a rename to e.g. `source_adapter` is not done.

{memgraph_context_graph-0.7.0 → memgraph_context_graph-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memgraph-context-graph
-Version: 0.7.0
+Version: 0.7.2
 Summary: Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)
 License: MIT
 License-File: LICENSE
@@ -431,34 +431,11 @@ 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.
 
-### OpenAI Codex Plugin
+### Codex and Claude Code Plugins
 
-Codex hook configuration can be installed as a user-level Codex plugin.
-
-The runtime-plugin flow is:
-
-```text
-Codex Plugin -> Codex Runtime Adapter -> Event Protocol -> Graph Connector -> Memgraph
-```
-
-The plugin installs Codex hook wiring. The Codex runtime adapter normalizes the hook payload. Graph connectors such as `SkillGraphConnector` decide what those events mean in their graph.
-
-Plugin source:
-
-```text
-context-graph/plugins/memgraph-context-graph-codex
-```
-
-Register the public Git-backed marketplace and install the plugin:
-
-```bash
-codex plugin marketplace add memgraph/ai-toolkit --sparse .agents/plugins
-codex plugin add context-graph@context-graph-plugins
-```
-
-Both are non-interactive; `codex plugin add` installs and enables the plugin in one step (`codex plugin list --json` confirms `"enabled": true`).
-
-Check the installed hook environment with:
+Both runtimes have a distributable Runtime Plugin that wires hooks and the MCP server; marketplace
+install steps are in [plugins/memgraph-context-graph-codex](../plugins/memgraph-context-graph-codex/README.md) and
+[plugins/memgraph-context-graph-claude](../plugins/memgraph-context-graph-claude/README.md). Check an install with:
 
 ```bash
 memgraph-context-graph doctor --runtime codex --connector skills-graph --connector actions-graph --connector sessions-graph
@@ -466,34 +443,6 @@ memgraph-context-graph doctor --runtime codex --connector skills-graph --connect
 
 Graph credentials live in `~/.config/context-graph/config.toml` (written by `setup`/`config set`), not in plugin hook files or the process environment — hooks read that file at runtime. See [Configuration](#configuration).
 
-### Claude Code Plugin
-
-Claude Code hook configuration can be installed as a Claude Code plugin.
-
-The runtime-plugin flow is:
-
-```text
-Claude Code Plugin -> Claude Code Runtime Adapter -> Event Protocol -> Graph Connector -> Memgraph
-```
-
-For a public Git-backed marketplace install, add the marketplace inside Claude Code:
-
-```text
-/plugin marketplace add memgraph/ai-toolkit
-```
-
-Then install:
-
-```text
-/plugin install context-graph@context-graph-plugins
-```
-
-Check the installed hook environment with:
-
-```bash
-memgraph-context-graph doctor --runtime claude-code --connector skills-graph --connector actions-graph --connector sessions-graph
-```
-
 ### Source Development
 
 For source development and per-project experiments, you can generate local Codex hook files:
@@ -665,9 +614,7 @@ class MyRuntimePlugin:
     def build_hooks_config(self, command: str, *, timeout: int = 30) -> dict:
         return build_hooks_config(command, timeout=timeout)
 
-    # init(project_dir, connectors, **kwargs) is optional -- omit it if your
-    # runtime has no project-local hook-config file to generate (matching
-    # ClaudeCodeHooksAdapter's own plugin, which doesn't define one yet).
+    # init(project_dir, connectors, **kwargs) is optional: omit it when there is no project-local file to write.
 
 
 PLUGIN = MyRuntimePlugin()

{memgraph_context_graph-0.7.0 → memgraph_context_graph-0.7.2}/README.md

@@ -406,34 +406,11 @@ 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.
 
-### OpenAI Codex Plugin
+### Codex and Claude Code Plugins
 
-Codex hook configuration can be installed as a user-level Codex plugin.
-
-The runtime-plugin flow is:
-
-```text
-Codex Plugin -> Codex Runtime Adapter -> Event Protocol -> Graph Connector -> Memgraph
-```
-
-The plugin installs Codex hook wiring. The Codex runtime adapter normalizes the hook payload. Graph connectors such as `SkillGraphConnector` decide what those events mean in their graph.
-
-Plugin source:
-
-```text
-context-graph/plugins/memgraph-context-graph-codex
-```
-
-Register the public Git-backed marketplace and install the plugin:
-
-```bash
-codex plugin marketplace add memgraph/ai-toolkit --sparse .agents/plugins
-codex plugin add context-graph@context-graph-plugins
-```
-
-Both are non-interactive; `codex plugin add` installs and enables the plugin in one step (`codex plugin list --json` confirms `"enabled": true`).
-
-Check the installed hook environment with:
+Both runtimes have a distributable Runtime Plugin that wires hooks and the MCP server; marketplace
+install steps are in [plugins/memgraph-context-graph-codex](../plugins/memgraph-context-graph-codex/README.md) and
+[plugins/memgraph-context-graph-claude](../plugins/memgraph-context-graph-claude/README.md). Check an install with:
 
 ```bash
 memgraph-context-graph doctor --runtime codex --connector skills-graph --connector actions-graph --connector sessions-graph
@@ -441,34 +418,6 @@ memgraph-context-graph doctor --runtime codex --connector skills-graph --connect
 
 Graph credentials live in `~/.config/context-graph/config.toml` (written by `setup`/`config set`), not in plugin hook files or the process environment — hooks read that file at runtime. See [Configuration](#configuration).
 
-### Claude Code Plugin
-
-Claude Code hook configuration can be installed as a Claude Code plugin.
-
-The runtime-plugin flow is:
-
-```text
-Claude Code Plugin -> Claude Code Runtime Adapter -> Event Protocol -> Graph Connector -> Memgraph
-```
-
-For a public Git-backed marketplace install, add the marketplace inside Claude Code:
-
-```text
-/plugin marketplace add memgraph/ai-toolkit
-```
-
-Then install:
-
-```text
-/plugin install context-graph@context-graph-plugins
-```
-
-Check the installed hook environment with:
-
-```bash
-memgraph-context-graph doctor --runtime claude-code --connector skills-graph --connector actions-graph --connector sessions-graph
-```
-
 ### Source Development
 
 For source development and per-project experiments, you can generate local Codex hook files:
@@ -640,9 +589,7 @@ class MyRuntimePlugin:
     def build_hooks_config(self, command: str, *, timeout: int = 30) -> dict:
         return build_hooks_config(command, timeout=timeout)
 
-    # init(project_dir, connectors, **kwargs) is optional -- omit it if your
-    # runtime has no project-local hook-config file to generate (matching
-    # ClaudeCodeHooksAdapter's own plugin, which doesn't define one yet).
+    # init(project_dir, connectors, **kwargs) is optional: omit it when there is no project-local file to write.
 
 
 PLUGIN = MyRuntimePlugin()

{memgraph_context_graph-0.7.0 → memgraph_context_graph-0.7.2}/docs/command-hooks.md

@@ -205,7 +205,7 @@ session end, so adapters emit two different events:
 | Runtime | Turn end | Session end |
 |---|---|---|
 | Claude Code | `Stop` (records `last_assistant_message`) | `SessionEnd` |
-| Codex | `Stop` (records `last_assistant_message`) | none |
+| Codex | `Stop` (records `last_assistant_message`) | `SessionEnd`, only when Codex ends the session; with its shared background server `/exit` just detaches |
 | Copilot CLI | `agentStop` | `sessionEnd` |
 | Cursor | `stop` | `sessionEnd` |
 | OpenCode | `session.execution.succeeded` / `.failed` | `session.deleted` |

{memgraph_context_graph-0.7.0 → memgraph_context_graph-0.7.2}/pyproject.toml

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

{memgraph_context_graph-0.7.0 → memgraph_context_graph-0.7.2}/src/memgraph_context_graph/__init__.py

@@ -45,9 +45,8 @@ from .protocols import GraphConnector, RuntimeAdapter
 try:
     __version__ = metadata.version(__package__ or __name__)
 except metadata.PackageNotFoundError:
-    # Case where package metadata is not available.
     __version__ = ""
-del metadata  # optional, avoids polluting the results of dir(__package__)
+del metadata
 
 __all__ = [
     "AgentEndEvent",

{memgraph_context_graph-0.7.0 → memgraph_context_graph-0.7.2}/src/memgraph_context_graph/adapters/_identity.py

@@ -25,22 +25,12 @@ from __future__ import annotations
 
 import os
 import stat
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import Any
 
-#: Points hooks at a different config *file*. Not a way to supply configuration
-#: values -- ADR 0002 removed those from the environment deliberately, because
-#: hook subprocesses do not source shell profiles and relying on ambient env
-#: caused `doctor` and hooks to disagree about what was configured.
-#:
-#: This is the opposite situation: a parent process that spawns a session hands
-#: the path down explicitly to its own child, so nothing is ambient and nothing
-#: can drift. It exists because the config file is otherwise a single global,
-#: which means pointing ONE session at a different Memgraph silently redirects
-#: every other Claude Code session running on the machine -- observed while
-#: building the eval gold slice, where an unrelated session's activity landed
-#: in the graph under test.
+#: Selects which config *file* hooks read, never a value in it (ADR 0003): a parent
+#: process hands the path to the session it spawns, so nothing is ambient.
 CONFIG_PATH_ENV = "CONTEXT_GRAPH_CONFIG"
 
 _DEFAULT_CONFIG_DIR = Path.home() / ".config" / "context-graph"
@@ -75,13 +65,7 @@ MEMORY_BACKEND_GRAPH = "context-graph"
 MEMORY_BACKEND_NATIVE = "native"
 MEMORY_BACKENDS = frozenset({MEMORY_BACKEND_GRAPH, MEMORY_BACKEND_NATIVE})
 
-_RECONCILE_DEFAULTS = {
-    "auto_reconcile": None,
-}
-
-#: Shared truthy/falsy vocabulary for TOML/CLI boolean flags — kept here so
-#: cli.py can validate `config set` input against the same set parse_bool_flag
-#: accepts, instead of redefining it inline.
+#: The boolean spellings parse_bool_flag accepts, shared with ``config set`` validation.
 TRUTHY_VALUES = frozenset({"1", "true", "yes", "on"})
 FALSY_VALUES = frozenset({"0", "false", "no", "off"})
 
@@ -101,7 +85,7 @@ class HookConfig:
     memgraph_database: str = _MEMGRAPH_DEFAULTS["database"]
     openai_api_key: str = _LLM_DEFAULTS["openai_api_key"]
     anthropic_api_key: str = _LLM_DEFAULTS["anthropic_api_key"]
-    auto_reconcile: bool | None = _RECONCILE_DEFAULTS["auto_reconcile"]
+    auto_reconcile: bool | None = None
     #: The model recall embeds with; None means the consumer's own default.
     embedding_model: str | None = None
     #: Every other ``[recall]`` key (lanes and widths), as written: the recall
@@ -133,18 +117,11 @@ class HookConfig:
 
 
 def load_config() -> HookConfig:
-    """Load hook configuration from the config file.
-
-    Returns a HookConfig with defaults for any missing values.
-    Caches the result for the lifetime of the process.
-    """
+    """Load hook configuration from the config file, with defaults for missing values; cached per process."""
     global _cached_config
-    if _cached_config is not None:
-        return _cached_config
-
-    config = _read_config_file()
-    _cached_config = config
-    return config
+    if _cached_config is None:
+        _cached_config = _read_config_file()
+    return _cached_config
 
 
 def reload_config() -> HookConfig:
@@ -190,13 +167,10 @@ def resolve_memgraph_env(
 
 
 def resolve_llm_env() -> dict[str, str]:
-    """Resolve LLM API key settings for hook subprocesses.
+    """Resolve LLM API keys for hook subprocesses, from the config file only.
 
-    Config file only — mirrors :func:`resolve_memgraph_env`, but there is no
-    CLI-flag override path for these since nothing resolves them from argparse.
-    Values are empty strings when not configured. Hook-spawned children must
-    overlay these empty values too so ambient credentials cannot supply a key
-    absent from the selected config file.
+    An unconfigured key is an empty string. Hook-spawned children must overlay these
+    empty values too, so ambient credentials cannot supply a key the config file lacks.
     """
     config = load_config()
     return {
@@ -208,42 +182,25 @@ def resolve_llm_env() -> dict[str, str]:
 def resolve_auto_reconcile() -> bool:
     """Resolve whether sessions-graph should auto-trigger reconciliation on SESSION_END.
 
-    Config file only — mirrors :func:`resolve_llm_env`. The config-file value
-    is ``None`` when never configured; per ADR 0002 (config-file-only-hook-
-    resolution) there is no ambient env var fallback to preserve here, so
-    "never configured" collapses to ``False``, matching
-    ``SessionsGraphConnector``'s own default. Off by default given LightRAG
-    entity extraction's LLM cost; opt in with
-    ``memgraph-context-graph config set reconcile.auto_reconcile true``.
+    Config file only (ADR 0002); never configured means ``False``, matching
+    ``SessionsGraphConnector``'s default, since reconciliation costs LLM calls.
     """
     return bool(load_config().auto_reconcile)
 
 
 def resolve_embedding_model() -> str | None:
-    """The configured ``[recall] embedding_model``, or None when unset.
-
-    Config file only, like :func:`resolve_auto_reconcile`. None leaves the
-    choice to sessions-graph's own default rather than duplicating it here.
-    """
+    """The configured ``[recall] embedding_model``, or None to leave sessions-graph's default."""
     return load_config().embedding_model
 
 
 def resolve_ontology() -> tuple[str | None, str | None]:
-    """The configured ``[ontology]`` (path, derive), each None when unset.
-
-    Config file only, like :func:`resolve_auto_reconcile`. sessions-graph owns
-    what the values mean and their defaults.
-    """
+    """The configured ``[ontology]`` (path, derive), each None when unset; sessions-graph owns their meaning."""
     config = load_config()
     return config.ontology_path, config.ontology_derive
 
 
 def parse_bool_flag(value: str | bool) -> bool:
-    """Parse a TOML/CLI boolean flag string. Truthy: "1"/"true"/"yes"/"on" (case-insensitive).
-
-    Passing an actual ``bool`` through unchanged guards against a future
-    swap to a real TOML parser (which would hand back native booleans).
-    """
+    """Parse a TOML/CLI boolean flag: :data:`TRUTHY_VALUES` (case-insensitive) is true, a ``bool`` passes through."""
     if isinstance(value, bool):
         return value
     return value.strip().lower() in TRUTHY_VALUES
@@ -271,52 +228,24 @@ def write_config(
     Only updates supplied values; preserves existing values for unspecified keys.
     Creates the file with 0600 permissions if it does not exist.
     """
-    global _cached_config
-
-    # Read existing config as base.
-    existing = _read_config_file()
-
-    final_edition = edition if edition is not None else existing.edition
-    final_user_id = user_id if user_id is not None else existing.user_id
-    final_url = memgraph_url if memgraph_url is not None else existing.memgraph_url
-    final_user = memgraph_user if memgraph_user is not None else existing.memgraph_user
-    final_password = memgraph_password if memgraph_password is not None else existing.memgraph_password
-    final_database = memgraph_database if memgraph_database is not None else existing.memgraph_database
-    final_openai_api_key = openai_api_key if openai_api_key is not None else existing.openai_api_key
-    final_anthropic_api_key = anthropic_api_key if anthropic_api_key is not None else existing.anthropic_api_key
-    final_auto_reconcile = auto_reconcile if auto_reconcile is not None else existing.auto_reconcile
-    final_embedding_model = embedding_model if embedding_model is not None else existing.embedding_model
-    final_ontology_path = ontology_path if ontology_path is not None else existing.ontology_path
-    final_ontology_derive = ontology_derive if ontology_derive is not None else existing.ontology_derive
-    final_github_token = github_token if github_token is not None else existing.github_token
-    final_memory_backend = memory_backend if memory_backend is not None else existing.memory_backend
-
-    content = _render_config(
-        edition=final_edition,
-        user_id=final_user_id or "",
-        url=final_url,
-        user=final_user,
-        password=final_password,
-        database=final_database,
-        openai_api_key=final_openai_api_key,
-        anthropic_api_key=final_anthropic_api_key,
-        auto_reconcile=final_auto_reconcile,
-        embedding_model=final_embedding_model,
-        recall_settings=existing.recall_settings,
-        ontology_path=final_ontology_path,
-        ontology_derive=final_ontology_derive,
-        github_token=final_github_token,
-        memory_backend=final_memory_backend,
-    )
-
-    path = config_file()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(content, encoding="utf-8")
-    path.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 0600
-
-    # Invalidate cache.
-    _cached_config = None
-    return config_file()
+    updates = {
+        "edition": edition,
+        "user_id": user_id,
+        "memgraph_url": memgraph_url,
+        "memgraph_user": memgraph_user,
+        "memgraph_password": memgraph_password,
+        "memgraph_database": memgraph_database,
+        "openai_api_key": openai_api_key,
+        "anthropic_api_key": anthropic_api_key,
+        "auto_reconcile": auto_reconcile,
+        "embedding_model": embedding_model,
+        "ontology_path": ontology_path,
+        "ontology_derive": ontology_derive,
+        "github_token": github_token,
+        "memory_backend": memory_backend,
+    }
+    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))
 
 
 def write_full_config(
@@ -328,7 +257,7 @@ def write_full_config(
     memgraph_database: str = _MEMGRAPH_DEFAULTS["database"],
     openai_api_key: str = _LLM_DEFAULTS["openai_api_key"],
     anthropic_api_key: str = _LLM_DEFAULTS["anthropic_api_key"],
-    auto_reconcile: bool | None = _RECONCILE_DEFAULTS["auto_reconcile"],
+    auto_reconcile: bool | None = None,
 ) -> Path:
     """Write a complete config file, resetting identity, Memgraph and LLM settings to what is given.
 
@@ -336,49 +265,29 @@ def write_full_config(
     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.
     """
-    global _cached_config
-
     existing = _read_config_file()
-    final_auto_reconcile = auto_reconcile if auto_reconcile is not None else existing.auto_reconcile
-
-    content = _render_config(
-        edition=existing.edition,
+    config = replace(
+        existing,
         user_id=user_id,
-        url=memgraph_url,
-        user=memgraph_user,
-        password=memgraph_password,
-        database=memgraph_database,
+        memgraph_url=memgraph_url,
+        memgraph_user=memgraph_user,
+        memgraph_password=memgraph_password,
+        memgraph_database=memgraph_database,
         openai_api_key=openai_api_key,
         anthropic_api_key=anthropic_api_key,
-        auto_reconcile=final_auto_reconcile,
-        embedding_model=existing.embedding_model,
-        recall_settings=existing.recall_settings,
-        ontology_path=existing.ontology_path,
-        ontology_derive=existing.ontology_derive,
-        github_token=existing.github_token,
-        memory_backend=existing.memory_backend,
+        auto_reconcile=auto_reconcile if auto_reconcile is not None else existing.auto_reconcile,
     )
+    return _write_config_file(_render_config(config))
+
 
+def _write_config_file(content: str) -> Path:
+    global _cached_config
     path = config_file()
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(content, encoding="utf-8")
-    path.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 0600
-
+    path.chmod(stat.S_IRUSR | stat.S_IWUSR)  # 0600: the file holds credentials.
     _cached_config = None
-    return config_file()
-
-
-def config_file_path() -> Path:
-    """Return the config file path (for display purposes)."""
-    return config_file()
-
-
-def config_dir_path() -> Path:
-    """Return the directory holding the config file actually in use."""
-    return config_file().parent
-
-
-# --- Internal helpers ---
+    return path
 
 
 def _read_config_file() -> HookConfig:
@@ -466,62 +375,50 @@ def _parse_toml(path: Path, problems: list[str] | None = None) -> dict[str, dict
     return sections
 
 
-def _render_config(
-    *,
-    edition: str | None = None,
-    user_id: str,
-    url: str,
-    user: str,
-    password: str,
-    database: str,
-    openai_api_key: str,
-    anthropic_api_key: str,
-    auto_reconcile: bool | None,
-    embedding_model: str | None = None,
-    recall_settings: dict[str, str] | None = None,
-    ontology_path: str | None = None,
-    ontology_derive: str | None = None,
-    github_token: str | None = None,
-    memory_backend: str | None = None,
-) -> str:
+def _render_config(config: HookConfig) -> str:
     """Render the full config file content.
 
-    The ``[reconcile]`` section is omitted entirely when ``auto_reconcile`` is
-    ``None`` (never configured), so a fresh read of the file resolves it back
-    to ``None`` rather than a concrete ``false`` — see
-    :func:`resolve_auto_reconcile` for why that distinction matters.
-    ``[recall]``, ``[ontology]``, ``[github]`` and ``[memory]`` are likewise omitted while they hold nothing.
+    ``[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.
     """
+    user_id = config.user_id or ""
     lines = [
         "# Context Graph hook configuration",
         "# Generated by: memgraph-context-graph config set / bootstrap",
         f"# Location: {config_file()}",
         "",
-        *([f'edition = "{edition}"', ""] if edition else []),
+        *([f'edition = "{config.edition}"', ""] if config.edition else []),
         # Enterprise takes the user and their database from the Memgraph login, so it writes neither.
-        *(["[identity]", f'user_id = "{user_id}"', ""] if edition != "enterprise" else []),
+        *(["[identity]", f'user_id = "{user_id}"', ""] if config.edition != "enterprise" else []),
         "[memgraph]",
-        f'url = "{url}"',
-        f'user = "{user}"',
-        f'password = "{password}"',
-        *([f'database = "{database}"'] if edition != "enterprise" else []),
+        f'url = "{config.memgraph_url}"',
+        f'user = "{config.memgraph_user}"',
+        f'password = "{config.memgraph_password}"',
+        *([f'database = "{config.memgraph_database}"'] if config.edition != "enterprise" else []),
         "",
         "[llm]",
-        f'openai_api_key = "{openai_api_key}"',
-        f'anthropic_api_key = "{anthropic_api_key}"',
+        f'openai_api_key = "{config.openai_api_key}"',
+        f'anthropic_api_key = "{config.anthropic_api_key}"',
     ]
-    if auto_reconcile is not None:
-        lines += ["", "[reconcile]", f"auto_reconcile = {'true' if auto_reconcile else 'false'}"]
-    recall = {"embedding_model": embedding_model, **(recall_settings or {})} if embedding_model else recall_settings
+    if config.auto_reconcile is not None:
+        lines += ["", "[reconcile]", f"auto_reconcile = {'true' if config.auto_reconcile else 'false'}"]
+    recall = (
+        {"embedding_model": config.embedding_model, **config.recall_settings}
+        if config.embedding_model
+        else config.recall_settings
+    )
     if recall:
         lines += ["", "[recall]", *(f'{key} = "{value}"' for key, value in recall.items())]
-    ontology = {key: value for key, value in (("path", ontology_path), ("derive", ontology_derive)) if value}
+    ontology = {
+        key: value for key, value in (("path", config.ontology_path), ("derive", config.ontology_derive)) if value
+    }
     if ontology:
         lines += ["", "[ontology]", *(f'{key} = "{value}"' for key, value in ontology.items())]
-    if github_token:
-        lines += ["", "[github]", f'token = "{github_token}"']
-    if memory_backend:
-        lines += ["", "[memory]", f'backend = "{memory_backend}"']
+    if config.github_token:
+        lines += ["", "[github]", f'token = "{config.github_token}"']
+    if config.memory_backend:
+        lines += ["", "[memory]", f'backend = "{config.memory_backend}"']
     lines.append("")
     return "\n".join(lines)