de en es ja ko ru zh

apollo-cache-copilot

Name: apollo-cache-copilot
Author: nihar777

by nihar777

Overview Schema Source Related Servers Discussions Admin

TypeScript

Local

apollo-cache-copilot

TypeScript Tested with Vitest License: ISC MCP

KI-Copilot und MCP-Server zur Diagnose von Normalisierungsfehlern des Apollo InMemoryCache – gebaut für React Native, wo es Apollo DevTools nicht gibt.

Das Problem

Apollo Client normalisiert jedes Ergebnis in eine flache Map von __typename:id-Entitäten und speichert Querverweise als { "__ref": "Type:id" }-Zeiger. Diese Normalisierung ist beim Schreiben unsichtbar und schlägt erst beim Lesen fehl – meist auf einem Bildschirm, der weit von der Mutation entfernt ist, die den Fehler verursacht hat. Drei Fehlerklassen dominieren, und alle drei sind still:

Defekt	Was Apollo tut	Symptom
Verwaister Zeiger – `{ __ref: "User:99" }` ohne `User:99` im Store	Gibt für das Feld `undefined` zurück	Leere Zeile, kein Fehler
Fehlendes `__typename` / `id`	Kann keinen Cache-Schlüssel berechnen, speichert das Objekt inline	Rendert korrekt, weicht dann beim zweiten Schreiben ab
Typ-/Schlüssel-Drift – `keyFields` stimmt nicht mit der Server-Payload überein	Dieselbe logische Entität unter zwei Schlüsseln	Doppelte Listeneinträge, veraltete Lesevorgänge

React Native verschlimmert jede einzelne davon:

Keine Apollo DevTools. Die Browser-Erweiterung ist das primäre Cache-Debugging-Werkzeug und existiert auf RN nicht. Der Notbehelf ist console.log(JSON.stringify(client.cache.extract())) und das manuelle Durchsehen eines mehrere Megabyte großen Datenblocks.
Persistierter Cache. apollo3-cache-persist + AsyncStorage bedeutet, dass ein beschädigter Cache einen Neustart der App überlebt – hartnäckig und nur auf dem Gerät des Benutzers reproduzierbar.
Offline-First-Mutationen. Optimistische Antworten schreiben von Natur aus partielle Entitäten – genau die Form, die Defekte 1 und 2 auslöst.
Lange Sitzungen. Mobile Apps bleiben tagelang aktiv, daher akkumuliert die Drift weit länger als in einem Browser-Tab.

Related MCP server: mcp-rn-devtools

Die Lösung

Die Erkennung ist deterministisch. Die Erklärung ist Aufgabe des Modells.

Ein Cache-Analysator, der die Ausgabe von cache.extract() durchläuft und strukturelle Defekte mit exakten Pfaden meldet (User:1.avatar → Avatar:99). Reine Graphtraversierung – kein Modell beteiligt, kein Raten, läuft auf einem 10-MB-Snapshot.
Ein MCP-Server, der diesen Analysator dem jeweiligen Agenten zugänglich macht, mit dem der Entwickler bereits spricht. Der Agent fragt nach Befunden plus dem relevanten Teilgraphen, sodass er nie den gesamten Cache im Kontext halten muss.

Die Diagnose wandelt sich von „10-MB-Blob einfügen und blinzeln" zu einem Gespräch.

Architektur

flowchart TD
    subgraph client["MCP client — Claude Desktop / Cursor"]
        A["Agent (the LLM)"]
    end

    subgraph server["apollo-cache-copilot (stdio process)"]
        T["StdioServerTransport<br/>apollo-copilot mcp"]
        R["Tool registry<br/>inspect_dangling_refs<br/>patch_cache<br/>diagnose_cache_graph"]
        Z["Zod schemas<br/>parse in, shape out"]

        subgraph g["cacheAgentGraph (LangGraph, LLM-free)"]
            I["inspectorNode<br/>writes findings"]
            RE["reasonerNode<br/>writes proposedPatches"]
            P["patcherNode<br/>writes narration"]
            I --> RE --> P
        end

        TOOL1["inspectDanglingRefs()<br/>pure, on a snapshot"]
        TOOL2["patchCache()<br/>modify / evict / gc"]

        T --> R --> Z --> I
        I -.->|calls| TOOL1
        P -.->|plans for| TOOL2
    end

    A <-->|"JSON-RPC 2.0 over stdio"| T
    TOOL1 --- CACHE["cache.extract() snapshot"]
    TOOL2 --- LIVE["live ApolloCache"]

ASCII, dasselbe:

  MCP client (Claude Desktop, Cursor, any stdio client)
        │  JSON-RPC 2.0  ▲
        ▼   over stdio   │  stdout IS the protocol channel —
  ┌─────────────────────────────────┐   all logs go to stderr
  │ StdioServerTransport            │
  ├─────────────────────────────────┤
  │ tools: inspect_dangling_refs    │  read-only
  │        patch_cache              │  mutating (dryRun available)
  │        diagnose_cache_graph     │  read-only, plans only
  ├─────────────────────────────────┤
  │ Zod schemas — parse at the edge │
  └───────────────┬─────────────────┘
                  ▼
  ┌─────────────────────────────────────────────────────┐
  │  cacheAgentGraph  (LangGraph, deliberately LLM-free)│
  │                                                     │
  │  INSPECTOR ──────► REASONER ──────► PATCHER         │
  │  walks the store   maps findings    narrates the     │
  │  → findings[]      → patch ops      plan             │
  │      │                  │                            │
  │      │ owns `findings`  │ owns `proposedPatches`      │
  └──────┼──────────────────┼────────────────────────────┘
         ▼                  ▼
  inspectDanglingRefs()   patchCache()
  pure, on a snapshot     cache.modify / evict / gc on a live cache

Jeder Graphknoten besitzt genau einen Zustandskanal – der Inspector schreibt findings, der Reasoner schreibt proposedPatches, der Patcher schreibt messages. Nur messages akkumuliert; wenn ein Knoten erneut läuft, wird derselbe Cache erneut analysiert, sodass ein Anhängen an anderer Stelle jeden Befund beim zweiten Durchlauf duplizieren würde.

Warum kein LLM im Graph? Jeder Defekt, den dieser Copilot erkennt, hat eine mechanische Reparatur (Zeiger beschneiden, Waise entfernen). Ein Modell würde Latenz, Kosten und Nichtdeterminismus zu einer Entscheidung hinzufügen, die ein switch bereits korrekt trifft. Der Graph verdient seine Daseinsberechtigung als Orchestrierung; das Modell lebt im MCP-Client, wo es einen Befund mit der Mutation oder dem Fragment korreliert, die es geschrieben hat.

Installation

npm install @indianic/apollo-cache-copilot
# or, from a checkout
npm install && npm run build

Erfordert Node.js ≥ 20 (vitest 4 und @langchain/core setzen es voraus; CI deckt 20 und 22 ab). @apollo/client (v3.8+ oder v4), react und react-native sind Peer-Abhängigkeiten – das Paket verwendet die Kopien deiner App.

Verwendung der Bibliothek

Nur ESM. Das Paket enthält Typdefinitionen.

`inspectDanglingRefs` – eine Momentaufnahme prüfen

Rein und synchron. Nimmt die Ausgabe von cache.extract() entgegen und gibt Befunde + Statistiken zurück.

import { inspectDanglingRefs } from 'apollo-cache-copilot';

const { findings, stats } = inspectDanglingRefs({
  cache: client.cache.extract(),
  // all optional:
  rootIds: ['ROOT_QUERY', 'ROOT_MUTATION'], // reachability roots
  includeUnreachable: true,                  // report gc candidates
  includeNormalizationGaps: true,            // report un-keyable inline objects
});

console.log(stats);
// { entityCount: 4, refCount: 3, danglingCount: 1, unreachableCount: 1 }

for (const f of findings) {
  console.log(f.kind, f.path, f.danglingRef ?? '');
  // ORPHANED_REF  User:1.avatar  Avatar:99
  // UNREACHABLE_ENTITY  Post:7
}

Arten von Befunden: ORPHANED_REF, UNREACHABLE_ENTITY, MISSING_TYPENAME, MISSING_ID. Jeder Befund trägt einen exakten Cache-Pfad.

`patchCache` – Reparaturen auf einen Live-Cache anwenden

Operationen sind deklarative Deskriptoren, damit sie einen JSON-Sprung überleben; das Werkzeug rehydriert sie in die Funktionen, die cache.modify erwartet. Geordnet, und Fehler werden aufgezeichnet statt geworfen, sodass ein ungültiger Schlüssel mitten im Stapel den Cache nicht halb gepatcht stranden lassen kann.

import { patchCache } from 'apollo-cache-copilot';

const { dryRun, results, collected } = patchCache(client.cache, {
  operations: [
    // drop dangling refs from a list field
    { type: 'modify', id: 'User:1', fields: { posts: { action: 'PRUNE_DANGLING_REFS' } } },
    // delete / invalidate / overwrite a field
    { type: 'modify', id: 'User:1', fields: { avatar: { action: 'DELETE' } } },
    { type: 'modify', id: 'User:1', fields: { bio: { action: 'SET', value: 'unset' } } },
    // evict an entity, or one field of it
    { type: 'evict', id: 'Post:7' },
    { type: 'evict', id: 'ROOT_QUERY', fieldName: 'user', args: { id: '1' } },
  ],
  gc: true,       // run cache.gc() once, after everything lands
  dryRun: false,  // true = validate only, cache untouched
});

results.forEach((r) => console.log(r.changed, r.error ?? ''));
console.log('collected:', collected); // keys gc() removed

Feldaktionen: DELETE, INVALIDATE, SET (mit value), PRUNE_DANGLING_REFS.

`cacheAgentGraph` – prüfen → ableiten → planen

Der kompilierte LangGraph. Gibt Befunde, die Patch-Operationen, die er anwenden würde, und eine Schritt-für-Schritt-Erzählung zurück. Er mutiert nie – gib proposedPatches an patchCache weiter, sobald du sie überprüft hast.

import { cacheAgentGraph } from 'apollo-cache-copilot';

const state = await cacheAgentGraph.invoke({ cacheState: client.cache.extract() });

state.messages.forEach((m) => console.log(String(m.content)));
// 2 findings: 1 orphaned ref, 1 unreachable entity.
// ...

// Review, then apply:
patchCache(client.cache, { operations: state.proposedPatches });

Außerdem exportiert: buildCacheAgentGraph() (unkompilierter Builder), die einzelnen Knoten inspectorNode / reasonerNode / patcherNode, CacheAgentAnnotation, jedes Zod-Schema (InspectDanglingRefsInputSchema, PatchCacheInputSchema, …) und seine abgeleiteten Typen, sowie die MCP-Oberfläche (createServer, startStdioServer, runInspectDanglingRefs, runPatchCache, runDiagnoseCacheGraph).

CLI-Verwendung

apollo-copilot [mcp]          Start the stdio MCP server (default when no args)
apollo-copilot inspect FILE   Diagnose a JSON cache snapshot and print findings

`apollo-copilot inspect <file>`

Exportiere den Cache aus deiner App und lies ihn dann:

// in the RN app
console.log(JSON.stringify(client.cache.extract()));

npx -y -p @indianic/apollo-cache-copilot apollo-copilot inspect ./cache-snapshot.json

━━ Cache Diagnostic ━━

Entities: 4 | Refs: 3 | Dangling: 1 | Unreachable: 1

⚠  ORPHANED_REF (1)
   • User:1.avatar → Avatar:99
     Points at "Avatar:99", which is not in the cache. Reads here return undefined.

🗑  UNREACHABLE_ENTITY (1)
   • Post:7
     No root reaches this entity; cache.gc() would collect it.

Ein sauberer Cache gibt ✓ Cache is clean: no findings. aus.

Exit-Codes: 0 Erfolg, 1 unerwarteter Fehler, 2 ungültige Eingabe (fehlende Datei, nicht lesbare Datei, ungültiges JSON, unbekannter Befehl).

`apollo-copilot mcp`

Startet den MCP-Server auf stdio und blockiert. Nur nützlich, wenn ein MCP-Client den Prozess besitzt – siehe unten. apollo-copilot-mcp ist ein veralteter Alias für dasselbe.

stdout ist der Protokollkanal. Der Server schreibt nichts außer JSON-RPC nach stdout; alle Diagnosen gehen nach stderr. Füge auf diesem Weg niemals ein console.log hinzu.

MCP-Setup

Verfügbare Tools

Werkzeug	Eingabe	Verhalten
`inspect_dangling_refs`	`cache`, optional `rootIds` / `includeUnreachable` / `includeNormalizationGaps`	Nur lesen. Gibt `findings` + `stats` zurück.
`diagnose_cache_graph`	`cache`	Nur lesen. Führt den vollständigen Graphen aus. Gibt `findings`, `proposedPatches`, `narration` zurück. Nur Planung.
`patch_cache`	`cache`, `operations`, `gc`, `dryRun`	Stellt die Momentaufnahme in einem Wegwerf-`InMemoryCache` wieder her, patcht ihn, gibt `results` + den erneut extrahierten `cache` zurück.

patch_cache führt die Momentaufnahme mit sich, weil ein stdio-Server dem Patcher keinen Live-Cache übergeben kann – nur JSON. Vergleiche den zurückgegebenen cache mit deinem oder stelle ihn mit client.cache.restore() wieder her.

Jedes Werkzeug gibt sowohl eine menschenlesbare Zusammenfassungszeile als auch maschinenlesbares structuredContent zurück, sodass Clients, die strukturierte Ausgaben nicht verstehen, trotzdem das JSON erhalten.

Claude Desktop

~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "apollo-cache-copilot": {
      "command": "npx",
      "args": ["-y", "-p", "@indianic/apollo-cache-copilot", "apollo-copilot", "mcp"]
    }
  }
}

Bei einem lokalen Checkout – zuerst bauen (npm run build), dann mit einem absoluten Pfad auf das bin-Skript zeigen:

{
  "mcpServers": {
    "apollo-cache-copilot": {
      "command": "node",
      "args": ["/absolute/path/to/apollo-cache-copilot/bin/apollo-copilot.js", "mcp"]
    }
  }
}

Starte Claude Desktop neu. Die drei Werkzeuge erscheinen im Tools-Menü.

Cursor

.cursor/mcp.json im Projekt (oder ~/.cursor/mcp.json für jedes Projekt):

{
  "mcpServers": {
    "apollo-cache-copilot": {
      "command": "npx",
      "args": ["-y", "-p", "@indianic/apollo-cache-copilot", "apollo-copilot", "mcp"]
    }
  }
}

Lokaler Checkout:

{
  "mcpServers": {
    "apollo-cache-copilot": {
      "command": "node",
      "args": ["${workspaceFolder}/bin/apollo-copilot.js", "mcp"]
    }
  }
}

Dann Cursor → Einstellungen → MCP → bestätige, dass der Server grün ist.

Dann einfach fragen

„Hier ist meine Cache-Momentaufnahme – warum ist der Avatar auf dem Profilbildschirm leer?"

Der Agent ruft diagnose_cache_graph auf, erhält User:1.avatar → Avatar:99 plus den vorgeschlagenen PRUNE_DANGLING_REFS, und bringt es mit der Mutation in Verbindung, die eine Referenz ohne den Entitätskörper geschrieben hat.

Entwicklung

npm install
npm run build      # tsc -> dist/  (run first: typecheck and tests import dist)
npm run typecheck  # tsc --noEmit -p tsconfig.test.json (includes tests)
npm test           # vitest run

tsconfig.json ist die Build-Konfiguration und schließt __tests__ / __mocks__ aus, sodass das veröffentlichte Paket nur die Werkzeuge umfasst. tsconfig.test.json führt eine Typprüfung für alles durch und erzeugt keine Ausgabe.

Erfolgskennzahlen

#	Kennzahl	Ziel
1	Erkennungs-Recall in der Fixture-Suite	100 % – jeder gezielt eingepflanzte Defekt gefunden
2	Falschpositive bei einer gesunden Momentaufnahme	0
3	Laufzeit des Analysators bei einem 10-MB-`extract()`	< 1s
4	Befunde mit exaktem Cache-Pfad	100 %
5	Entwicklerzeit vom Symptom zur benannten Grundursache	< 5 Min. (statt Stunden)
6	Pro Diagnose an das Modell gesendete Tokens	< 10k – Befunde + Teilgraph, niemals der gesamte Cache

Lizenz

ISC – siehe LICENSE.

Available Tools

3 tools

diagnose_cache_graphDiagnose cache graphA

Read-only

Run the full inspect -> reason -> plan graph over a serialized cache. Returns findings, the proposed patch operations (feed them to patch_cache), and per-step narration. Plans only; never mutates.

ParametersJSON Schema

Name	Required	Description	Default
`cache`	Yes	The full serialized cache, exactly as returned by `cache.extract()`. Keys are cache IDs (e.g. "ROOT_QUERY", "User:1"); values are that entity's stored fields, which may contain `{ "__ref": "<cache id>" }` pointers to other entries in this same object.

Output Schema

ParametersJSON Schema

Name	Required	Description
`findings`	Yes	Every defect the inspector found in `cache`.
`narration`	Yes
`proposedPatches`	Yes	Mechanically-derived fixes for the fixable findings, ready to pass to patch_cache as-is.

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The annotations already declare readOnlyHint=true, and the description reinforces this with 'Plans only; never mutates.' It adds useful behavioral context about what the tool does not do and how its output should be consumed, going beyond the structured annotation without contradicting it.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two dense sentences deliver the pipeline, the return value, the downstream consumer, and the side-effect guarantee. Every phrase earns its place and the most important behavioral constraint is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter tool with a fully documented schema and an output schema, the description is complete: it names the inputs, outputs, downstream action, and non-mutating behavior. Nothing an agent needs to invoke it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already provides 100% coverage, including a detailed description of the cache object and its structure. The tool description does not need to restate parameter details; the schema carries the semantic weight, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb and resource ('Run the full inspect -> reason -> plan graph over a serialized cache') and clearly differentiates itself from the sibling tools by describing its broader pipeline. It also states what it returns, making its role unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when this tool fits: it produces patch operations that should be fed to patch_cache, and it is a planning-only step. It does not explicitly state when to prefer it over inspect_dangling_refs, but the pipeline framing and output-to-patch_cache relationship make the usage context clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

inspect_dangling_refsInspect dangling refsA

Read-only

Audit a serialized Apollo InMemoryCache (cache.extract() output) for dangling __refs, unreachable entities, and objects Apollo could not normalize. Read-only.

ParametersJSON Schema

Name	Required	Description
`cache`	Yes	The full serialized cache, exactly as returned by `cache.extract()`. Keys are cache IDs (e.g. "ROOT_QUERY", "User:1"); values are that entity's stored fields, which may contain `{ "__ref": "<cache id>" }` pointers to other entries in this same object.
`rootIds`	No	Cache IDs to treat as reachability roots for the UNREACHABLE_ENTITY check, e.g. ["ROOT_QUERY"]. Omit to use every one of ROOT_QUERY / ROOT_MUTATION / ROOT_SUBSCRIPTION that is present in `cache`. Has no effect on ORPHANED_REF or normalization-gap findings.
`includeUnreachable`	No	Include UNREACHABLE_ENTITY findings for entities no root can reach (candidates `cache.gc()` would collect). Set false to skip reachability analysis and only check refs/normalization.
`includeNormalizationGaps`	No	Include MISSING_TYPENAME / MISSING_ID findings for inline (non-entity) objects that Apollo could not normalize because they lack a `__typename` or an `id`/`_id` field.

Output Schema

ParametersJSON Schema

Name	Required	Description
`stats`	Yes	Aggregate counts over the whole cache, independent of the findings list.
`findings`	Yes	Every defect found, in walk order.

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide readOnlyHint, and the description repeats 'Read-only.' It adds the scope of audit findings but no additional behavioral context such as error behavior, performance implications, or what the tool does not inspect. With the safety profile already covered by annotations, this is adequate but not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short sentences totaling 19 words. It front-loads the verb, resource, and primary finding types, and 'Read-only' is a harmless, minimal redundancy with the annotation. Every word contributes to understanding what the tool does.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has 4 parameters, 2 siblings, and subtle optional-parameter interactions, but the input schema is exceptionally detailed and an output schema exists, so the short description is sufficient for invocation. The main completeness gap is the lack of an explicit decision rule versus diagnose_cache_graph, preventing a 5.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with detailed parameter documentation for cache, rootIds, includeUnreachable, and includeNormalizationGaps, including defaults and effects on findings. The description itself adds no parameter-level detail beyond the cache.extract() context, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with the specific verb 'Audit' and names the exact resource: a serialized Apollo InMemoryCache from cache.extract(). It then enumerates the three distinct finding categories (dangling __refs, unreachable entities, normalization gaps), which makes the tool's scope precise and differentiates it from the write-oriented patch_cache and the broader-sounding diagnose_cache_graph.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied: use this when you have cache.extract() output and need to audit for ref/reachability/normalization issues. However, there is no explicit when-to-use versus alternatives, no exclusions, and no routing to sibling tools such as diagnose_cache_graph. The context is clear but the guidance is not explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

patch_cachePatch cacheA

Idempotent

Apply declarative repairs (modify / evict, optional gc) to a serialized cache and return the patched store. Set dryRun to validate the operations without changing anything.

ParametersJSON Schema

Name	Required	Description
`gc`	No	Run `cache.gc()` once after all operations land, to collect anything the patches orphaned.
`cache`	Yes	The full serialized cache, exactly as returned by `cache.extract()`. Keys are cache IDs (e.g. "ROOT_QUERY", "User:1"); values are that entity's stored fields, which may contain `{ "__ref": "<cache id>" }` pointers to other entries in this same object.
`dryRun`	No	Validate `operations` and report what would happen without mutating the cache.
`operations`	Yes	One or more modify/evict operations to apply, in order.

Output Schema

ParametersJSON Schema

Name	Required	Description
`cache`	Yes	The store after the operations landed. Unchanged when `dryRun` is true.
`dryRun`	Yes	Echoes the request's dryRun — true means the cache was not actually touched.
`results`	Yes	One result per input operation, in the same order.
`collected`	Yes	Cache keys removed by the trailing `gc()`, when it ran.

TDQS

A3.8/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations indicate readOnlyHint=false and idempotentHint=true, and the description adds meaningful behavioral context beyond those flags: it explicitly states that dryRun validates without mutating the cache, that the modified store is returned, and that gc is optional. This goes beyond what the annotations alone convey, while not contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no filler. The core action is front-loaded, and the dryRun safety note earns its place as a critical usage caveat. It is appropriately sized for the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the very rich input and output schemas, the description only needs to establish the operation intent, the mutating nature, and the dryRun flow, which it does. The main missing element is explicit guidance on when to choose this tool over the siblings, but the schema and annotations cover most invocation details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already thoroughly documents each parameter and nested operation shape. The description mentions modify/evict and dryRun, but it does not add parameter-level meaning beyond what the schema provides. The baseline of 3 applies because the schema carries the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool applies declarative repairs (modify/evict, optional gc) to a serialized cache and returns the patched store. The specific verb 'apply' plus the resource 'serialized cache' and operation types distinguish it from the sibling tools inspect_dangling_refs and diagnose_cache_graph, which are non-mutating inspection tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this tool is for mutating a serialized cache and mentions dryRun for validation, but it gives no explicit guidance on when to use patch_cache versus the sibling tools. No exclusion criteria or alternative routing is provided, so an agent must infer the appropriate context from the tool name and sibling names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

3 tool updatesv1.0.2Aug 26, 2026

Changeddiagnose_cache_graph8 fields changed

addedInput schema / properties / cache / additionalProperties / description

Added value: +"One normalized store entry: the raw field/value map Apollo keeps under a single cache key."

addedInput schema / properties / cache / description

Added value: +"The full serialized cache, exactly as returned by `cache.extract()`. Keys are cache IDs (e.g. \"ROOT_QUERY\", \"User:1\"); values are that entity's stored fields, which may contain `{ \"__ref\": \"<cache id>\" }` pointers to other entries in this same object."

addedOutput schema / properties / findings / description

Added value: +"Every defect the inspector found in `cache`."

addedOutput schema / properties / findings / items / properties / danglingRef / description

Added value: +"The unresolved cache key the ref pointed at. Only present when kind is ORPHANED_REF."

addedOutput schema / properties / findings / items / properties / message / description
```
Added value: +"Human-readable explanation of this finding."
```

addedOutput schema / properties / findings / items / properties / path / description

Added value: +"Dotted path to the defect from its cache key, e.g. \"User:2.posts.1\"."

addedOutput schema / properties / proposedPatches / description

Added value: +"Mechanically-derived fixes for the fixable findings, ready to pass to patch_cache as-is."

changedOutput schema / properties / proposedPatches / items / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "broadcast": {
-        "default": true,
-        "type": "boolean"
-      },
-      "fields": {
-        "additionalProperties": {
-          "oneOf": [
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "DELETE",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            },
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "INVALIDATE",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            },
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "SET",
-                  "type": "string"
-                },
-                "value": {}
-              },
-              "required": [
-                "action",
-                "value"
-              ],
-              "type": "object"
-            },
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "PRUNE_DANGLING_REFS",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            }
-          ]
-        },
-        "propertyNames": {
-          "type": "string"
-        },
-        "type": "object"
-      },
-      "id": {
-        "default": "ROOT_QUERY",
-        "type": "string"
-      },
-      "optimistic": {
-        "default": false,
-        "type": "boolean"
-      },
-      "type": {
-        "const": "modify",
-        "type": "string"
-      }
-    },
-    "required": [
-      "type",
-      "id",
-      "fields",
-      "optimistic",
-      "broadcast"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "args": {
-        "additionalProperties": {},
-        "propertyNames": {
-          "type": "string"
-        },
-        "type": "object"
-      },
-      "broadcast": {
-        "default": true,
-        "type": "boolean"
-      },
-      "fieldName": {
-        "type": "string"
-      },
-      "id": {
-        "type": "string"
-      },
-      "type": {
-        "const": "evict",
-        "type": "string"
-      }
-    },
-    "required": [
-      "type",
-      "id",
-      "broadcast"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "broadcast": {
+        "default": true,
+        "description": "Notify active queries/subscriptions of this change. Set false to patch silently.",
+        "type": "boolean"
+      },
+      "fields": {
+        "additionalProperties": {
+          "oneOf": [
+            {
+              "additionalProperties": false,
+              "description": "Remove this field from the entity entirely.",
+              "properties": {
+                "action": {
+                  "const": "DELETE",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "description": "Mark this field stale so Apollo refetches it, without removing or changing its value.",
+              "properties": {
+                "action": {
+                  "const": "INVALIDATE",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "description": "Overwrite this field with `value` (any JSON — a scalar, object, or `{ \"__ref\": \"<cache id>\" }`).",
+              "properties": {
+                "action": {
+                  "const": "SET",
+                  "type": "string"
+                },
+                "value": {}
+              },
+              "required": [
+                "action",
+                "value"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "description": "Drop any `__ref` pointer(s) this field holds that no longer resolve to an entity in the cache. Works on a single ref or a list of refs; refs that still resolve are left untouched.",
+              "properties": {
+                "action": {
+                  "const": "PRUNE_DANGLING_REFS",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            }
+          ]
+        },
+        "description": "Map of field name -> FieldPatch describing how to change that one field.",
+        "propertyNames": {
+          "type": "string"
+        },
+        "type": "object"
+      },
+      "id": {
+        "default": "ROOT_QUERY",
+        "description": "Cache key of the entity to modify, e.g. \"User:2\". Defaults to \"ROOT_QUERY\" if omitted.",
+        "type": "string"
+      },
+      "optimistic": {
+        "default": false,
+        "description": "Apply against the optimistic layer instead of the base cache. Mirrors `cache.modify`'s option.",
+        "type": "boolean"
+      },
+      "type": {
+        "const": "modify",
+        "type": "string"
+      }
+    },
+    "required": [
+      "type",
+      "id",
+      "fields",
+      "optimistic",
+      "broadcast"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "args": {
+        "additionalProperties": {},
+        "description": "Field arguments to match when evicting a specific parameterized field (used with `fieldName`).",
+        "propertyNames": {
+          "type": "string"
+        },
+        "type": "object"
+      },
+      "broadcast": {
+        "default": true,
+        "description": "Notify active queries/subscriptions of this eviction. Set false to patch silently.",
+        "type": "boolean"
+      },
+      "fieldName": {
+        "description": "Evict only this one field instead of the whole entity at `id`.",
+        "type": "string"
+      },
+      "id": {
+        "description": "Cache key of the entity to evict, e.g. \"Post:5\".",
+        "type": "string"
+      },
+      "type": {
+        "const": "evict",
+        "type": "string"
+      }
+    },
+    "required": [
+      "type",
+      "id",
+      "broadcast"
+    ],
+    "type": "object"
+  }
+]

Changedinspect_dangling_refs14 fields changed

addedInput schema / properties / cache / additionalProperties / description

Added value: +"One normalized store entry: the raw field/value map Apollo keeps under a single cache key."

addedInput schema / properties / cache / description

Added value: +"The full serialized cache, exactly as returned by `cache.extract()`. Keys are cache IDs (e.g. \"ROOT_QUERY\", \"User:1\"); values are that entity's stored fields, which may contain `{ \"__ref\": \"<cache id>\" }` pointers to other entries in this same object."

addedInput schema / properties / includeNormalizationGaps / description

Added value: +"Include MISSING_TYPENAME / MISSING_ID findings for inline (non-entity) objects that Apollo could not normalize because they lack a `__typename` or an `id`/`_id` field."

addedInput schema / properties / includeUnreachable / description

Added value: +"Include UNREACHABLE_ENTITY findings for entities no root can reach (candidates `cache.gc()` would collect). Set false to skip reachability analysis and only check refs/normalization."

addedInput schema / properties / rootIds / description

Added value: +"Cache IDs to treat as reachability roots for the UNREACHABLE_ENTITY check, e.g. [\"ROOT_QUERY\"]. Omit to use every one of ROOT_QUERY / ROOT_MUTATION / ROOT_SUBSCRIPTION that is present in `cache`. Has no effect on ORPHANED_REF or normalization-gap findings."

addedOutput schema / properties / findings / description
```
Added value: +"Every defect found, in walk order."
```

addedOutput schema / properties / findings / items / properties / danglingRef / description

Added value: +"The unresolved cache key the ref pointed at. Only present when kind is ORPHANED_REF."

addedOutput schema / properties / findings / items / properties / message / description
```
Added value: +"Human-readable explanation of this finding."
```

addedOutput schema / properties / findings / items / properties / path / description

Added value: +"Dotted path to the defect from its cache key, e.g. \"User:2.posts.1\"."

addedOutput schema / properties / stats / description

Added value: +"Aggregate counts over the whole cache, independent of the findings list."

addedOutput schema / properties / stats / properties / danglingCount / description
```
Added value: +"Of those refs, how many did not resolve."
```
addedOutput schema / properties / stats / properties / entityCount / description
```
Added value: +"Total cache keys in the input."
```
addedOutput schema / properties / stats / properties / refCount / description
```
Added value: +"Total `__ref` pointers encountered."
```
addedOutput schema / properties / stats / properties / unreachableCount / description
```
Added value: +"Entities no root reaches."
```

Changedpatch_cache15 fields changed

addedInput schema / properties / cache / additionalProperties / description

Added value: +"One normalized store entry: the raw field/value map Apollo keeps under a single cache key."

addedInput schema / properties / cache / description

Added value: +"The full serialized cache, exactly as returned by `cache.extract()`. Keys are cache IDs (e.g. \"ROOT_QUERY\", \"User:1\"); values are that entity's stored fields, which may contain `{ \"__ref\": \"<cache id>\" }` pointers to other entries in this same object."

addedInput schema / properties / dryRun / description

Added value: +"Validate `operations` and report what would happen without mutating the cache."

addedInput schema / properties / gc / description

Added value: +"Run `cache.gc()` once after all operations land, to collect anything the patches orphaned."

addedInput schema / properties / operations / description

Added value: +"One or more modify/evict operations to apply, in order."

changedInput schema / properties / operations / items / oneOf

Previous value: -[
-  {
-    "properties": {
-      "broadcast": {
-        "default": true,
-        "type": "boolean"
-      },
-      "fields": {
-        "additionalProperties": {
-          "oneOf": [
-            {
-              "properties": {
-                "action": {
-                  "const": "DELETE",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            },
-            {
-              "properties": {
-                "action": {
-                  "const": "INVALIDATE",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            },
-            {
-              "properties": {
-                "action": {
-                  "const": "SET",
-                  "type": "string"
-                },
-                "value": {}
-              },
-              "required": [
-                "action",
-                "value"
-              ],
-              "type": "object"
-            },
-            {
-              "properties": {
-                "action": {
-                  "const": "PRUNE_DANGLING_REFS",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            }
-          ]
-        },
-        "propertyNames": {
-          "type": "string"
-        },
-        "type": "object"
-      },
-      "id": {
-        "default": "ROOT_QUERY",
-        "type": "string"
-      },
-      "optimistic": {
-        "default": false,
-        "type": "boolean"
-      },
-      "type": {
-        "const": "modify",
-        "type": "string"
-      }
-    },
-    "required": [
-      "type",
-      "fields"
-    ],
-    "type": "object"
-  },
-  {
-    "properties": {
-      "args": {
-        "additionalProperties": {},
-        "propertyNames": {
-          "type": "string"
-        },
-        "type": "object"
-      },
-      "broadcast": {
-        "default": true,
-        "type": "boolean"
-      },
-      "fieldName": {
-        "type": "string"
-      },
-      "id": {
-        "type": "string"
-      },
-      "type": {
-        "const": "evict",
-        "type": "string"
-      }
-    },
-    "required": [
-      "type",
-      "id"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "properties": {
+      "broadcast": {
+        "default": true,
+        "description": "Notify active queries/subscriptions of this change. Set false to patch silently.",
+        "type": "boolean"
+      },
+      "fields": {
+        "additionalProperties": {
+          "oneOf": [
+            {
+              "description": "Remove this field from the entity entirely.",
+              "properties": {
+                "action": {
+                  "const": "DELETE",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            },
+            {
+              "description": "Mark this field stale so Apollo refetches it, without removing or changing its value.",
+              "properties": {
+                "action": {
+                  "const": "INVALIDATE",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            },
+            {
+              "description": "Overwrite this field with `value` (any JSON — a scalar, object, or `{ \"__ref\": \"<cache id>\" }`).",
+              "properties": {
+                "action": {
+                  "const": "SET",
+                  "type": "string"
+                },
+                "value": {}
+              },
+              "required": [
+                "action",
+                "value"
+              ],
+              "type": "object"
+            },
+            {
+              "description": "Drop any `__ref` pointer(s) this field holds that no longer resolve to an entity in the cache. Works on a single ref or a list of refs; refs that still resolve are left untouched.",
+              "properties": {
+                "action": {
+                  "const": "PRUNE_DANGLING_REFS",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            }
+          ]
+        },
+        "description": "Map of field name -> FieldPatch describing how to change that one field.",
+        "propertyNames": {
+          "type": "string"
+        },
+        "type": "object"
+      },
+      "id": {
+        "default": "ROOT_QUERY",
+        "description": "Cache key of the entity to modify, e.g. \"User:2\". Defaults to \"ROOT_QUERY\" if omitted.",
+        "type": "string"
+      },
+      "optimistic": {
+        "default": false,
+        "description": "Apply against the optimistic layer instead of the base cache. Mirrors `cache.modify`'s option.",
+        "type": "boolean"
+      },
+      "type": {
+        "const": "modify",
+        "type": "string"
+      }
+    },
+    "required": [
+      "type",
+      "fields"
+    ],
+    "type": "object"
+  },
+  {
+    "properties": {
+      "args": {
+        "additionalProperties": {},
+        "description": "Field arguments to match when evicting a specific parameterized field (used with `fieldName`).",
+        "propertyNames": {
+          "type": "string"
+        },
+        "type": "object"
+      },
+      "broadcast": {
+        "default": true,
+        "description": "Notify active queries/subscriptions of this eviction. Set false to patch silently.",
+        "type": "boolean"
+      },
+      "fieldName": {
+        "description": "Evict only this one field instead of the whole entity at `id`.",
+        "type": "string"
+      },
+      "id": {
+        "description": "Cache key of the entity to evict, e.g. \"Post:5\".",
+        "type": "string"
+      },
+      "type": {
+        "const": "evict",
+        "type": "string"
+      }
+    },
+    "required": [
+      "type",
+      "id"
+    ],
+    "type": "object"
+  }
+]

addedOutput schema / properties / cache / additionalProperties / description

Added value: +"One normalized store entry: the raw field/value map Apollo keeps under a single cache key."

addedOutput schema / properties / cache / description

Added value: +"The store after the operations landed. Unchanged when `dryRun` is true."

addedOutput schema / properties / collected / description

Added value: +"Cache keys removed by the trailing `gc()`, when it ran."

addedOutput schema / properties / dryRun / description

Added value: +"Echoes the request's dryRun — true means the cache was not actually touched."

addedOutput schema / properties / results / description

Added value: +"One result per input operation, in the same order."

addedOutput schema / properties / results / items / properties / changed / description
```
Added value: +"Whether `cache.modify` / `cache.evict` actually changed anything."
```

addedOutput schema / properties / results / items / properties / error / description

Added value: +"Set when this one operation failed; the rest of the batch still ran."

addedOutput schema / properties / results / items / properties / operation / description
```
Added value: +"The operation this result is reporting on, echoed back."
```

changedOutput schema / properties / results / items / properties / operation / oneOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "broadcast": {
-        "default": true,
-        "type": "boolean"
-      },
-      "fields": {
-        "additionalProperties": {
-          "oneOf": [
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "DELETE",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            },
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "INVALIDATE",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            },
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "SET",
-                  "type": "string"
-                },
-                "value": {}
-              },
-              "required": [
-                "action",
-                "value"
-              ],
-              "type": "object"
-            },
-            {
-              "additionalProperties": false,
-              "properties": {
-                "action": {
-                  "const": "PRUNE_DANGLING_REFS",
-                  "type": "string"
-                }
-              },
-              "required": [
-                "action"
-              ],
-              "type": "object"
-            }
-          ]
-        },
-        "propertyNames": {
-          "type": "string"
-        },
-        "type": "object"
-      },
-      "id": {
-        "default": "ROOT_QUERY",
-        "type": "string"
-      },
-      "optimistic": {
-        "default": false,
-        "type": "boolean"
-      },
-      "type": {
-        "const": "modify",
-        "type": "string"
-      }
-    },
-    "required": [
-      "type",
-      "id",
-      "fields",
-      "optimistic",
-      "broadcast"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "args": {
-        "additionalProperties": {},
-        "propertyNames": {
-          "type": "string"
-        },
-        "type": "object"
-      },
-      "broadcast": {
-        "default": true,
-        "type": "boolean"
-      },
-      "fieldName": {
-        "type": "string"
-      },
-      "id": {
-        "type": "string"
-      },
-      "type": {
-        "const": "evict",
-        "type": "string"
-      }
-    },
-    "required": [
-      "type",
-      "id",
-      "broadcast"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "broadcast": {
+        "default": true,
+        "description": "Notify active queries/subscriptions of this change. Set false to patch silently.",
+        "type": "boolean"
+      },
+      "fields": {
+        "additionalProperties": {
+          "oneOf": [
+            {
+              "additionalProperties": false,
+              "description": "Remove this field from the entity entirely.",
+              "properties": {
+                "action": {
+                  "const": "DELETE",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "description": "Mark this field stale so Apollo refetches it, without removing or changing its value.",
+              "properties": {
+                "action": {
+                  "const": "INVALIDATE",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "description": "Overwrite this field with `value` (any JSON — a scalar, object, or `{ \"__ref\": \"<cache id>\" }`).",
+              "properties": {
+                "action": {
+                  "const": "SET",
+                  "type": "string"
+                },
+                "value": {}
+              },
+              "required": [
+                "action",
+                "value"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "description": "Drop any `__ref` pointer(s) this field holds that no longer resolve to an entity in the cache. Works on a single ref or a list of refs; refs that still resolve are left untouched.",
+              "properties": {
+                "action": {
+                  "const": "PRUNE_DANGLING_REFS",
+                  "type": "string"
+                }
+              },
+              "required": [
+                "action"
+              ],
+              "type": "object"
+            }
+          ]
+        },
+        "description": "Map of field name -> FieldPatch describing how to change that one field.",
+        "propertyNames": {
+          "type": "string"
+        },
+        "type": "object"
+      },
+      "id": {
+        "default": "ROOT_QUERY",
+        "description": "Cache key of the entity to modify, e.g. \"User:2\". Defaults to \"ROOT_QUERY\" if omitted.",
+        "type": "string"
+      },
+      "optimistic": {
+        "default": false,
+        "description": "Apply against the optimistic layer instead of the base cache. Mirrors `cache.modify`'s option.",
+        "type": "boolean"
+      },
+      "type": {
+        "const": "modify",
+        "type": "string"
+      }
+    },
+    "required": [
+      "type",
+      "id",
+      "fields",
+      "optimistic",
+      "broadcast"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "args": {
+        "additionalProperties": {},
+        "description": "Field arguments to match when evicting a specific parameterized field (used with `fieldName`).",
+        "propertyNames": {
+          "type": "string"
+        },
+        "type": "object"
+      },
+      "broadcast": {
+        "default": true,
+        "description": "Notify active queries/subscriptions of this eviction. Set false to patch silently.",
+        "type": "boolean"
+      },
+      "fieldName": {
+        "description": "Evict only this one field instead of the whole entity at `id`.",
+        "type": "string"
+      },
+      "id": {
+        "description": "Cache key of the entity to evict, e.g. \"Post:5\".",
+        "type": "string"
+      },
+      "type": {
+        "const": "evict",
+        "type": "string"
+      }
+    },
+    "required": [
+      "type",
+      "id",
+      "broadcast"
+    ],
+    "type": "object"
+  }
+]

3 tool updatesv1.0.0Aug 21, 2026
- First observeddiagnose_cache_graph
- First observedinspect_dangling_refs
- First observedpatch_cache

Deploy Server

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

TDQS

A4.2/5.0

Scored 2026-08-26 18:55 across 3 tools

Disambiguation4/5

The three tools map to distinct workflow phases: focused read-only audit, planning/diagnosis, and mutation. inspect_dangling_refs and diagnose_cache_graph overlap in that both return findings, but the descriptions clearly differentiate the focused audit from the full inspect-reason-plan pipeline.

Naming Consistency5/5

All tool names follow a consistent snake_case verb_noun pattern: inspect_dangling_refs, patch_cache, diagnose_cache_graph. The verbs and noun objects are clear and predictable.

Tool Count5/5

Three tools is a well-scoped size for a focused Apollo cache repair copilot. Each tool covers a meaningful stage of the workflow—diagnose, plan, patch—without redundancy or bloat.

Completeness5/5

The surface covers the full repair lifecycle: audit problems, generate a plan, and apply/validate repairs with dry-run and optional GC. There are no obvious dead ends for the stated purpose.

Maintenance

ActivityMaintained

ResponsivenessUnresponsive

Resources

Need Help?

Related Servers

Related MCP Connectors

Meeba Brain A
io.github.meemoprasad
Repository knowledge graph MCP server for codebase understanding and debugging.
Code Analysis Developer Tools
51
Appcircle MCP
io.appcircle
MCP server for Appcircle mobile CI/CD platform.
CI/CD & DevOps Developer Tools
2
Planning Center MCP ServerOAuth
com.planningcenter
The official Planning Center MCP server for interacting with your ministry's data.
App Automation Project Management
2
agentic-commerce A
io.bosonprotocol
MCP server for Boson Protocol — on-chain agentic commerce for physical & digital goods.
Blockchain E-commerce & Retail Autonomous Agents
632

Related MCP Servers

React Native Debugger MCP
Developer Tools Monitoring Code Analysis
twodoorsdev
A
license
B
quality
F
maintenance
An MCP server that connects to your React Native application debugger
Updated 2 years ago (2025-03-28 00:27 UTC)
2
16 npm
32
MIT
mcp-rn-devtools
Developer Tools Monitoring
pablonortiz
A
license
Not graded
quality
A
maintenance
This MCP server enables real-time debugging and inspection of running React Native apps, providing access to console logs, errors, network requests, navigation state, storage, and performance profiling.
Updated 8 days ago (2026-10-05 14:57 UTC)
1
MIT
react-native-dev-mcp
Developer Tools Command Line
luizhbesper
A
license
A
quality
D
maintenance
MCP server that gives AI coding agents hands, eyes and a mechanic's ear for React Native development.
Updated 4 months ago (2026-06-17 10:40 UTC)
9
23 npm
2
MIT
metro-mcp
Developer Tools App Automation Testing & QA Tools
steve228uk
A
license
Not graded
quality
A
maintenance
A plugin-based MCP server for React Native runtime debugging, inspection, and automation via Chrome DevTools Protocol. Works with Expo, bare React Native, and any Metro + Hermes project without app code changes.
Updated a month ago (2026-09-04 20:37 UTC)
575 npm
82
MIT

apollo-cache-copilot

Das Problem

Die Lösung

Architektur

Installation

Verwendung der Bibliothek

inspectDanglingRefs – eine Momentaufnahme prüfen

patchCache – Reparaturen auf einen Live-Cache anwenden

cacheAgentGraph – prüfen → ableiten → planen

CLI-Verwendung

apollo-copilot inspect <file>

apollo-copilot mcp

MCP-Setup

Verfügbare Tools

Claude Desktop

Cursor

Dann einfach fragen

Entwicklung

Erfolgskennzahlen

Lizenz

Available Tools

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

`inspectDanglingRefs` – eine Momentaufnahme prüfen

`patchCache` – Reparaturen auf einen Live-Cache anwenden

`cacheAgentGraph` – prüfen → ableiten → planen

`apollo-copilot inspect <file>`

`apollo-copilot mcp`