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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memgraph-context-graph
-Version: 0.8.0
+Version: 0.9.0
 Summary: Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)
 License: MIT
 License-File: LICENSE
@@ -202,6 +202,7 @@ memgraph-context-graph setup                     # interactive on a terminal; pl
 memgraph-context-graph setup claude-code codex   # just these agents
 memgraph-context-graph setup cursor --project-dir ~/work/billing
 memgraph-context-graph setup --plan              # print the plan, change nothing
+memgraph-context-graph update [runtime ...]      # upgrade the package, refresh the wiring and the schema
 memgraph-context-graph uninstall [runtime ...]   # remove the wiring; the graph and config stay
 ```
 
@@ -211,6 +212,15 @@ wires each agent, and runs `doctor`'s checks. Every step checks before it acts,
 missing. The TUI starts only when stdin and stdout are both terminals; the plugins' `scripts/bootstrap.sh`
 runs `setup <runtime> --no-tui`.
 
+**Updating.** Upgrading the package moves the code hooks and the MCP server run, but what setup wrote once stays
+as it was. `update` upgrades the uv tool and its connectors, then, with the new release, refreshes everything
+that is wired: Claude Code's and Codex's plugin (marketplace refreshed, plugin updated), each per-project agent's
+hook file in `--project-dir` (default: the current directory) and its MCP registration, and the graph's indexes
+and constraints. It then runs `doctor`'s checks. Name runtimes to refresh only those; `--no-upgrade` skips the
+package step. Your own hooks, the config and the graph's data are untouched, and running it again changes nothing.
+Running agent sessions keep the hooks they loaded: restart them. Outside the uv tool (a virtualenv, say) the
+package step only warns, and you upgrade it yourself first.
+
 **Identity and connection.** setup writes `~/.config/context-graph/config.toml`; hooks read their configuration from that file at runtime (see [Configuration](#configuration) — env vars are **not** read at hook time). To change your identity later:
 
 ```bash
@@ -268,6 +278,10 @@ database = "memgraph"
 [llm]
 openai_api_key = ""
 anthropic_api_key = ""
+derive_model = "claude-sonnet-5-5"
+
+[capture]
+connectors = "skills-graph, actions-graph, sessions-graph"
 
 [reconcile]
 auto_reconcile = true
@@ -275,12 +289,21 @@ auto_reconcile = true
 [recall]
 embedding_model = "BAAI/bge-small-en-v1.5"
 turns_k = "8"
+
+[extraction]
+model = "fastino/gliner2.5-base-v1"
+entity_threshold = "0.3"
 ```
 
 `[reconcile]` turns on sessions-graph's auto-trigger reconciliation (see
 [sessions-graph § reconciliation](../sessions-graph/README.md#session-reconciliation)),
 which needs no LLM. `[llm]` is optional: a key only lets reconciliation learn
-the user's own ontology (`sessions-graph derive`).
+the user's own ontology (`sessions-graph derive`), and `derive_model` picks
+the model it calls (default `claude-sonnet-5-5` with Anthropic, `gpt-5` with OpenAI).
+`[capture] connectors` is which graph connectors a hook enables when its
+command names no `--connector`, from `skills-graph`, `actions-graph`,
+`sessions-graph` and `resources-graph`; unset means the first three, and
+an empty value enables none. Setup installs the ones it names.
 `[reconcile]` is omitted entirely from a file setup wrote — absent
 means "never configured," distinct from an explicit `auto_reconcile = false`.
 `[recall]` is optional too: without it, recall runs with the widths the
@@ -288,6 +311,10 @@ benchmark measured; see [Recall](#recall-memory-for-the-harnesss-model).
 `[ontology]` is optional as well: `path` names a schema file the user's
 sessions are extracted under and `derive` is `extend` (the default) or
 `off`; see sessions-graph's [Ontology versions](../sessions-graph/README.md#ontology-versions).
+`[extraction]` tunes how reconciliation, re-extraction and derivation read
+sessions, all optional: `model` (a GLiNER2 checkpoint), `entity_threshold` and
+`relation_threshold` (drop extractions below that confidence, 0 to 1), and
+`chunk_size`/`chunk_overlap` (words per window); unset keys keep GLiNER2's defaults.
 
 Manage it with:
 
@@ -296,8 +323,9 @@ memgraph-context-graph config show
 memgraph-context-graph config get memgraph.url
 memgraph-context-graph config set <key> <value>
 # keys: identity.user_id, memgraph.{url,user,password,database},
-#       llm.{openai_api_key,anthropic_api_key}, reconcile.auto_reconcile,
-#       recall.embedding_model, ontology.{path,derive}, memory.backend
+#       llm.{openai_api_key,anthropic_api_key,derive_model}, capture.connectors,
+#       reconcile.auto_reconcile, recall.embedding_model, ontology.{path,derive}, memory.backend
+# [recall] widths and [extraction] are edited in the file.
 ```
 
 Hooks never read environment variables for these values, and neither does setup: it writes only
@@ -355,6 +383,7 @@ from the tool call, so a model can only read its own user's sessions.
 | `facts_k`, `fact_turns_k` | `15`, `8` | Facts matched, and the messages they were read from |
 | `user_fact_types`, `user_facts_k` | `2`, `30` | Relation types gathered whole, for counting questions |
 | `turn_chars` | `1500` | Characters shown per message |
+| `query_instruction` | per model | Prefix embedded with the question; bge's English models get their retrieval instruction, other models none |
 
 Recall needs Memgraph with MAGE (`memgraph/memgraph-mage`) for its vector lanes;
 without it, it answers from text search and says so. `doctor` checks both

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

@@ -177,6 +177,7 @@ memgraph-context-graph setup                     # interactive on a terminal; pl
 memgraph-context-graph setup claude-code codex   # just these agents
 memgraph-context-graph setup cursor --project-dir ~/work/billing
 memgraph-context-graph setup --plan              # print the plan, change nothing
+memgraph-context-graph update [runtime ...]      # upgrade the package, refresh the wiring and the schema
 memgraph-context-graph uninstall [runtime ...]   # remove the wiring; the graph and config stay
 ```
 
@@ -186,6 +187,15 @@ wires each agent, and runs `doctor`'s checks. Every step checks before it acts,
 missing. The TUI starts only when stdin and stdout are both terminals; the plugins' `scripts/bootstrap.sh`
 runs `setup <runtime> --no-tui`.
 
+**Updating.** Upgrading the package moves the code hooks and the MCP server run, but what setup wrote once stays
+as it was. `update` upgrades the uv tool and its connectors, then, with the new release, refreshes everything
+that is wired: Claude Code's and Codex's plugin (marketplace refreshed, plugin updated), each per-project agent's
+hook file in `--project-dir` (default: the current directory) and its MCP registration, and the graph's indexes
+and constraints. It then runs `doctor`'s checks. Name runtimes to refresh only those; `--no-upgrade` skips the
+package step. Your own hooks, the config and the graph's data are untouched, and running it again changes nothing.
+Running agent sessions keep the hooks they loaded: restart them. Outside the uv tool (a virtualenv, say) the
+package step only warns, and you upgrade it yourself first.
+
 **Identity and connection.** setup writes `~/.config/context-graph/config.toml`; hooks read their configuration from that file at runtime (see [Configuration](#configuration) — env vars are **not** read at hook time). To change your identity later:
 
 ```bash
@@ -243,6 +253,10 @@ database = "memgraph"
 [llm]
 openai_api_key = ""
 anthropic_api_key = ""
+derive_model = "claude-sonnet-5-5"
+
+[capture]
+connectors = "skills-graph, actions-graph, sessions-graph"
 
 [reconcile]
 auto_reconcile = true
@@ -250,12 +264,21 @@ auto_reconcile = true
 [recall]
 embedding_model = "BAAI/bge-small-en-v1.5"
 turns_k = "8"
+
+[extraction]
+model = "fastino/gliner2.5-base-v1"
+entity_threshold = "0.3"
 ```
 
 `[reconcile]` turns on sessions-graph's auto-trigger reconciliation (see
 [sessions-graph § reconciliation](../sessions-graph/README.md#session-reconciliation)),
 which needs no LLM. `[llm]` is optional: a key only lets reconciliation learn
-the user's own ontology (`sessions-graph derive`).
+the user's own ontology (`sessions-graph derive`), and `derive_model` picks
+the model it calls (default `claude-sonnet-5-5` with Anthropic, `gpt-5` with OpenAI).
+`[capture] connectors` is which graph connectors a hook enables when its
+command names no `--connector`, from `skills-graph`, `actions-graph`,
+`sessions-graph` and `resources-graph`; unset means the first three, and
+an empty value enables none. Setup installs the ones it names.
 `[reconcile]` is omitted entirely from a file setup wrote — absent
 means "never configured," distinct from an explicit `auto_reconcile = false`.
 `[recall]` is optional too: without it, recall runs with the widths the
@@ -263,6 +286,10 @@ benchmark measured; see [Recall](#recall-memory-for-the-harnesss-model).
 `[ontology]` is optional as well: `path` names a schema file the user's
 sessions are extracted under and `derive` is `extend` (the default) or
 `off`; see sessions-graph's [Ontology versions](../sessions-graph/README.md#ontology-versions).
+`[extraction]` tunes how reconciliation, re-extraction and derivation read
+sessions, all optional: `model` (a GLiNER2 checkpoint), `entity_threshold` and
+`relation_threshold` (drop extractions below that confidence, 0 to 1), and
+`chunk_size`/`chunk_overlap` (words per window); unset keys keep GLiNER2's defaults.
 
 Manage it with:
 
@@ -271,8 +298,9 @@ memgraph-context-graph config show
 memgraph-context-graph config get memgraph.url
 memgraph-context-graph config set <key> <value>
 # keys: identity.user_id, memgraph.{url,user,password,database},
-#       llm.{openai_api_key,anthropic_api_key}, reconcile.auto_reconcile,
-#       recall.embedding_model, ontology.{path,derive}, memory.backend
+#       llm.{openai_api_key,anthropic_api_key,derive_model}, capture.connectors,
+#       reconcile.auto_reconcile, recall.embedding_model, ontology.{path,derive}, memory.backend
+# [recall] widths and [extraction] are edited in the file.
 ```
 
 Hooks never read environment variables for these values, and neither does setup: it writes only
@@ -330,6 +358,7 @@ from the tool call, so a model can only read its own user's sessions.
 | `facts_k`, `fact_turns_k` | `15`, `8` | Facts matched, and the messages they were read from |
 | `user_fact_types`, `user_facts_k` | `2`, `30` | Relation types gathered whole, for counting questions |
 | `turn_chars` | `1500` | Characters shown per message |
+| `query_instruction` | per model | Prefix embedded with the question; bge's English models get their retrieval instruction, other models none |
 
 Recall needs Memgraph with MAGE (`memgraph/memgraph-mage`) for its vector lanes;
 without it, it answers from text search and says so. `doctor` checks both

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

@@ -5,12 +5,13 @@ Protocol, then routes those events to graph connectors. The installed command
 is the same for every runtime:
 
 ```bash
-memgraph-context-graph hook run <runtime> \
-  --connector skills-graph \
-  --connector actions-graph \
-  --connector sessions-graph
+memgraph-context-graph hook run <runtime>
 ```
 
+It enables the graph connectors the config file's `[capture] connectors`
+names (unset: `skills-graph`, `actions-graph`, `sessions-graph`). Repeated
+`--connector` flags override that for one hook command.
+
 Runtime registrations are discovered through the
 `memgraph_context_graph.runtimes` Python entry-point group.
 
@@ -36,8 +37,9 @@ memgraph-context-graph hook init antigravity-cli
 memgraph-context-graph hook init grok
 ```
 
-`hook init` enables all three built-in connectors by default. Use repeated
-`--connector` flags to select a subset. Existing Copilot, Cursor, Antigravity, and Grok
+`hook init` writes hook commands without `--connector` flags, so they enable
+`[capture] connectors`. Repeated `--connector` flags pin a set into the
+generated commands instead. Existing Copilot, Cursor, Antigravity, and Grok
 JSON documents are merged without removing unrelated settings or hooks.
 OpenCode's generated plugin is replaced only with `--force`.
 
@@ -246,12 +248,11 @@ memgraph-context-graph setup antigravity-cli --project-dir "$PWD"
 Smoke-test a registration and its configured connectors:
 
 ```bash
-memgraph-context-graph doctor --runtime cursor \
-  --connector skills-graph \
-  --connector actions-graph \
-  --connector sessions-graph
+memgraph-context-graph doctor --runtime cursor
 ```
 
+`doctor` checks the `[capture] connectors` set unless `--connector` flags name others.
+
 Each runtime provides its own native probe payload; `doctor` does not assume
 that every runtime calls its session-end event `Stop`.
 

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

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

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

@@ -85,6 +85,11 @@ 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"]
+    #: ``[llm] derive_model``: the model ontology derivation calls; None means the provider's default.
+    derive_model: str | None = None
+    #: ``[capture] connectors``: the graph connectors a hook enables when its command names none;
+    #: None (never set) means memgraph_context_graph.connectors.DEFAULT_CONNECTORS.
+    connectors: tuple[str, ...] | None = None
     auto_reconcile: bool | None = None
     #: The model recall embeds with; None means the consumer's own default.
     embedding_model: str | None = None
@@ -95,6 +100,9 @@ class HookConfig:
     ontology_path: str | None = None
     #: ``[ontology] derive``: "extend" (the default) or "off"; see sessions-graph's ontology module.
     ontology_derive: str | None = None
+    #: ``[extraction]`` keys (GLiNER2 checkpoint, thresholds, chunking), as written: sessions-graph
+    #: validates them, this module only keeps them across rewrites.
+    extraction_settings: dict[str, str] = field(default_factory=dict)
     #: ``[github] token``: overrides the ``gh`` login resources-graph's Sweep otherwise fetches with.
     github_token: str | None = None
     #: ``[memory] backend``: ``"context-graph"`` when the user has handed their
@@ -186,7 +194,7 @@ def resolve_auto_reconcile() -> bool:
     """Resolve whether sessions-graph should auto-trigger reconciliation on SESSION_END.
 
     Config file only (ADR 0002); never configured means ``False``, matching
-    ``SessionsGraphConnector``'s default, since reconciliation costs LLM calls.
+    ``SessionsGraphConnector``'s default.
     """
     return bool(load_config().auto_reconcile)
 
@@ -196,6 +204,16 @@ def resolve_embedding_model() -> str | None:
     return load_config().embedding_model
 
 
+def resolve_extraction() -> dict[str, str]:
+    """The configured ``[extraction]`` keys, as written; sessions-graph owns their meaning."""
+    return dict(load_config().extraction_settings)
+
+
+def resolve_derive_model() -> str | None:
+    """The configured ``[llm] derive_model``, or None to leave the provider's default."""
+    return load_config().derive_model
+
+
 def resolve_ontology() -> tuple[str | None, str | None]:
     """The configured ``[ontology]`` (path, derive), each None when unset; sessions-graph owns their meaning."""
     config = load_config()
@@ -219,6 +237,8 @@ def write_config(
     memgraph_database: str | None = None,
     openai_api_key: str | None = None,
     anthropic_api_key: str | None = None,
+    derive_model: str | None = None,
+    connectors: tuple[str, ...] | None = None,
     auto_reconcile: bool | None = None,
     embedding_model: str | None = None,
     ontology_path: str | None = None,
@@ -241,6 +261,8 @@ def write_config(
         "memgraph_database": memgraph_database,
         "openai_api_key": openai_api_key,
         "anthropic_api_key": anthropic_api_key,
+        "derive_model": derive_model,
+        "connectors": connectors,
         "auto_reconcile": auto_reconcile,
         "embedding_model": embedding_model,
         "ontology_path": ontology_path,
@@ -266,8 +288,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]``,
-    ``[session_start]``) and the edition are kept from the existing file, since only ``config set`` or a hand edit ever sets them.
+    Every other section (``[capture]``, ``[reconcile]``, ``[recall]``, ``[ontology]``, ``[extraction]``,
+    ``[github]``, ``[memory]``, ``[session_start]``), ``[llm] derive_model`` 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,9 +335,11 @@ def _read_config_file() -> HookConfig:
     identity = sections.get("identity", {})
     memgraph = sections.get("memgraph", {})
     llm = sections.get("llm", {})
+    capture = sections.get("capture", {})
     reconcile = sections.get("reconcile", {})
     recall = sections.get("recall", {})
     ontology = sections.get("ontology", {})
+    extraction = sections.get("extraction", {})
     github = sections.get("github", {})
     memory = sections.get("memory", {})
     session_start = sections.get("session_start", {})
@@ -330,11 +354,14 @@ def _read_config_file() -> HookConfig:
         memgraph_database=memgraph.get("database") or _MEMGRAPH_DEFAULTS["database"],
         openai_api_key=llm.get("openai_api_key", _LLM_DEFAULTS["openai_api_key"]),
         anthropic_api_key=llm.get("anthropic_api_key", _LLM_DEFAULTS["anthropic_api_key"]),
+        derive_model=llm.get("derive_model") or None,
+        connectors=_parse_list(capture["connectors"]) if "connectors" in capture else None,
         auto_reconcile=parse_bool_flag(auto_reconcile_raw) if auto_reconcile_raw is not None else None,
         embedding_model=recall.get("embedding_model") or None,
         recall_settings={key: value for key, value in recall.items() if key != "embedding_model"},
         ontology_path=ontology.get("path") or None,
         ontology_derive=ontology.get("derive") or None,
+        extraction_settings=dict(extraction),
         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,
@@ -348,6 +375,11 @@ def _read_config_file() -> HookConfig:
     )
 
 
+def _parse_list(value: str) -> tuple[str, ...]:
+    """A comma-separated value (``"a, b"``) as its non-blank items; the parser has no arrays."""
+    return tuple(item.strip() for item in value.split(",") if item.strip())
+
+
 def _parse_toml(path: Path, problems: list[str] | None = None) -> dict[str, dict[str, str]]:
     """Minimal TOML parser — handles [section] and key = "value" pairs.
 
@@ -387,7 +419,8 @@ def _render_config(config: HookConfig) -> str:
 
     ``[reconcile]`` is omitted while ``auto_reconcile`` is ``None`` so a re-read keeps "never configured"
     distinct from an explicit ``false``, and ``[session_start]`` likewise while ``session_resume`` is;
-    ``[recall]``, ``[ontology]``, ``[github]`` and ``[memory]`` are omitted while they hold nothing.
+    ``[capture]`` likewise while ``connectors`` is; ``[recall]``, ``[ontology]``, ``[extraction]``, ``[github]``
+    and ``[memory]`` are omitted while they hold nothing.
     """
     user_id = config.user_id or ""
     lines = [
@@ -407,7 +440,10 @@ def _render_config(config: HookConfig) -> str:
         "[llm]",
         f'openai_api_key = "{config.openai_api_key}"',
         f'anthropic_api_key = "{config.anthropic_api_key}"',
+        *([f'derive_model = "{config.derive_model}"'] if config.derive_model else []),
     ]
+    if config.connectors is not None:
+        lines += ["", "[capture]", f'connectors = "{", ".join(config.connectors)}"']
     if config.auto_reconcile is not None:
         lines += ["", "[reconcile]", f"auto_reconcile = {'true' if config.auto_reconcile else 'false'}"]
     recall = (
@@ -422,6 +458,8 @@ def _render_config(config: HookConfig) -> str:
     }
     if ontology:
         lines += ["", "[ontology]", *(f'{key} = "{value}"' for key, value in ontology.items())]
+    if config.extraction_settings:
+        lines += ["", "[extraction]", *(f'{key} = "{value}"' for key, value in config.extraction_settings.items())]
     if config.github_token:
         lines += ["", "[github]", f'token = "{config.github_token}"']
     if config.memory_backend:

{memgraph_context_graph-0.8.0 → memgraph_context_graph-0.9.0}/src/memgraph_context_graph/cli.py

@@ -9,10 +9,16 @@ import sys
 from importlib import metadata
 from typing import TYPE_CHECKING, Any, TypedDict, cast
 
+from memgraph_context_graph.connectors import (
+    COMPONENTS,
+    DEFAULT_CONNECTORS,
+    configured_connectors,
+    supported_connectors,
+)
 from memgraph_context_graph.tools import normalize_connector_name
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Callable, Sequence
 
 _HELP = """usage: memgraph-context-graph <command> [options]
 
@@ -20,6 +26,7 @@ Commands:
   setup [runtime ...]  Install Context Graph for your agents (interactive on a terminal);
                    --memory-backend context-graph|native switches whose memory they use.
   uninstall [runtime ...]  Remove the agents' wiring; your graph and config stay.
+  update [runtime ...]  Upgrade the package and refresh the agents' wiring and the graph's schema.
   config           Get or set persistent configuration values.
   doctor           Check runtime hook dependencies and Memgraph connectivity.
   join <url> <login>  Use an Enterprise Memgraph as <login> (edition = enterprise); --password or prompt.
@@ -54,6 +61,11 @@ def main(argv: Sequence[str] | None = None) -> int:
 
         return uninstall_main(args[1:])
 
+    if command == "update":
+        from memgraph_context_graph.setup.cli import update_main
+
+        return update_main(args[1:])
+
     if command == "config":
         return _config(args[1:])
 
@@ -106,6 +118,8 @@ def _config(argv: list[str]) -> int:
         "memgraph.database": "memgraph_database",
         "llm.openai_api_key": "openai_api_key",
         "llm.anthropic_api_key": "anthropic_api_key",
+        "llm.derive_model": "derive_model",
+        "capture.connectors": "connectors",
         "reconcile.auto_reconcile": "auto_reconcile",
         "recall.embedding_model": "embedding_model",
         "ontology.path": "ontology_path",
@@ -143,6 +157,14 @@ def _config(argv: list[str]) -> int:
         print(f"memgraph.database = {config.memgraph_database!r}")
         print(f"llm.openai_api_key = {'***' if config.openai_api_key else repr('')}")
         print(f"llm.anthropic_api_key = {'***' if config.anthropic_api_key else repr('')}")
+        if config.derive_model is None:
+            print("llm.derive_model = unset (defaults to the provider's model)")
+        else:
+            print(f"llm.derive_model = {config.derive_model!r}")
+        if config.connectors is None:
+            print(f"capture.connectors = unset (defaults to {', '.join(DEFAULT_CONNECTORS)})")
+        else:
+            print(f"capture.connectors = {', '.join(config.connectors)!r}")
         if config.auto_reconcile is None:
             print("reconcile.auto_reconcile = unset (defaults to false)")
         else:
@@ -156,6 +178,8 @@ def _config(argv: list[str]) -> int:
             print("ontology.derive = unset (defaults to extend)")
         else:
             print(f"ontology.derive = {config.ontology_derive!r}")
+        for key, value in config.extraction_settings.items():
+            print(f"extraction.{key} = {value!r}")
         print(f"github.token = {'***' if config.github_token else 'unset'}")
         print(
             f"memory.backend = {config.memory_backend!r}"
@@ -189,7 +213,7 @@ def _config(argv: list[str]) -> int:
         else:
             value = argv[2]
 
-        write_value: str | bool = value
+        write_value: str | bool | tuple[str, ...] = value
         if key in _BOOL_KEYS:
             normalized = value.strip().lower()
             if normalized not in TRUTHY_VALUES | FALSY_VALUES:
@@ -205,6 +229,12 @@ def _config(argv: list[str]) -> int:
         if key == "ontology.derive" and value not in {"extend", "off"}:
             print(f"Invalid value for {key}: {value!r} (expected extend/off)", file=sys.stderr)
             return 2
+        if key == "capture.connectors":
+            try:
+                write_value = tuple(supported_connectors(value.split(",")))
+            except ValueError as exc:
+                print(f"Invalid value for {key}: {exc}", file=sys.stderr)
+                return 2
 
         # The key/value pairing is only known at runtime (bool iff key is in
         # _BOOL_KEYS, str otherwise); write_config's own parameters are precisely
@@ -214,6 +244,8 @@ def _config(argv: list[str]) -> int:
             display_value = "***"
         elif key in _BOOL_KEYS:
             display_value = str(write_value).lower()
+        elif isinstance(write_value, tuple):
+            display_value = repr(", ".join(write_value))
         else:
             display_value = repr(write_value)
         print(f"Wrote {key} = {display_value} to {config_path}")
@@ -236,6 +268,8 @@ def _config(argv: list[str]) -> int:
             return 1
         if key in _SECRET_KEYS:
             print("***")
+        elif isinstance(value, tuple):
+            print(", ".join(value))
         else:
             print(value)
         return 0
@@ -370,7 +404,7 @@ def _doctor(argv: list[str]) -> int:
         "--connector",
         action="append",
         default=None,
-        help="Graph connector to enable. Defaults to skills-graph.",
+        help="Graph connector to check, repeatable. Defaults to the config file's [capture] connectors.",
     )
     parser.add_argument(
         "--json",
@@ -379,7 +413,7 @@ def _doctor(argv: list[str]) -> int:
     )
     args = parser.parse_args(argv)
 
-    checks = doctor_checks([args.runtime], args.connector or ["skills-graph"])
+    checks = doctor_checks([args.runtime], args.connector or configured_connectors())
     ok = all(check["ok"] for check in checks)
     payload: _DoctorPayload = {"ok": ok, "checks": checks}
     if args.json:
@@ -519,82 +553,47 @@ def _check_package(package_name: str) -> _CheckResult:
 
 def _check_connector(connector_name: str) -> _CheckResult:
     normalized = normalize_connector_name(connector_name)
-    if normalized == "skills-graph":
-        graph = None
-        try:
-            from skills_graph import SkillGraph
+    if normalized not in COMPONENTS:
+        return {"name": f"connector:{connector_name}", "ok": False, "detail": "unsupported connector"}
 
-            graph = SkillGraph()
-            version = _package_version("skills-graph")
-            return {"name": "connector:skills-graph", "ok": True, "detail": f"installed={version}; memgraph=reachable"}
-        except Exception as exc:
-            return {"name": "connector:skills-graph", "ok": False, "detail": f"{type(exc).__name__}: {exc}"}
-        finally:
-            _close(graph and graph._db)
+    from memgraph_context_graph.adapters._identity import resolve_memgraph_env
+    from memgraph_context_graph.hooks.runner import memgraph_kwargs
 
-    if normalized == "actions-graph":
-        graph = None
-        try:
-            from actions_graph import ActionsGraph
+    name = f"connector:{normalized}"
+    graph = None
+    try:
+        graph = COMPONENTS[normalized].graph()(**memgraph_kwargs(resolve_memgraph_env()))
+        detail = f"installed={_package_version(normalized)}; memgraph=reachable"
+        extra = _CONNECTOR_CHECKS.get(normalized)
+        ok, more = extra() if extra is not None else (True, "")
+        return {"name": name, "ok": ok, "detail": f"{detail}; {more}" if ok and more else more or detail}
+    except Exception as exc:
+        return {"name": name, "ok": False, "detail": f"{type(exc).__name__}: {exc}"}
+    finally:
+        _close(graph and graph._db)
 
-            graph = ActionsGraph()
-            version = _package_version("actions-graph")
-            return {"name": "connector:actions-graph", "ok": True, "detail": f"installed={version}; memgraph=reachable"}
-        except Exception as exc:
-            return {"name": "connector:actions-graph", "ok": False, "detail": f"{type(exc).__name__}: {exc}"}
-        finally:
-            _close(graph and graph._db)
 
-    if normalized == "sessions-graph":
-        graph = None
-        try:
-            from sessions_graph import SessionsGraph
-
-            from memgraph_context_graph.adapters._identity import resolve_memgraph_env, resolve_user_id
-            from memgraph_context_graph.hooks.runner import memgraph_kwargs
-
-            graph = SessionsGraph(**memgraph_kwargs(resolve_memgraph_env()))
-            version = _package_version("sessions-graph")
-            user_id = resolve_user_id({})
-            if not user_id:
-                return {
-                    "name": "connector:sessions-graph",
-                    "ok": False,
-                    "detail": "user_id not resolved — run: memgraph-context-graph config set identity.user_id <your-name>",
-                }
-            return {
-                "name": "connector:sessions-graph",
-                "ok": True,
-                "detail": f"installed={version}; memgraph=reachable; user_id={user_id!r}",
-            }
-        except Exception as exc:
-            return {"name": "connector:sessions-graph", "ok": False, "detail": f"{type(exc).__name__}: {exc}"}
-        finally:
-            _close(graph and graph._db)
+def _check_sessions_graph() -> tuple[bool, str]:
+    from memgraph_context_graph.adapters._identity import resolve_user_id
 
-    if normalized == "resources-graph":
-        graph = None
-        try:
-            from memgraph_context_graph.adapters._identity import load_config, resolve_memgraph_env
-            from memgraph_context_graph.hooks.runner import memgraph_kwargs
-            from resources_graph import ResourcesGraph
-
-            graph = ResourcesGraph(**memgraph_kwargs(resolve_memgraph_env()))
-            version = _package_version("resources-graph")
-            # Touches are recorded without a token; the Sweep falls back to the user's gh login.
-            token = "set" if load_config().github_token else "unset (the Sweep uses the gh login)"
-            return {
-                "name": "connector:resources-graph",
-                "ok": True,
-                "detail": f"installed={version}; memgraph=reachable; github.token {token}",
-            }
-        except Exception as exc:
-            return {"name": "connector:resources-graph", "ok": False, "detail": f"{type(exc).__name__}: {exc}"}
-        finally:
-            _close(graph and graph._db)
+    user_id = resolve_user_id({})
+    if not user_id:
+        return False, "user_id not resolved — run: memgraph-context-graph config set identity.user_id <your-name>"
+    return True, f"user_id={user_id!r}"
 
-    else:
-        return {"name": f"connector:{connector_name}", "ok": False, "detail": "unsupported connector"}
+
+def _check_resources_graph() -> tuple[bool, str]:
+    from memgraph_context_graph.adapters._identity import load_config
+
+    # Touches are recorded without a token; the Sweep falls back to the user's gh login.
+    return True, f"github.token {'set' if load_config().github_token else 'unset (the Sweep uses the gh login)'}"
+
+
+#: What a connector needs beyond a reachable Memgraph: (ok, what its check line adds, or why it fails).
+_CONNECTOR_CHECKS: dict[str, Callable[[], tuple[bool, str]]] = {
+    "sessions-graph": _check_sessions_graph,
+    "resources-graph": _check_resources_graph,
+}
 
 
 def _check_embeddings() -> _CheckResult: