surreal-memory 2.7.0__tar.gz → 2.7.2__tar.gz

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: surreal-memory
-Version: 2.7.0
+Version: 2.7.2
 Summary: Reflex-based memory system for AI agents with SurrealDB backend — retrieval through activation, not search
 Project-URL: Homepage, https://github.com/acidkill/surreal-memory
 Project-URL: Documentation, https://github.com/acidkill/surreal-memory/blob/main/docs/getting-started/quickstart.md
@@ -266,6 +266,7 @@ Everything else — sessions, context loading, habit tracking, maintenance — w
 
 - **Encoding Pipeline** — composable async steps: extract entities → create neurons → link synapses → bundle into fibers
 - **Reflex Retrieval** — spreading activation through the neuron graph, combined with SurrealDB vector search when available
+- **Reranking** — optional cross-encoder pass over-fetches SA candidates and blends relevance score with activation level for higher recall precision
 - **Consolidation** — merges similar neurons, reinforces strong paths, prunes weak ones
 - **Compression** — 5-tier lifecycle: full → summary → essence → ghost → metadata
 
@@ -307,6 +308,7 @@ Sync uses **Merkle delta** — only diffs travel, not the full brain.
 - **15 memory types** — fact, decision, error, insight, preference, workflow, instruction, and more
 - **Spreading activation** — memories surface by association, not keyword match
 - **Vector search** — SurrealDB HNSW for semantic similarity (when embeddings are configured)
+- **Cross-encoder reranking** — optional config-driven precision pass, HTTP (shared inference server) or in-process, blended with the activation score
 - **Cognitive reasoning** — hypothesize, submit evidence, make predictions, verify with Bayesian confidence
 
 #### Knowledge Ingestion
@@ -365,6 +367,31 @@ Set the provider to `auto` to pick the best available option at runtime
 
 ---
 
+## Reranking
+
+Spreading activation over-fetches candidates; an optional cross-encoder reranker then
+scores each `(query, memory)` pair for relevance and blends that score with the
+activation level (`blend_weight`, default `0.7`) for a final precision pass. Off by
+default — recall works the same without it.
+
+```toml
+[reranker]
+enabled = true
+endpoint = "http://127.0.0.1:11435/v1"   # OpenAI-compatible /rerank (e.g. llamastash)
+model_name = "BAAI/bge-reranker-v2-m3"
+blend_weight = 0.7
+```
+
+- **HTTP mode** (`endpoint` set) — runs on a shared inference server (e.g. llama.cpp /
+  llamastash on GPU), no `torch` dependency needed locally. Falls back to the
+  `SURREAL_MEMORY_RERANKER_ENDPOINT` env var when `endpoint` is unset.
+- **In-process mode** (no endpoint) — loads a local `sentence-transformers` `CrossEncoder`.
+  Install with `pip install "surreal-memory[reranker]"`.
+- Reranking never breaks recall — any error falls back to the spreading-activation
+  ordering unchanged.
+
+---
+
 ## Setup by Tool
 
 <details>

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/README.md

@@ -154,6 +154,7 @@ Everything else — sessions, context loading, habit tracking, maintenance — w
 
 - **Encoding Pipeline** — composable async steps: extract entities → create neurons → link synapses → bundle into fibers
 - **Reflex Retrieval** — spreading activation through the neuron graph, combined with SurrealDB vector search when available
+- **Reranking** — optional cross-encoder pass over-fetches SA candidates and blends relevance score with activation level for higher recall precision
 - **Consolidation** — merges similar neurons, reinforces strong paths, prunes weak ones
 - **Compression** — 5-tier lifecycle: full → summary → essence → ghost → metadata
 
@@ -195,6 +196,7 @@ Sync uses **Merkle delta** — only diffs travel, not the full brain.
 - **15 memory types** — fact, decision, error, insight, preference, workflow, instruction, and more
 - **Spreading activation** — memories surface by association, not keyword match
 - **Vector search** — SurrealDB HNSW for semantic similarity (when embeddings are configured)
+- **Cross-encoder reranking** — optional config-driven precision pass, HTTP (shared inference server) or in-process, blended with the activation score
 - **Cognitive reasoning** — hypothesize, submit evidence, make predictions, verify with Bayesian confidence
 
 #### Knowledge Ingestion
@@ -253,6 +255,31 @@ Set the provider to `auto` to pick the best available option at runtime
 
 ---
 
+## Reranking
+
+Spreading activation over-fetches candidates; an optional cross-encoder reranker then
+scores each `(query, memory)` pair for relevance and blends that score with the
+activation level (`blend_weight`, default `0.7`) for a final precision pass. Off by
+default — recall works the same without it.
+
+```toml
+[reranker]
+enabled = true
+endpoint = "http://127.0.0.1:11435/v1"   # OpenAI-compatible /rerank (e.g. llamastash)
+model_name = "BAAI/bge-reranker-v2-m3"
+blend_weight = 0.7
+```
+
+- **HTTP mode** (`endpoint` set) — runs on a shared inference server (e.g. llama.cpp /
+  llamastash on GPU), no `torch` dependency needed locally. Falls back to the
+  `SURREAL_MEMORY_RERANKER_ENDPOINT` env var when `endpoint` is unset.
+- **In-process mode** (no endpoint) — loads a local `sentence-transformers` `CrossEncoder`.
+  Install with `pip install "surreal-memory[reranker]"`.
+- Reranking never breaks recall — any error falls back to the spreading-activation
+  ordering unchanged.
+
+---
+
 ## Setup by Tool
 
 <details>

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "surreal-memory"
-version = "2.7.0"
+version = "2.7.2"
 description = "Reflex-based memory system for AI agents with SurrealDB backend — retrieval through activation, not search"
 readme = "README.md"
 license = "MIT"

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/__init__.py

@@ -16,7 +16,7 @@ from surreal_memory.engine.encoder import EncodingResult, MemoryEncoder
 from surreal_memory.engine.reflex_activation import CoActivation, ReflexActivation
 from surreal_memory.engine.retrieval import DepthLevel, ReflexPipeline, RetrievalResult
 
-__version__ = "2.7.0"
+__version__ = "2.7.2"
 
 __all__ = [
     "__version__",

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/engine/diagnostics.py

@@ -513,11 +513,16 @@ class DiagnosticsEngine:
         if neuron_count == 0:
             return 0.0
 
-        all_synapses = await self._storage.get_all_synapses()
-        connected: set[str] = set()
-        for s in all_synapses:
-            connected.add(s.source_id)
-            connected.add(s.target_id)
+        # Prefer the DB-side distinct-endpoints aggregate over loading ~185k
+        # Synapse objects (that scan was seconds of the dashboard's slowness).
+        get_connected = getattr(self._storage, "get_connected_neuron_ids", None)
+        if get_connected is not None:
+            connected: set[str] = set(await get_connected())
+        else:
+            connected = set()
+            for s in await self._storage.get_all_synapses():
+                connected.add(s.source_id)
+                connected.add(s.target_id)
 
         # Also count neurons that belong to fibers as connected
         if fibers:
@@ -536,8 +541,13 @@ class DiagnosticsEngine:
         if neuron_count == 0:
             return 0.0
 
-        states = await self._storage.get_all_neuron_states()
-        activated_count = sum(1 for s in states if s.access_frequency > 0)
+        # DB aggregate instead of loading every neuron_state (~64k rows).
+        count_active = getattr(self._storage, "count_activated_neuron_states", None)
+        if count_active is not None:
+            activated_count = int(await count_active())
+        else:
+            states = await self._storage.get_all_neuron_states()
+            activated_count = sum(1 for s in states if s.access_frequency > 0)
         return activated_count / max(neuron_count, 1)
 
     @staticmethod

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/engine/retrieval.py

@@ -495,15 +495,24 @@ class ReflexPipeline:
                     logger.debug("Deferred write flush failed (non-critical)", exc_info=True)
             return _early_result
 
-        # 4.9 Cross-encoder reranking (optional post-SA refinement)
-        if self._config.reranker_enabled and len(activations) > 1:
+        # 4.9 Cross-encoder reranking (optional post-SA refinement).
+        # Reranking is deployment/runtime config, NOT per-brain state — read it
+        # from the effective app config so each client (CLI, MCP, web UI) uses its
+        # OWN endpoint. Persisting it on the (shared) brain made a reranker-off
+        # client — e.g. the web-UI container — flip the flag for everyone on
+        # connect (the reranker-flip bug). The brain's reranker_* fields are kept
+        # for compatibility but are no longer the source of truth here.
+        from surreal_memory.unified_config import get_config as _get_app_config
+
+        _rr = _get_app_config().reranker
+        if _rr.enabled and len(activations) > 1:
             try:
                 from surreal_memory.engine.reranker import reranker_available
 
                 # The config endpoint (config.toml [reranker].endpoint) makes
                 # reranking available even when neither the env endpoint nor an
                 # in-process CrossEncoder is present, so gate on it explicitly.
-                config_endpoint = (self._config.reranker_endpoint or "").strip()
+                config_endpoint = (_rr.endpoint or "").strip()
                 if config_endpoint or reranker_available():
                     from surreal_memory.engine.reranker import rerank_activations
 
@@ -515,7 +524,7 @@ class ReflexPipeline:
                             key=lambda x: x[1].activation_level,
                             reverse=True,
                         )
-                    ][: self._config.reranker_max_candidates]
+                    ][: _rr.max_candidates]
                     neuron_batch = await self._storage.get_neurons_batch(top_nids)
                     neuron_contents = {
                         nid: n.content for nid, n in neuron_batch.items() if n.content
@@ -526,12 +535,12 @@ class ReflexPipeline:
                             query,
                             activations,
                             neuron_contents,
-                            model_name=self._config.reranker_model,
-                            blend_weight=self._config.reranker_blend_weight,
-                            min_score=self._config.reranker_min_score,
-                            max_candidates=self._config.reranker_max_candidates,
+                            model_name=_rr.model_name,
+                            blend_weight=_rr.blend_weight,
+                            min_score=_rr.min_score,
+                            max_candidates=_rr.max_candidates,
                             limit=50,
-                            endpoint=self._config.reranker_endpoint,
+                            endpoint=_rr.endpoint,
                         )
                         logger.debug(
                             "Reranked %d → %d activations",

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/server/app.py

@@ -586,21 +586,33 @@ def create_app(
         capped_limit = min(limit, 2000)
         edge_cap = 4000
 
-        synapses = await storage.get_all_synapses()
-        total_synapses = len(synapses)
-
-        # Degree count → rank neurons by connectivity, take the densest core.
-        degree: dict[str, int] = {}
-        for s in synapses:
-            degree[s.source_id] = degree.get(s.source_id, 0) + 1
-            degree[s.target_id] = degree.get(s.target_id, 0) + 1
-        ranked_ids = sorted(degree, key=lambda nid: degree[nid], reverse=True)
-        selected_ids = set(ranked_ids[offset : offset + capped_limit])
-
-        # Edge-first: keep edges with both endpoints in the dense set (cap payload).
-        visible_synapses = [
-            s for s in synapses if s.source_id in selected_ids and s.target_id in selected_ids
-        ][:edge_cap]
+        # Degree ranking + edge fetch via DB aggregates/graph traversal when the
+        # backend supports it (SurrealDB). Loading all ~185k synapses into Python
+        # just to rank/filter them was ~10 s of the graph view's 30 s+ hang.
+        get_degrees = getattr(storage, "get_synapse_degrees", None)
+        get_edges = getattr(storage, "get_edges_for_neurons", None)
+        if get_degrees is not None and get_edges is not None:
+            degree: dict[str, int] = await get_degrees()
+            # Each edge contributes once to its in-group and once to its out-group.
+            total_synapses = sum(degree.values()) // 2
+            ranked_ids = sorted(degree, key=lambda nid: degree[nid], reverse=True)
+            selected_ids = set(ranked_ids[offset : offset + capped_limit])
+            # Indexed ->synapse traversal fetches only the selected core's edges.
+            core_edges = await get_edges(list(selected_ids))
+            visible_synapses = [s for s in core_edges if s.target_id in selected_ids][:edge_cap]
+        else:
+            synapses = await storage.get_all_synapses()
+            total_synapses = len(synapses)
+            degree = {}
+            for s in synapses:
+                degree[s.source_id] = degree.get(s.source_id, 0) + 1
+                degree[s.target_id] = degree.get(s.target_id, 0) + 1
+            ranked_ids = sorted(degree, key=lambda nid: degree[nid], reverse=True)
+            selected_ids = set(ranked_ids[offset : offset + capped_limit])
+            # Edge-first: keep edges with both endpoints in the dense set (cap payload).
+            visible_synapses = [
+                s for s in synapses if s.source_id in selected_ids and s.target_id in selected_ids
+            ][:edge_cap]
 
         # Nodes = every endpoint the visible edges reference, plus the selected core.
         endpoint_ids = {s.source_id for s in visible_synapses} | {
@@ -608,11 +620,19 @@ def create_app(
         }
         node_ids = endpoint_ids | selected_ids
 
-        # No id-batch store method exists; index all neurons in Python (~4.6k is fine).
-        all_neurons = await storage.find_neurons(limit=100000)
-        by_id = {n.id: n for n in all_neurons}
-        neurons = [by_id[nid] for nid in node_ids if nid in by_id]
-        total_neurons = len(degree) or len(all_neurons)
+        # Fetch ONLY the nodes we render, without the embedding vector. Loading all
+        # ~64k neurons here (each carrying a 1024-float embedding_vec) was the graph
+        # view's 30 s+ hang; node_ids is a few thousand at most.
+        find_by_ids = getattr(storage, "find_neurons_by_ids", None)
+        if find_by_ids is not None:
+            neurons = await find_by_ids(list(node_ids), include_embedding=False)
+        else:
+            all_neurons = await storage.find_neurons(limit=100000)
+            by_id = {n.id: n for n in all_neurons}
+            neurons = [by_id[nid] for nid in node_ids if nid in by_id]
+        # Isolated neurons never render in the graph, so the connected-node count
+        # (len(degree)) is the graph's universe; the true brain total is on /stats.
+        total_neurons = len(degree)
 
         fibers = await storage.get_fibers(limit=1000)
 

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/server/routes/dashboard_api.py

@@ -94,13 +94,10 @@ async def get_stats() -> DashboardStats:
         """Analyze a single brain using its own per-brain storage."""
         try:
             brain_storage = await get_shared_storage(brain_name=name)
-            stats = await brain_storage.get_stats(name)
-            nc = stats.get("neuron_count", 0)
-            sc = stats.get("synapse_count", 0)
-            fc = stats.get("fiber_count", 0)
 
             grade = "F"
             purity = 0.0
+            nc = sc = fc = 0
             try:
                 from surreal_memory.engine.diagnostics import DiagnosticsEngine
 
@@ -108,8 +105,18 @@ async def get_stats() -> DashboardStats:
                 report = await diag.analyze(name)
                 grade = report.grade
                 purity = report.purity_score
+                # The report already carries the counts (via get_enhanced_stats),
+                # so a separate get_stats here would just repeat the same three
+                # count queries per brain.
+                nc = report.neuron_count
+                sc = report.synapse_count
+                fc = report.fiber_count
             except Exception:
                 logger.debug("Diagnostics failed for brain %s", name, exc_info=True)
+                stats = await brain_storage.get_stats(name)
+                nc = stats.get("neuron_count", 0)
+                sc = stats.get("synapse_count", 0)
+                fc = stats.get("fiber_count", 0)
 
             return BrainSummary(
                 id=name,
@@ -379,7 +386,25 @@ async def get_timeline(
     end: str | None = Query(default=None, description="ISO datetime end"),
 ) -> TimelineResponse:
     """Get chronological list of memories for timeline visualization."""
-    neurons = await storage.find_neurons(limit=min(limit, 2000))
+    # Push the time window into the DB when both bounds are given, and never fetch
+    # the embedding_vec — the timeline uses only id/content/type/created_at/metadata,
+    # so dragging the 1024-float vector per row was pure waste.
+    from datetime import datetime as _dt
+
+    def _iso(s: str | None) -> _dt | None:
+        if not s:
+            return None
+        try:
+            return _dt.fromisoformat(s)
+        except ValueError:
+            return None
+
+    start_dt = _iso(start)
+    end_dt = _iso(end)
+    time_range = (start_dt, end_dt) if start_dt and end_dt else None
+    neurons = await storage.find_neurons(
+        limit=min(limit, 2000), time_range=time_range, include_embedding=False
+    )
 
     entries: list[TimelineEntry] = []
     for n in neurons:
@@ -444,7 +469,9 @@ async def get_daily_stats(
     end = now
 
     # Use public API: find_neurons with time_range
-    neurons = await storage.find_neurons(time_range=(start, end), limit=1000)
+    neurons = await storage.find_neurons(
+        time_range=(start, end), limit=1000, include_embedding=False
+    )
 
     # Aggregate neurons by day
     days_map: dict[str, DailyStatsEntry] = {}

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/storage/base.py

@@ -144,6 +144,7 @@ class NeuralStorage(ABC):
         limit: int = 100,
         offset: int = 0,
         ephemeral: bool | None = None,
+        include_embedding: bool = True,
     ) -> list[Neuron]:
         """
         Find neurons matching criteria.

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/storage/memory_store.py

@@ -106,6 +106,7 @@ class InMemoryStorage(
         limit: int = 100,
         offset: int = 0,
         ephemeral: bool | None = None,
+        include_embedding: bool = True,
     ) -> list[Neuron]:
         full_scan = content_contains is None and content_exact is None
         limit = min(limit, 10000 if full_scan else 1000)

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/storage/shared_store.py

@@ -201,6 +201,7 @@ class SharedStorage(SharedFiberBrainMixin, NeuralStorage):
         limit: int = 100,
         offset: int = 0,
         ephemeral: bool | None = None,
+        include_embedding: bool = True,
     ) -> list[Neuron]:
         """Find neurons matching criteria."""
         params: dict[str, Any] = {"limit": limit, "offset": offset}

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/storage/sqlite_neurons.py

@@ -192,6 +192,7 @@ class SQLiteNeuronMixin:
         limit: int = 100,
         offset: int = 0,
         ephemeral: bool | None = None,
+        include_embedding: bool = True,
     ) -> list[Neuron]:
         # Cache shortcut for exact-match lookups (most repeated pattern)
         if content_exact is not None and content_contains is None and time_range is None:

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/storage/surrealdb/store.py

@@ -601,6 +601,7 @@ class SurrealDBStorage(
         limit: int = 100,
         offset: int = 0,
         ephemeral: bool | None = None,
+        include_embedding: bool = True,
     ) -> list[Neuron]:
         brain_id = self._get_brain_id()
         conditions = ["brain_id = $brain_id"]
@@ -629,12 +630,43 @@ class SurrealDBStorage(
             params["ephemeral"] = ephemeral
 
         where = " AND ".join(conditions)
+        # OMIT the 1024-3072-float embedding_vec when the caller doesn't need it
+        # (dashboard graph/timeline). It is ~4-8 KB/row, so dragging it over tens of
+        # thousands of rows is the single biggest dashboard slowdown after a re-embed.
+        projection = "SELECT *" if include_embedding else "SELECT * OMIT embedding_vec"
         rows = await self._query(
-            f"SELECT * FROM neuron WHERE {where} ORDER BY id LIMIT {int(limit)} START {int(offset)}",
+            f"{projection} FROM neuron WHERE {where} ORDER BY id LIMIT {int(limit)} START {int(offset)}",
             **params,
         )
         return [_row_to_neuron(r) for r in rows]
 
+    async def find_neurons_by_ids(
+        self, neuron_ids: list[str], include_embedding: bool = False
+    ) -> list[Neuron]:
+        """Fetch specific neurons by id in one query, omitting the embedding by
+        default. Used by the graph view, which needs only a few thousand nodes out
+        of tens of thousands and never uses the vector."""
+        if not neuron_ids:
+            return []
+        # Convert to SurrealDB record ids and keep only injection-safe names
+        # (alphanumeric + underscore), since they are interpolated into FROM.
+        safe = [
+            sid
+            for nid in neuron_ids
+            for sid in (_to_surreal_id(nid),)
+            if sid and all(c.isalnum() or c == "_" for c in sid)
+        ]
+        if not safe:
+            return []
+        projection = "SELECT *" if include_embedding else "SELECT * OMIT embedding_vec"
+        out: list[Neuron] = []
+        # Chunk to keep the FROM record-id list a sane query size.
+        for i in range(0, len(safe), 1000):
+            things = ", ".join(f"neuron:{s}" for s in safe[i : i + 1000])
+            rows = await self._query(f"{projection} FROM {things}")
+            out.extend(_row_to_neuron(r) for r in rows)
+        return out
+
     async def suggest_neurons(
         self,
         prefix: str,
@@ -2029,10 +2061,100 @@ class SurrealDBStorage(
         )
         return [_row_to_neuron_state(r) for r in rows]
 
-    async def get_all_synapses(self) -> list[Synapse]:
+    async def count_activated_neuron_states(self, brain_id: str | None = None) -> int:
+        """Count neuron_states with access_frequency > 0 via a DB aggregate.
+
+        Diagnostics used to load every neuron_state (~64k rows) just to count the
+        activated ones — a multi-second scan on the dashboard. This does it in a
+        single ``count() … GROUP ALL`` (~0.4 s)."""
+        bid = brain_id or self._get_brain_id()
+        rows = await self._query(
+            "SELECT count() AS c FROM neuron_state"
+            " WHERE brain_id = $bid AND access_frequency > 0 GROUP ALL",
+            bid=bid,
+        )
+        return int(rows[0].get("c", 0)) if rows else 0
+
+    async def get_connected_neuron_ids(self, brain_id: str | None = None) -> set[str]:
+        """Return the set of neuron ids that are an endpoint of any synapse.
+
+        Uses ``GROUP BY in`` / ``GROUP BY out`` on the native RELATE edge (the
+        `source_id`/`target_id` fields are computed, so `array::group` on them
+        yields nothing — but the real `in`/`out` record links group fine). This
+        replaces loading ~185k Synapse objects (~10 s) for the orphan-rate metric
+        with two distinct-key scans (~2 s total)."""
+        bid = brain_id or self._get_brain_id()
+        connected: set[str] = set()
+        for field in ("in", "out"):
+            rows = await self._query(
+                f"SELECT VALUE {field} FROM synapse WHERE brain_id = $bid GROUP BY {field}",
+                bid=bid,
+            )
+            for rid in rows:
+                connected.add(_from_surreal_id(str(rid)))
+        return connected
+
+    async def get_synapse_degrees(self, brain_id: str | None = None) -> dict[str, int]:
+        """Per-neuron synapse degree via DB ``GROUP BY`` on the RELATE endpoints.
+
+        Replaces loading every synapse into Python just to count endpoints
+        (the dashboard graph's ranking step). Note: grouping must target the
+        real ``in``/``out`` record links — the ``source_id``/``target_id``
+        fields are computed and do not aggregate."""
+        bid = brain_id or self._get_brain_id()
+        degree: dict[str, int] = {}
+        for field in ("in", "out"):
+            rows = await self._query(
+                f"SELECT {field} AS nid, count() AS deg FROM synapse"
+                f" WHERE brain_id = $bid GROUP BY {field}",
+                bid=bid,
+            )
+            for r in rows:
+                nid = _endpoint_to_id(r.get("nid"))
+                if nid:
+                    degree[nid] = degree.get(nid, 0) + int(r.get("deg", 0) or 0)
+        return degree
+
+    async def get_edges_for_neurons(self, neuron_ids: list[str]) -> list[Synapse]:
+        """Outgoing synapses of the given neurons via the indexed graph traversal.
+
+        ``->synapse`` on a record id uses the RELATE edge index, so fetching the
+        edges of a few thousand selected nodes is sub-second — versus ~10 s for a
+        full ``SELECT * FROM synapse`` table scan with 185k+ edges."""
+        if not neuron_ids:
+            return []
+        safe = [
+            sid
+            for nid in neuron_ids
+            for sid in (_to_surreal_id(nid),)
+            if sid and all(c.isalnum() or c == "_" for c in sid)
+        ]
+        edges: list[Synapse] = []
+        for i in range(0, len(safe), 500):
+            things = ", ".join(f"neuron:{s}" for s in safe[i : i + 500])
+            rows = await self._query(
+                "SELECT id, ->synapse.{id, out, type, weight, direction, created_at} AS edges"
+                f" FROM {things}"
+            )
+            for row in rows:
+                src = row.get("id")
+                for e in row.get("edges") or []:
+                    d = dict(e)
+                    d["in"] = src
+                    try:
+                        edges.append(_row_to_synapse(d))
+                    except Exception:
+                        continue
+        return edges
+
+    async def get_all_synapses(self, include_metadata: bool = True) -> list[Synapse]:
         brain_id = self._get_brain_id()
+        # OMIT the metadata blob when the caller (e.g. the dashboard graph) only
+        # needs endpoints/type/weight — it roughly halves the transfer for the
+        # ~185k-row synapse scan.
+        projection = "SELECT *" if include_metadata else "SELECT * OMIT metadata"
         rows = await self._query(
-            "SELECT * FROM synapse WHERE brain_id = $brain_id",
+            f"{projection} FROM synapse WHERE brain_id = $brain_id",
             brain_id=brain_id,
         )
         return [_row_to_synapse(r) for r in rows]

{surreal_memory-2.7.0 → surreal_memory-2.7.2}/src/surreal_memory/unified_config.py

@@ -2130,12 +2130,12 @@ async def _migrate_brain_runtime_config(
     must never break recall.
     """
     try:
+        # NOTE: reranker config is intentionally NOT layered onto the brain here.
+        # It is deployment/runtime config, read from the app config at recall time
+        # (see ReflexPipeline). Persisting it on a shared brain let a reranker-off
+        # client (e.g. the web-UI container) flip the flag for everyone on
+        # connect — the reranker-flip bug. Only [brain] extras are migrated.
         overrides = config.brain.runtime_overrides()
-        # Also layer config.toml [reranker] onto the stored brain so reranking is
-        # driven by app config (issue: reranker BrainConfig fields were never
-        # persisted, so the feature was dead code). Always applied; the diff check
-        # below no-ops when the stored brain already matches.
-        overrides.update(reranker_brain_config_overrides(config.reranker))
         if not overrides:
             return