diff --git a/pom.xml b/pom.xml
index 5f86377c..a5867da9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -170,6 +170,19 @@
             <version>8.18.0</version>
         </dependency>
 
+        <!-- Caffeine: bounded in-process cache (Apache-2.0). Required because
+             CodeIqApplication enables @EnableCaching but Spring Boot defaults
+             to ConcurrentMapCacheManager (unbounded, no TTL, no eviction) when
+             no provider is on the classpath. Caffeine + the cache.type=caffeine
+             configuration in application.yml gives every @Cacheable region a
+             max-size + write-expiry, capping lifetime-of-process growth on
+             unique-key caches like node-detail and file-tree. Spring Boot
+             manages the version via its parent BOM. -->
+        <dependency>
+            <groupId>com.github.ben-manes.caffeine</groupId>
+            <artifactId>caffeine</artifactId>
+        </dependency>
+
         <!-- Logstash JSON encoder (MIT). Drops a structured JSON line per log
              event with timestamp, level, logger, thread, message, MDC entries
              (request_id, etc.), and optional stack trace. Used in the serving
diff --git a/scripts/aks-launch.sh b/scripts/aks-launch.sh
index a561a846..67b15808 100755
--- a/scripts/aks-launch.sh
+++ b/scripts/aks-launch.sh
@@ -40,11 +40,31 @@ fi
 mkdir -p /tmp/spring-boot-loader
 
 # JVM flag preset. Every entry has a non-default behavior that without it
-# would write outside /tmp. Order: -D system properties first, then -XX.
-# Don't reorder — keep it greppable for the sentinel test.
+# would write outside /tmp OR break under cgroup memory limits. Order: -D
+# system properties first, then -XX. Don't reorder — keep it greppable for
+# the sentinel test.
+#
+# Memory caps explained:
+#   MaxRAMPercentage=50     Heap ceiling = 50% of cgroup memory limit. The
+#                           remaining 50% covers Neo4j off-heap page cache
+#                           (capped at 256 MB in Neo4jConfig), Metaspace,
+#                           JIT code cache, Tomcat NIO buffers, and OS slack.
+#                           At limits.memory: 4Gi this lands the JVM at
+#                           ~2 GiB heap which is 4× the working set of a
+#                           200 K-node graph.
+#   InitialRAMPercentage=25 Lower start, lets G1 grow on demand. Avoids
+#                           paying the full heap reservation up-front so a
+#                           pod that's only doing health probes stays small.
+#   ExitOnOutOfMemoryError  Fail-fast on JVM-side OOM. Lets K8s restart
+#                           cleanly instead of looping in a degraded state
+#                           where readiness probes timeout.
 JAVA_OPTS=(
   -Dorg.springframework.boot.loader.tmpDir=/tmp/spring-boot-loader
   -Djava.io.tmpdir=/tmp
+  -XX:MaxRAMPercentage=50
+  -XX:InitialRAMPercentage=25
+  -XX:+UseG1GC
+  -XX:+ExitOnOutOfMemoryError
   -XX:ErrorFile=/tmp/hs_err_pid%p.log
   -XX:HeapDumpPath=/tmp
   -XX:+HeapDumpOnOutOfMemoryError
diff --git a/shared/runbooks/aks-oom-quick-fix.md b/shared/runbooks/aks-oom-quick-fix.md
new file mode 100644
index 00000000..920a2ce6
--- /dev/null
+++ b/shared/runbooks/aks-oom-quick-fix.md
@@ -0,0 +1,162 @@
+# Runbook: AKS OOM quick fix for `codeiq serve`
+
+> **Audience:** ops engineers seeing `codeiq serve` pods crash, restart-loop, or feel sluggish on AKS (or any Kubernetes cluster) at the typical ~200 K-node graph scale.
+>
+> **Symptom:** pod is `OOMKilled`, or `kubectl top pod` shows steady-state RSS climbing toward the cgroup limit, or readiness probe flaps under load.
+>
+> **Companion:** [`aks-read-only-deploy.md`](aks-read-only-deploy.md) covers the read-only-rootfs deploy shape; this runbook covers the memory tuning that should pair with it.
+
+## TL;DR
+
+```yaml
+resources:
+  requests: { memory: "3Gi", cpu: "500m" }
+  limits:   { memory: "4Gi", cpu: "2"     }
+env:
+  - name: JAVA_TOOL_OPTIONS
+    value: >-
+      -XX:MaxRAMPercentage=50
+      -XX:InitialRAMPercentage=25
+      -XX:+UseG1GC
+      -XX:+ExitOnOutOfMemoryError
+      -XX:+HeapDumpOnOutOfMemoryError
+      -XX:HeapDumpPath=/tmp/codeiq-oom.hprof
+readinessProbe:
+  httpGet: { path: /actuator/health/readiness, port: 8080 }
+  initialDelaySeconds: 60
+  periodSeconds: 30
+  timeoutSeconds: 10
+  failureThreshold: 3
+livenessProbe:
+  httpGet: { path: /actuator/health/liveness, port: 8080 }
+  initialDelaySeconds: 90
+  periodSeconds: 30
+  failureThreshold: 6
+```
+
+If you only do one thing, **set `MaxRAMPercentage=50` and `limits.memory: 4Gi`** — that alone resolves most OOMKilled crashes on the current architecture.
+
+## 1. Why a graph this small OOMs
+
+On a typical workload (~200 K nodes, ~320 K edges) the raw graph is ~150–200 MiB. The pod still OOMs because three independent memory-consumers fight for the same cgroup limit:
+
+| Consumer | Default behaviour (untuned) | After the v0.2.1 quick-win PR |
+|---|---|---|
+| JVM heap | `-XX:MaxRAMPercentage=75` (JDK 25 default in containers) → ~3 GiB on a 4 GiB pod | Capped at 50% via `aks-launch.sh` |
+| Neo4j page cache | Auto-grabs ~50% of *free* RAM at startup (off-heap, additive) | Capped at 256 MiB in `Neo4jConfig.java` |
+| Spring `@Cacheable` regions | `ConcurrentMapCacheManager` — unbounded, no TTL, no eviction | Caffeine `maximumSize=1000, expireAfterWrite=5m` |
+| Topology snapshot | Two independent `AtomicReference<List<CodeNode>>` (one in `McpTools`, one in `TopologyController`) | One shared `TopologySnapshotProvider`, 60 s TTL |
+
+The first two cumulatively exceed `limits.memory` because nothing tells either side it has to share. The next two leak slowly under normal traffic until the heap fills.
+
+## 2. Diagnostic — what's actually broken
+
+Run these inside the cluster before applying the patch. They tell you whether the failure mode is **kernel OOM** (cgroup limit) or **JVM heap thrash** (probes timing out under GC pauses) — different fixes apply.
+
+```bash
+NS=<your-namespace>
+POD=$(kubectl -n $NS get pod -l app=codeiq -o jsonpath='{.items[0].metadata.name}')
+
+# 1. Are pods being kernel-OOM-killed?
+kubectl -n $NS get events --sort-by='.lastTimestamp' | grep -iE "oom|kill|evict"
+kubectl -n $NS describe pod $POD | grep -A2 "Last State"
+
+# 2. Pod resource limits + actual usage
+kubectl -n $NS get pod $POD -o jsonpath='{.spec.containers[0].resources}'; echo
+kubectl -n $NS top pod $POD
+
+# 3. JVM-effective heap settings + current heap
+kubectl -n $NS exec $POD -- jcmd 1 VM.flags  | tr ' ' '\n' | grep -E "MaxHeapSize|MaxRAMPercentage"
+kubectl -n $NS exec $POD -- jcmd 1 GC.heap_info
+```
+
+### Decision tree
+
+- **`Last State: Terminated  Reason: OOMKilled`** → pod hit the cgroup limit. Apply the full TL;DR patch above.
+- **No `OOMKilled`, but readiness flaps (`Reason: Unhealthy` events for `/actuator/health/readiness`)** → JVM is in GC thrash. The Caffeine + topology-snapshot fixes in v0.2.1 + bumping `failureThreshold: 6` resolve this without changing pod size.
+- **Steady-state RSS keeps climbing for hours** → unbounded Spring cache. Confirm the pod image includes the Caffeine fix (v0.2.1+) by checking `kubectl exec $POD -- jcmd 1 VM.classloader_stats | grep -i caffeine`.
+
+## 3. Apply the Deployment patch
+
+```yaml
+# Deployment.spec.template.spec.containers[0]
+resources:
+  # request = guaranteed-not-evicted floor; limit = hard cgroup ceiling.
+  # 200 K-node graphs comfortably fit in 4 GiB total once the v0.2.1
+  # quick-win lands. Bump the limit (not the request) if your store grows
+  # past ~500 MB on disk.
+  requests:
+    memory: "3Gi"
+    cpu: "500m"
+  limits:
+    memory: "4Gi"
+    cpu: "2"
+env:
+  - name: JAVA_TOOL_OPTIONS
+    # JAVA_TOOL_OPTIONS is picked up by every JVM invocation and prepended
+    # to argv. Useful here because aks-launch.sh already sets the same
+    # flags at exec time — the env var is a belt-and-braces fallback if
+    # ops bypass the launch wrapper (e.g. kubectl exec'ing into the pod).
+    value: >-
+      -XX:MaxRAMPercentage=50
+      -XX:InitialRAMPercentage=25
+      -XX:+UseG1GC
+      -XX:+ExitOnOutOfMemoryError
+      -XX:+HeapDumpOnOutOfMemoryError
+      -XX:HeapDumpPath=/tmp/codeiq-oom.hprof
+readinessProbe:
+  # Spring + Neo4j cold start is 10–16s. initialDelaySeconds of 60 gives
+  # Spring's lazy beans + the first Neo4j page-cache page-in headroom
+  # before the first probe failure can mark the pod NotReady.
+  httpGet: { path: /actuator/health/readiness, port: 8080 }
+  initialDelaySeconds: 60
+  periodSeconds: 30
+  timeoutSeconds: 10
+  failureThreshold: 3
+livenessProbe:
+  # failureThreshold: 6 over periodSeconds: 30 = 3 minutes of tolerated
+  # unresponsiveness before SIGKILL. Critical because GraphHealthIndicator
+  # runs against Neo4j and a flushing page cache can stall it briefly
+  # under burst traffic. Liveness must never flap on transient slowness;
+  # only on actual JVM-dead.
+  httpGet: { path: /actuator/health/liveness, port: 8080 }
+  initialDelaySeconds: 90
+  periodSeconds: 30
+  failureThreshold: 6
+```
+
+After `kubectl apply`, watch the rollout:
+
+```bash
+kubectl -n $NS rollout status deployment/codeiq --timeout=5m
+kubectl -n $NS top pod -l app=codeiq         # RSS should land near the requested 3Gi, not the 4Gi limit
+kubectl -n $NS logs -l app=codeiq --tail=200 | grep -iE "oom|outofmemory|gc"
+```
+
+## 4. What this does NOT fix
+
+- **5 M+ node graphs.** At that scale the topology snapshot is multi-GB regardless of TTL. The bounded-Cypher refactor is needed (tracked as the topology-deep-refactor follow-up).
+- **runCypher misuse.** Operators or LLM agents can still run unbounded ad-hoc Cypher and OOM the pod. Limit the `runCypher` MCP tool's `maxResults` via `codeiq.yml` if you expose it externally.
+- **Heap dump capture under cgroup pressure.** `HeapDumpPath=/tmp` is fine on tmpfs-backed `/tmp` (the read-only deploy uses `emptyDir: { medium: Memory }`), but if `/tmp` is also at the limit when the OOM fires, the dump won't write. For long-term diagnosis attach an `emptyDir` volume sized at `1.5 × heap` and point `HeapDumpPath` at it.
+
+## 5. Horizontal scaling
+
+The image-bundled read-only graph means each pod is fully stateless — `replicas: N` is safe. The only per-pod state worth knowing about is the in-process rate-limit `ConcurrentHashMap` in `RateLimitFilter`; token buckets reset per-replica, which is correct for per-key throttling but means a global rate limit across replicas isn't enforced. Most workloads don't need that.
+
+```yaml
+spec:
+  replicas: 3
+  strategy:
+    type: RollingUpdate
+    rollingUpdate:
+      maxUnavailable: 0
+      maxSurge: 1
+```
+
+A 3-replica deploy at `4Gi × 3 = 12Gi` total cluster cost gives ~3× the request capacity of a single 8Gi pod with zero crash risk.
+
+## 6. Cross-references
+
+- Code changes that landed alongside this runbook: `config/Neo4jConfig.java` (page-cache cap), `query/TopologySnapshotProvider.java` (shared snapshot), `application.yml` (Caffeine cache type), `scripts/aks-launch.sh` (JVM flag preset).
+- Related runbook: [`aks-read-only-deploy.md`](aks-read-only-deploy.md) — the deploy shape this OOM patch sits inside.
+- Architecture rationale: [`shared/runbooks/engineering-standards.md`](engineering-standards.md) §4 (resource sizing) and the OOM review thread in the project history.
diff --git a/src/main/java/io/github/randomcodespace/iq/api/TopologyController.java b/src/main/java/io/github/randomcodespace/iq/api/TopologyController.java
index d6d6ae8f..eae8ecae 100644
--- a/src/main/java/io/github/randomcodespace/iq/api/TopologyController.java
+++ b/src/main/java/io/github/randomcodespace/iq/api/TopologyController.java
@@ -1,12 +1,7 @@
 package io.github.randomcodespace.iq.api;
 
-import io.github.randomcodespace.iq.cache.AnalysisCache;
-import io.github.randomcodespace.iq.config.CodeIqConfig;
-import io.github.randomcodespace.iq.graph.GraphStore;
-import io.github.randomcodespace.iq.model.CodeEdge;
-import io.github.randomcodespace.iq.model.CodeNode;
 import io.github.randomcodespace.iq.query.TopologyService;
-import org.springframework.beans.factory.annotation.Autowired;
+import io.github.randomcodespace.iq.query.TopologySnapshotProvider;
 import org.springframework.context.annotation.Profile;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -16,14 +11,16 @@
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.server.ResponseStatusException;
 
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * REST API controller for service topology queries.
+ *
+ * <p>Reads topology data from {@link TopologySnapshotProvider} which is
+ * shared with {@code McpTools}. Previously this controller kept its own
+ * lifetime-of-process {@code AtomicReference<List<CodeNode>>}, doubling the
+ * topology heap footprint under mixed REST + MCP traffic.
  */
 @RestController
 @RequestMapping("/api/topology")
@@ -31,145 +28,79 @@
 public class TopologyController {
 
     private final TopologyService topologyService;
-    private final GraphStore graphStore;
-    private final CodeIqConfig config;
-    private final AtomicReference<List<CodeNode>> cachedNodes = new AtomicReference<>();
-    private final AtomicReference<List<CodeEdge>> cachedEdges = new AtomicReference<>();
+    private final TopologySnapshotProvider snapshotProvider;
 
     public TopologyController(TopologyService topologyService,
-                              @Autowired(required = false) GraphStore graphStore,
-                              CodeIqConfig config) {
+                              TopologySnapshotProvider snapshotProvider) {
         this.topologyService = topologyService;
-        this.graphStore = graphStore;
-        this.config = config;
+        this.snapshotProvider = snapshotProvider;
     }
 
-    // --- Data loading: Neo4j first, H2 fallback ---
-
-    /**
-     * Check whether Neo4j has data available.
-     */
-    private volatile Boolean neo4jHasData;
-
-    private boolean hasNeo4jData() {
-        if (graphStore == null) return false;
-        if (neo4jHasData != null) return neo4jHasData;
-        try {
-            neo4jHasData = graphStore.count() > 0;
-        } catch (Exception e) {
-            neo4jHasData = false;
-        }
-        return neo4jHasData;
-    }
-
-    /**
-     * Load data from Neo4j if available, otherwise from H2 cache.
-     */
-    private synchronized void ensureDataLoaded() {
-        if (cachedNodes.get() != null) return;
-
-        // Try Neo4j first (has enriched data with SERVICE nodes)
-        if (hasNeo4jData()) {
-            List<CodeNode> nodes = graphStore.findAll();
-            cachedNodes.set(nodes);
-            // Collect edges from all nodes' relationship lists
-            cachedEdges.set(nodes.stream()
-                    .flatMap(n -> n.getEdges().stream())
-                    .toList());
-            return;
-        }
-
-        // Fall back to H2 cache
-        Path root = Path.of(config.getRootPath()).toAbsolutePath().normalize();
-        Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");
-        Path h2File = root.resolve(config.getCacheDir()).resolve("analysis-cache.mv.db");
-        if (!Files.exists(h2File)) return;
-        try (AnalysisCache cache = new AnalysisCache(cachePath)) {
-            cachedNodes.set(cache.loadAllNodes());
-            cachedEdges.set(cache.loadAllEdges());
+    private TopologySnapshotProvider.Snapshot requireSnapshot() {
+        TopologySnapshotProvider.Snapshot snap = snapshotProvider.snapshot();
+        // 404 only when no source was reachable (preserves legacy behaviour
+        // where ensureDataLoaded() left cachedNodes==null vs []). A loaded
+        // but empty graph still returns 200 with empty topology.
+        if (!snap.loaded()) {
+            throw new ResponseStatusException(HttpStatus.NOT_FOUND,
+                    "No analysis cache found. Run analyze first.");
         }
-    }
-
-    /**
-     * Invalidate the in-memory cache (e.g. after re-analysis).
-     */
-    public synchronized void invalidateCache() {
-        cachedNodes.set(null);
-        cachedEdges.set(null);
-        neo4jHasData = null;
+        return snap;
     }
 
     @GetMapping
     public Map<String, Object> getTopology() {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.getTopology(nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.getTopology(s.nodes(), s.edges());
     }
 
     @GetMapping("/services/{name}")
     public Map<String, Object> serviceDetail(@PathVariable String name) {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.serviceDetail(name, nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.serviceDetail(name, s.nodes(), s.edges());
     }
 
     @GetMapping("/services/{name}/deps")
     public Map<String, Object> serviceDependencies(@PathVariable String name) {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.serviceDependencies(name, nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.serviceDependencies(name, s.nodes(), s.edges());
     }
 
     @GetMapping("/services/{name}/dependents")
     public Map<String, Object> serviceDependents(@PathVariable String name) {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.serviceDependents(name, nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.serviceDependents(name, s.nodes(), s.edges());
     }
 
     @GetMapping("/blast-radius/{nodeId}")
     public Map<String, Object> blastRadius(@PathVariable String nodeId) {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.blastRadius(nodeId, nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.blastRadius(nodeId, s.nodes(), s.edges());
     }
 
     @GetMapping("/path")
     public List<Map<String, Object>> findPath(
             @RequestParam("from") String source,
             @RequestParam("to") String target) {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.findPath(source, target, nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.findPath(source, target, s.nodes(), s.edges());
     }
 
     @GetMapping("/bottlenecks")
     public List<Map<String, Object>> findBottlenecks() {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.findBottlenecks(nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.findBottlenecks(s.nodes(), s.edges());
     }
 
     @GetMapping("/circular")
     public List<List<String>> findCircularDeps() {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.findCircularDeps(nodes, cachedEdges.get());
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.findCircularDeps(s.nodes(), s.edges());
     }
 
     @GetMapping("/dead")
     public List<Map<String, Object>> findDeadServices() {
-        ensureDataLoaded();
-        List<CodeNode> nodes = requireCache();
-        return topologyService.findDeadServices(nodes, cachedEdges.get());
-    }
-
-    private List<CodeNode> requireCache() {
-        List<CodeNode> nodes = cachedNodes.get();
-        if (nodes == null) {
-            throw new ResponseStatusException(HttpStatus.NOT_FOUND,
-                    "No analysis cache found. Run analyze first.");
-        }
-        return nodes;
+        TopologySnapshotProvider.Snapshot s = requireSnapshot();
+        return topologyService.findDeadServices(s.nodes(), s.edges());
     }
 }
diff --git a/src/main/java/io/github/randomcodespace/iq/config/Neo4jConfig.java b/src/main/java/io/github/randomcodespace/iq/config/Neo4jConfig.java
index 2f0cf4a1..3a503cbc 100644
--- a/src/main/java/io/github/randomcodespace/iq/config/Neo4jConfig.java
+++ b/src/main/java/io/github/randomcodespace/iq/config/Neo4jConfig.java
@@ -9,6 +9,7 @@
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
 import org.neo4j.graphdb.GraphDatabaseService;
+import org.neo4j.io.ByteUnit;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.context.annotation.Bean;
@@ -46,7 +47,15 @@ DatabaseManagementService databaseManagementService(CodeIqConfig config, Environ
                 // (e.g. unbounded variable-length match on a hub node) from hogging
                 // the page cache and starving readiness/liveness probes. Audit
                 // finding #2 (HIGH) — runs alongside per-tool timeouts in McpTools.
-                .setConfig(GraphDatabaseSettings.transaction_timeout, Duration.ofSeconds(30));
+                .setConfig(GraphDatabaseSettings.transaction_timeout, Duration.ofSeconds(30))
+                // Bound Neo4j off-heap page cache. Without an explicit cap, embedded
+                // Neo4j auto-sizes the page cache to ~50% of free RAM at startup,
+                // which races the JVM heap inside an AKS pod (single cgroup memory
+                // limit) and triggers OOMKilled before either side stabilises. Sized
+                // for the read-only serving workload — the ~200 K-node graphs we
+                // ship today fit comfortably in 256 MB; lift this if your store
+                // grows past ~500 MB on disk.
+                .setConfig(GraphDatabaseSettings.pagecache_memory, ByteUnit.mebiBytes(256));
 
         // Read-only mode for serving profile — no lock files, no transaction logs.
         // Required for read-only filesystems (e.g., AKS with read-only volumes).
diff --git a/src/main/java/io/github/randomcodespace/iq/mcp/McpTools.java b/src/main/java/io/github/randomcodespace/iq/mcp/McpTools.java
index 65646f28..7cf214b5 100644
--- a/src/main/java/io/github/randomcodespace/iq/mcp/McpTools.java
+++ b/src/main/java/io/github/randomcodespace/iq/mcp/McpTools.java
@@ -20,6 +20,7 @@
 import io.github.randomcodespace.iq.query.QueryService;
 import io.github.randomcodespace.iq.query.StatsService;
 import io.github.randomcodespace.iq.query.TopologyService;
+import io.github.randomcodespace.iq.query.TopologySnapshotProvider;
 import org.neo4j.graphdb.GraphDatabaseService;
 import org.neo4j.graphdb.Result;
 import org.slf4j.Logger;
@@ -36,8 +37,6 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * MCP tool definitions using Spring AI annotations.
@@ -62,6 +61,7 @@ public class McpTools {
     private final StatsService statsService;
     private final TopologyService topologyService;
     private final GraphStore graphStore;
+    private final TopologySnapshotProvider snapshotProvider;
     private final EvidencePackAssembler evidencePackAssembler;
     private final ArtifactMetadataProvider artifactMetadataProvider;
 
@@ -70,22 +70,12 @@ public class McpTools {
     /** Hard depth cap on variable-length traversals (default 10). */
     private final int maxDepth;
 
-    /**
-     * 60s TTL on the full-graph snapshot used by the topology tools. Without
-     * this, every concurrent {@code blast_radius} / {@code find_path} /
-     * {@code service_dependencies} call paid the full {@code findAll()} cost
-     * and double-allocated multi-GB heaps on large graphs (audit C1 HIGH).
-     */
-    private static final long CACHE_TTL_NANOS = TimeUnit.SECONDS.toNanos(60);
-    private final AtomicReference<CachedSnapshot> graphSnapshot = new AtomicReference<>();
-
-    private record CachedSnapshot(CacheData data, long takenAtNanos) {}
-
     public McpTools(QueryService queryService,
                     CodeIqConfig config, ObjectMapper objectMapper,
                     Optional<FlowEngine> flowEngine, GraphDatabaseService graphDb,
                     StatsService statsService, TopologyService topologyService,
                     GraphStore graphStore,
+                    TopologySnapshotProvider snapshotProvider,
                     Optional<EvidencePackAssembler> evidencePackAssembler,
                     Optional<ArtifactMetadataProvider> artifactMetadataProvider,
                     CodeIqUnifiedConfig unifiedConfig) {
@@ -97,6 +87,7 @@ public McpTools(QueryService queryService,
         this.statsService = statsService;
         this.topologyService = topologyService;
         this.graphStore = graphStore;
+        this.snapshotProvider = snapshotProvider;
         this.evidencePackAssembler = evidencePackAssembler.orElse(null);
         this.artifactMetadataProvider = artifactMetadataProvider.orElse(null);
         McpLimitsConfig lim = unifiedConfig != null && unifiedConfig.mcp() != null
@@ -106,44 +97,32 @@ public McpTools(QueryService queryService,
     }
 
     /**
-     * Load graph data on-demand from Neo4j, served from a 60-second TTL cache
-     * to avoid double-allocating the full graph under concurrent topology calls.
-     * <p>
-     * Audit C1 (HIGH) — without the cache, every {@code service_dependencies},
-     * {@code blast_radius}, {@code find_path}, {@code find_bottlenecks},
-     * {@code find_circular_deps}, {@code find_dead_services}, {@code find_node}
-     * call paid the full {@code findAll()} cost and two concurrent calls
-     * double-allocated. On a 5M-node graph that is multi-GB per call.
-     * <p>
-     * TODO (follow-up): refactor TopologyService to use Cypher queries instead
-     * of in-memory traversal so the snapshot isn't needed at all. The cache
-     * is the bridge fix.
+     * Adapt the shared {@link TopologySnapshotProvider} to the local
+     * {@link CacheData} record that the topology tool methods consume.
+     *
+     * <p>The provider holds the snapshot (60 s TTL, deduplicates concurrent
+     * loads); this thin wrapper keeps the existing call shape inside
+     * {@code McpTools} and preserves the legacy "no analysis data" error
+     * contract on which test fixtures + MCP error envelopes depend. The
+     * actual cache used to live here as a per-bean {@code AtomicReference};
+     * {@code TopologyController} kept a second one with no TTL, so under
+     * mixed REST + MCP traffic two multi-MB snapshots coexisted on heap.
+     * The shared provider eliminates that duplicate.
      */
     private CacheData getCachedData() {
-        long now = System.nanoTime();
-        CachedSnapshot current = graphSnapshot.get();
-        if (current != null && (now - current.takenAtNanos()) < CACHE_TTL_NANOS) {
-            return current.data();
-        }
-        // Stale or missing — recompute. Two concurrent recomputes can both
-        // hit findAll() once before either replaces the snapshot; that's fine
-        // (rare, bounded to the TTL window) and far less than the previous
-        // every-call double-allocation behavior.
-        List<CodeNode> nodes = graphStore.findAll();
-        List<CodeEdge> edges = nodes.stream()
-                .flatMap(n -> n.getEdges().stream())
-                .toList();
-        if (nodes.isEmpty()) {
+        TopologySnapshotProvider.Snapshot snap = snapshotProvider.snapshot();
+        // MCP topology tools can't operate on a missing-or-empty graph —
+        // collapse "no source" and "loaded but empty" into the same error
+        // since both leave the tool with nothing to traverse.
+        if (!snap.loaded() || snap.nodes().isEmpty()) {
             throw new RuntimeException("No analysis data available. Run 'codeiq analyze' first.");
         }
-        CacheData fresh = new CacheData(nodes, edges);
-        graphSnapshot.set(new CachedSnapshot(fresh, System.nanoTime()));
-        return fresh;
+        return new CacheData(snap.nodes(), snap.edges());
     }
 
-    /** Test-only — invalidate the snapshot cache so a new {@code findAll()} runs next call. */
+    /** Test-only — invalidate the shared snapshot so a new {@code findAll()} runs next call. */
     void invalidateGraphSnapshotCacheForTesting() {
-        graphSnapshot.set(null);
+        snapshotProvider.invalidate();
     }
 
     @McpTool(name = "get_stats", description = "Get graph overview: total nodes, edges, files, languages, and frameworks detected. Use when asked about project size, composition, or what was analyzed. Returns JSON with counts and breakdowns.")
diff --git a/src/main/java/io/github/randomcodespace/iq/query/TopologySnapshotProvider.java b/src/main/java/io/github/randomcodespace/iq/query/TopologySnapshotProvider.java
new file mode 100644
index 00000000..39b80aca
--- /dev/null
+++ b/src/main/java/io/github/randomcodespace/iq/query/TopologySnapshotProvider.java
@@ -0,0 +1,119 @@
+package io.github.randomcodespace.iq.query;
+
+import io.github.randomcodespace.iq.cache.AnalysisCache;
+import io.github.randomcodespace.iq.config.CodeIqConfig;
+import io.github.randomcodespace.iq.graph.GraphStore;
+import io.github.randomcodespace.iq.model.CodeEdge;
+import io.github.randomcodespace.iq.model.CodeNode;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Single owner of the in-heap topology snapshot used by both the REST topology
+ * endpoints ({@code TopologyController}) and the topology MCP tools
+ * ({@code McpTools}).
+ *
+ * <p>Previously each consumer kept its own
+ * {@code AtomicReference<List<CodeNode>>} — {@code TopologyController} never
+ * expired its copy (lifetime-of-process), {@code McpTools} had a 60 s TTL.
+ * Under mixed REST + MCP traffic two multi-MB snapshots coexisted on heap.
+ * This bean unifies both into one 60-second TTL snapshot, halving the
+ * topology heap ceiling.
+ *
+ * <p><b>Why a TTL on read-only data?</b> The window doesn't refresh stale data
+ * (it doesn't change at serve); it deduplicates concurrent loads — if two
+ * requests hit the cold path at once, only one full {@code findAll()} pays
+ * the cost. After 60 s of idle the snapshot becomes GC-eligible, so an idle
+ * pod releases the heap.
+ *
+ * <p><b>Neo4j first, H2 fallback.</b> Preserves the legacy
+ * {@code TopologyController.ensureDataLoaded()} behaviour where serve could
+ * boot off a raw H2 cache (pre-enrich). Real serve deploys go through enrich.
+ *
+ * <p><b>Empty data is not an error here.</b> Returning an empty
+ * {@link Snapshot} lets each consumer choose its own error shape:
+ * {@code RuntimeException} for MCP (becomes a structured error envelope),
+ * {@code ResponseStatusException(NOT_FOUND)} for REST.
+ */
+@Component
+@Profile("serving")
+public class TopologySnapshotProvider {
+
+    /**
+     * Topology snapshot. {@code loaded} distinguishes "source was reachable
+     * and returned data (possibly empty)" from "no source available at all"
+     * — the former is a legitimate 200-with-empty-body response, the latter
+     * is a 404 (run analyze/enrich first). Without this flag the controller
+     * conflates "empty graph" with "never analyzed".
+     */
+    public record Snapshot(List<CodeNode> nodes, List<CodeEdge> edges, boolean loaded) {
+        public static Snapshot of(List<CodeNode> nodes, List<CodeEdge> edges) {
+            return new Snapshot(nodes, edges, true);
+        }
+        public static Snapshot unavailable() {
+            return new Snapshot(List.of(), List.of(), false);
+        }
+    }
+
+    private static final long TTL_NANOS = TimeUnit.SECONDS.toNanos(60);
+
+    private final GraphStore graphStore;
+    private final CodeIqConfig config;
+    private final AtomicReference<TimedSnapshot> cache = new AtomicReference<>();
+
+    private record TimedSnapshot(Snapshot snapshot, long takenAtNanos) {}
+
+    public TopologySnapshotProvider(@Autowired(required = false) GraphStore graphStore,
+                                    CodeIqConfig config) {
+        this.graphStore = graphStore;
+        this.config = config;
+    }
+
+    public Snapshot snapshot() {
+        long now = System.nanoTime();
+        TimedSnapshot current = cache.get();
+        if (current != null && (now - current.takenAtNanos()) < TTL_NANOS) {
+            return current.snapshot();
+        }
+        Snapshot fresh = load();
+        cache.set(new TimedSnapshot(fresh, System.nanoTime()));
+        return fresh;
+    }
+
+    public void invalidate() {
+        cache.set(null);
+    }
+
+    private Snapshot load() {
+        if (graphStore != null) {
+            try {
+                if (graphStore.count() > 0) {
+                    List<CodeNode> nodes = graphStore.findAll();
+                    List<CodeEdge> edges = nodes.stream()
+                            .flatMap(n -> n.getEdges().stream())
+                            .toList();
+                    return Snapshot.of(nodes, edges);
+                }
+            } catch (Exception ignored) {
+                // Fall through to H2 fallback.
+            }
+        }
+
+        Path root = Path.of(config.getRootPath()).toAbsolutePath().normalize();
+        Path cachePath = root.resolve(config.getCacheDir()).resolve("analysis-cache.db");
+        Path h2File = root.resolve(config.getCacheDir()).resolve("analysis-cache.mv.db");
+        if (Files.exists(h2File)) {
+            try (AnalysisCache h2 = new AnalysisCache(cachePath)) {
+                return Snapshot.of(h2.loadAllNodes(), h2.loadAllEdges());
+            }
+        }
+        return Snapshot.unavailable();
+    }
+}
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index a2ef2586..a55e6e45 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -98,7 +98,16 @@ spring:
     exclude:
       - org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration
   cache:
-    type: simple
+    # Caffeine replaces the default ConcurrentMapCacheManager which was
+    # unbounded — every @Cacheable region in QueryService (node-detail,
+    # file-tree, consumers, callers, etc.) accumulated lifetime-of-process
+    # entries keyed by node-id / depth / offset. maximumSize=1000 caps each
+    # named region at 1000 entries; expireAfterWrite=5m bounds staleness.
+    # Both are intentionally generous for a read-only graph that doesn't
+    # change between enrich runs.
+    type: caffeine
+    caffeine:
+      spec: maximumSize=1000,expireAfterWrite=5m
 
 logging:
   level:
diff --git a/src/test/java/io/github/randomcodespace/iq/api/TopologyControllerExtendedTest.java b/src/test/java/io/github/randomcodespace/iq/api/TopologyControllerExtendedTest.java
index 9b158765..b497e11f 100644
--- a/src/test/java/io/github/randomcodespace/iq/api/TopologyControllerExtendedTest.java
+++ b/src/test/java/io/github/randomcodespace/iq/api/TopologyControllerExtendedTest.java
@@ -49,6 +49,7 @@ class TopologyControllerExtendedTest {
     private GraphStore graphStore;
 
     private TopologyController controller;
+    private io.github.randomcodespace.iq.query.TopologySnapshotProvider snapshotProvider;
 
     @TempDir
     Path tempDir;
@@ -58,7 +59,9 @@ void setUp() {
         var config = new CodeIqConfig();
         // Use the temp dir as rootPath so H2 fallback finds no cache file
         CodeIqConfigTestSupport.override(config).rootPath(tempDir.toString()).done();
-        controller = new TopologyController(topologyService, graphStore, config);
+        snapshotProvider = new io.github.randomcodespace.iq.query.TopologySnapshotProvider(
+                graphStore, config);
+        controller = new TopologyController(topologyService, snapshotProvider);
         mockMvc = MockMvcBuilders.standaloneSetup(controller).build();
     }
 
@@ -335,8 +338,8 @@ void invalidateCacheClearsState() throws Exception {
         mockMvc.perform(get("/api/topology").accept(MediaType.APPLICATION_JSON))
                 .andExpect(status().isOk());
 
-        // Invalidate
-        controller.invalidateCache();
+        // Invalidate the shared snapshot (controller no longer holds its own cache)
+        snapshotProvider.invalidate();
 
         // Second call should reload data (count called again)
         mockMvc.perform(get("/api/topology").accept(MediaType.APPLICATION_JSON))
diff --git a/src/test/java/io/github/randomcodespace/iq/api/TopologyEndpointTest.java b/src/test/java/io/github/randomcodespace/iq/api/TopologyEndpointTest.java
index 45a29692..2a6e57c8 100644
--- a/src/test/java/io/github/randomcodespace/iq/api/TopologyEndpointTest.java
+++ b/src/test/java/io/github/randomcodespace/iq/api/TopologyEndpointTest.java
@@ -66,16 +66,18 @@ void setUp() {
 
         objectMapper = new ObjectMapper();
 
-        // GraphStore returns >0 count so TopologyController loads from Neo4j
+        // GraphStore returns >0 count so TopologySnapshotProvider loads from Neo4j
         lenient().when(graphStore.count()).thenReturn(1L);
         lenient().when(graphStore.findAll()).thenReturn(List.of());
 
-        var topologyController = new TopologyController(topologyService, graphStore, config);
+        var snapshotProvider = new io.github.randomcodespace.iq.query.TopologySnapshotProvider(
+                graphStore, config);
+        var topologyController = new TopologyController(topologyService, snapshotProvider);
         mockMvc = MockMvcBuilders.standaloneSetup(topologyController).build();
 
         mcpTools = new McpTools(queryService, config, objectMapper,
                 Optional.empty(), graphDb, new StatsService(),
-                new TopologyService(), graphStore,
+                new TopologyService(), graphStore, snapshotProvider,
                 Optional.empty(), Optional.empty(), null);
     }
 
diff --git a/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsEvidenceTest.java b/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsEvidenceTest.java
index c6fc36d3..37956e06 100644
--- a/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsEvidenceTest.java
+++ b/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsEvidenceTest.java
@@ -49,10 +49,11 @@ void setUp() {
                 Map.of(), "cafebabe");
         org.mockito.Mockito.lenient().when(metadataProvider.current()).thenReturn(metadata);
 
+        var snapshotProvider = new io.github.randomcodespace.iq.query.TopologySnapshotProvider(graphStore, config);
         mcpTools = new McpTools(
                 queryService, config, objectMapper,
                 Optional.empty(), graphDb,
-                statsService, topologyService, graphStore,
+                statsService, topologyService, graphStore, snapshotProvider,
                 Optional.of(assembler), Optional.of(metadataProvider), null);
     }
 
@@ -70,10 +71,12 @@ void getEvidencePackReturnsPackJson() throws Exception {
 
     @Test
     void getEvidencePackReturnsErrorWhenAssemblerAbsent() {
+        var noConfig = new CodeIqConfig();
         McpTools noAssembler = new McpTools(
-                queryService, new CodeIqConfig(), objectMapper,
+                queryService, noConfig, objectMapper,
                 Optional.empty(), graphDb,
                 statsService, topologyService, graphStore,
+                new io.github.randomcodespace.iq.query.TopologySnapshotProvider(graphStore, noConfig),
                 Optional.empty(), Optional.empty(), null);
 
         String result = noAssembler.getEvidencePack("Foo", null, null, null);
@@ -89,10 +92,12 @@ void getArtifactMetadataReturnsMetadataJson() {
 
     @Test
     void getArtifactMetadataReturnsErrorWhenAbsent() {
+        var noMetaConfig = new CodeIqConfig();
         McpTools noMeta = new McpTools(
-                queryService, new CodeIqConfig(), objectMapper,
+                queryService, noMetaConfig, objectMapper,
                 Optional.empty(), graphDb,
                 statsService, topologyService, graphStore,
+                new io.github.randomcodespace.iq.query.TopologySnapshotProvider(graphStore, noMetaConfig),
                 Optional.empty(), Optional.empty(), null);
 
         String result = noMeta.getArtifactMetadata();
diff --git a/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsExpandedTest.java b/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsExpandedTest.java
index a9460174..4f71eec9 100644
--- a/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsExpandedTest.java
+++ b/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsExpandedTest.java
@@ -64,10 +64,15 @@ void setUp() {
         config = new CodeIqConfig();
         CodeIqConfigTestSupport.override(config).rootPath(".").done();
         objectMapper = new ObjectMapper();
+        // Default the GraphStore as having data so the snapshot provider takes
+        // its Neo4j path (count > 0 → findAll). Lenient because tests that
+        // don't reach a topology tool never read it.
+        org.mockito.Mockito.lenient().when(graphStore.count()).thenReturn(1L);
+        var snapshotProvider = new io.github.randomcodespace.iq.query.TopologySnapshotProvider(graphStore, config);
         mcpTools = new McpTools(
                 queryService, config, objectMapper,
                 Optional.empty(), graphDb, statsService,
-                new TopologyService(), graphStore,
+                new TopologyService(), graphStore, snapshotProvider,
                 Optional.empty(), Optional.empty(), null
         );
     }
diff --git a/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsTest.java b/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsTest.java
index 4c812ddd..537f32ba 100644
--- a/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsTest.java
+++ b/src/test/java/io/github/randomcodespace/iq/mcp/McpToolsTest.java
@@ -57,7 +57,11 @@ void setUp() {
         config = new CodeIqConfig();
         CodeIqConfigTestSupport.override(config).rootPath(".").done();
         objectMapper = new ObjectMapper();
-        mcpTools = new McpTools(queryService, config, objectMapper, java.util.Optional.ofNullable(flowEngine), graphDb, statsService, new io.github.randomcodespace.iq.query.TopologyService(), graphStore, java.util.Optional.empty(), java.util.Optional.empty(), null);
+        // Default GraphStore.count() so TopologySnapshotProvider takes its
+        // Neo4j path; tests that hit topology tools stub findAll() too.
+        org.mockito.Mockito.lenient().when(graphStore.count()).thenReturn(1L);
+        var snapshotProvider = new io.github.randomcodespace.iq.query.TopologySnapshotProvider(graphStore, config);
+        mcpTools = new McpTools(queryService, config, objectMapper, java.util.Optional.ofNullable(flowEngine), graphDb, statsService, new io.github.randomcodespace.iq.query.TopologyService(), graphStore, snapshotProvider, java.util.Optional.empty(), java.util.Optional.empty(), null);
     }
 
     private Map<String, Object> parseJson(String json) throws IOException {