{
  "notice": "bxzxxr MCP archive: a record of what public MCP servers declared when we listed them (we never call their tools). It is data, not a rating: nothing here says a server is safe, secure, verified or trustworthy, and a server can change after we looked. Secrets we detected are redacted; redacted tool lists are withheld and only their hash is shown.",
  "infrastructure": {
    "host": "mcp.cachly.dev",
    "site": "cachly.dev",
    "addresses": [
      {
        "address": "78.47.24.49",
        "endpoints": 1,
        "shared_infrastructure": false,
        "network": {
          "asn": 24940,
          "name": "HETZNER-AS - Hetzner Online GmbH",
          "prefix": "78.46.0.0/15",
          "country": "DE"
        }
      }
    ],
    "addresses_recorded": true,
    "address_history": [
      {
        "addresses": [
          "78.47.24.49"
        ],
        "first_seen": "2026-11-21T15:04:01.580Z",
        "last_seen": "2026-11-21T15:04:01.580Z",
        "checks": 1
      }
    ],
    "hosting": [],
    "software": [],
    "server_info": {
      "name": "cachly-mcp",
      "version": "0.10.267",
      "protocol_version": "2025-06-18"
    },
    "headers": {
      "strict-transport-security": "max-age=63072000; includeSubDomains; preload",
      "access-control-allow-origin": "*"
    },
    "auth": null
  },
  "related": {
    "same_address": {
      "total": 0,
      "sample": []
    },
    "same_site": {
      "total": 0,
      "sample": []
    },
    "same_tool_list": {
      "total": 0,
      "sample": []
    },
    "same_publisher": {
      "publisher": "io.github.cachly-dev",
      "total": 0,
      "sample": []
    },
    "same_repository": {
      "repository_url": "https://github.com/cachly-dev/cachly-mcp",
      "total": 0,
      "sample": []
    },
    "note": "Shared addresses on big platforms (Cloudflare, Vercel and the like) put unrelated servers together; those are marked shared_infrastructure. A match is a pivot, not a link between operators."
  },
  "endpoint": {
    "id": "28128",
    "server_name": "io.github.cachly-dev/mcp-server",
    "url": "https://mcp.cachly.dev/mcp",
    "host": "mcp.cachly.dev",
    "transport": "streamable-http",
    "last_checked_at": "2026-11-21T15:04:01.580Z",
    "last_state": "listed",
    "last_detail": null,
    "consecutive_failures": 0,
    "current_sha": "742c7a4aec07dc311d1e0d9b00afcfdd528f8431f06bb912f1a6e06fb708af92",
    "first_listed_at": "2026-11-21T15:04:01.580Z",
    "created_at": "2026-11-21T09:25:04.147Z",
    "resolved_addresses": [
      "78.47.24.49"
    ]
  },
  "server": {
    "name": "io.github.cachly-dev/mcp-server",
    "title": "cachly — Explain it once. Every AI knows it.",
    "description": "Keeps the rules, decisions and fixes you explain to your AI, for every session and tool. EU servers.",
    "version": "0.10.267",
    "registry_status": "active",
    "repository_url": "https://github.com/cachly-dev/cachly-mcp",
    "website_url": "https://cachly.dev",
    "published_at": "2026-11-20T11:44:44.572Z",
    "updated_at": "2026-11-20T11:44:44.572Z",
    "first_seen": "2026-11-21T09:25:03.461Z"
  },
  "other_endpoints": [],
  "intel": {
    "capabilities": [
      "keeps-memory",
      "vector-search"
    ],
    "evm_addresses": [],
    "chains": [],
    "tokens": [],
    "computed_at": "2026-11-22T15:43:06.619Z"
  },
  "operator": null,
  "needs_sign_in": false,
  "reachability": {
    "window_days": 30,
    "checks": 1,
    "answered": 1,
    "answered_percent": 100,
    "avg_listing_latency_ms": 1414,
    "first_check_in_window": "2026-11-21T15:04:01.580Z",
    "consecutive_failures_now": 0,
    "days": [
      {
        "day": "2026-11-21",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      }
    ]
  },
  "tool_list": {
    "sha256": "742c7a4aec07dc311d1e0d9b00afcfdd528f8431f06bb912f1a6e06fb708af92",
    "tools": 27,
    "resources": 0,
    "prompts": 0,
    "first_seen": "2026-11-21T15:04:02.996Z",
    "tool_names": [
      "cache_get",
      "cache_set",
      "semantic_search",
      "index_project",
      "remember_context",
      "recall_context",
      "list_remembered",
      "forget_context",
      "learn_from_attempts",
      "recall_best_solution",
      "smart_recall",
      "session_start",
      "session_end",
      "session_handoff",
      "team_learn",
      "team_recall",
      "roadmap_add",
      "roadmap_update",
      "roadmap_list",
      "roadmap_next",
      "brain_doctor",
      "causal_trace",
      "autopilot",
      "brain_search",
      "brain_predict",
      "brain_from_git",
      "cachly_tool"
    ],
    "declared": {
      "tools": [
        {
          "name": "cache_get",
          "description": "Get a value from a running cache instance by key. Returns the stored value (string or deserialized JSON object) or null if the key does not exist or has expired. Read-only — no side effects. Use cache_mget when you need multiple keys in one round-trip. Use cache_exists to check existence without retrieving the value. Use semantic_search when you need fuzzy/vector search across stored values.",
          "inputSchema": {
            "type": "object",
            "required": [
              "key"
            ],
            "properties": {
              "key": {
                "type": "string",
                "description": "Cache key to retrieve"
              },
              "org_id": {
                "type": "string",
                "description": "Optional org ID — if the direct key misses, falls back to the shared org namespace org:{org_id}:sem:{key}"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the instance."
              }
            }
          }
        },
        {
          "name": "cache_set",
          "description": "Set a key-value pair in a running cache instance. Overwrites any existing value at the key — not idempotent for new data. Returns \"OK\" on success; returns an error if the instance_id is invalid or the instance is paused. Value can be a string or a JSON-serialized object. Optionally set a TTL in seconds (omit for no expiry). Use cache_mset instead for setting multiple keys in a single pipeline round-trip. Use cache_stream_set instead for caching LLM token streams (ordered string chunks).",
          "inputSchema": {
            "type": "object",
            "required": [
              "key",
              "value"
            ],
            "properties": {
              "key": {
                "type": "string",
                "description": "Cache key"
              },
              "ttl": {
                "type": "number",
                "description": "Time-to-live in seconds (optional, omit for no expiry)"
              },
              "value": {
                "type": "string",
                "description": "Value to store (string or JSON)"
              },
              "org_id": {
                "type": "string",
                "description": "Optional org ID — also writes the key to the shared org namespace org:{org_id}:sem:{key} with the same TTL"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance (from list_instances)"
              }
            }
          }
        },
        {
          "name": "semantic_search",
          "description": "Find cached entries that are semantically similar to a natural-language query. Read-only — no side effects. Returns an array of objects, each with: key, value, similarity_score (0–1), and namespace. Returns an empty array if no entries meet the similarity threshold. Requires OPENAI_API_KEY (or compatible provider) and CACHLY_VECTOR_URL; every tier includes a vector token. Embeddings are computed server-side and never leave Germany (pgvector HNSW index). Example: \"find all cached responses about password reset\" or \"what did we answer about pricing?\". Use cache_get for exact key lookup; use smart_recall for brain lessons.",
          "inputSchema": {
            "type": "object",
            "required": [
              "query"
            ],
            "properties": {
              "query": {
                "type": "string",
                "description": "Natural-language query to find similar cached content"
              },
              "top_k": {
                "type": "number",
                "description": "Maximum number of results to return (default: 5)"
              },
              "namespace": {
                "type": "string",
                "description": "Semantic namespace to search in (default: cachly:sem)"
              },
              "threshold": {
                "type": "number",
                "description": "Minimum cosine similarity 0–1 (default: 0.82). Lower = broader matches."
              },
              "use_hybrid": {
                "type": "boolean",
                "description": "Enable Hybrid BM25+Vector RRF fusion search. Passes `hybrid: true` and the query text to the pgvector API for higher precision on named entities. Default: false."
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance (from list_instances)"
              },
              "auto_namespace": {
                "type": "boolean",
                "description": "Auto-detect the namespace from the query text using text heuristics instead of using the `namespace` parameter. Returns results only from the matching domain (code/translation/summary/qa/creative)."
              }
            }
          }
        },
        {
          "name": "index_project",
          "description": "Index local source files into the cachly semantic cache so AI assistants can use semantic_search to find relevant files instead of re-reading the whole codebase every time. Walks a directory recursively, reads each matching file, and stores a summary + path as a semantic cache entry (prompt = file path + content excerpt, value = relative path). Requires an embedding provider (OPENAI_API_KEY or CACHLY_EMBED_PROVIDER + key). Run once, then re-run after major refactors. TTL=86400 (24h) keeps entries fresh.",
          "inputSchema": {
            "type": "object",
            "required": [
              "dir"
            ],
            "properties": {
              "dir": {
                "type": "string",
                "description": "Absolute path to the directory to index (e.g. /Users/you/myproject/src)"
              },
              "ttl": {
                "type": "number",
                "description": "TTL in seconds for indexed entries (default: 86400 = 24 h)"
              },
              "max_files": {
                "type": "number",
                "description": "Maximum number of files to index (default: 100)"
              },
              "namespace": {
                "type": "string",
                "description": "Semantic namespace to store under (default: cachly:sem:code)"
              },
              "extensions": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "File extensions to include (default: [\"ts\",\"js\",\"go\",\"py\",\"java\",\"rs\",\"md\",\"kt\",\"swift\"])"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cachly instance"
              },
              "summary_chars": {
                "type": "number",
                "description": "Characters to use as summary per file (default: 1200)"
              }
            }
          }
        },
        {
          "name": "remember_context",
          "description": "Save context information to the cache so you can recall it later without re-computing. Perfect for caching: codebase overviews, file summaries, project structure, frequently-accessed data, or \"thinking\" results like dependency analysis. The AI assistant can use this to avoid re-reading the entire codebase every time. Overwrites any existing value stored under the same key. Returns { key, stored_at, ttl } confirming the saved context. Example: remember_context(\"project overview\", \"This is a Next.js app with...\") then later: recall_context(\"project overview\"). Use recall_context to retrieve; use list_remembered to see all stored keys.",
          "inputSchema": {
            "type": "object",
            "required": [
              "key",
              "content"
            ],
            "properties": {
              "key": {
                "type": "string",
                "description": "Descriptive key like \"project_overview\", \"auth_architecture\", \"file:src/index.ts\""
              },
              "ttl": {
                "type": "number",
                "description": "Time-to-live in seconds (default: 86400 = 24h, use 0 for no expiry)"
              },
              "content": {
                "type": "string",
                "description": "The context/summary/analysis to remember"
              },
              "category": {
                "enum": [
                  "overview",
                  "architecture",
                  "file_summary",
                  "dependency",
                  "thinking",
                  "custom"
                ],
                "type": "string",
                "description": "Category for organization (default: custom)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "recall_context",
          "description": "Retrieve previously saved context from the cache. Returns the saved content or null if not found. Use this at the START of any task to check if you already have relevant context cached, before doing expensive operations like reading many files. Supports glob patterns: \"file:*\" matches all file summaries, \"arch*\" matches architecture-related keys.",
          "inputSchema": {
            "type": "object",
            "required": [
              "key"
            ],
            "properties": {
              "key": {
                "type": "string",
                "description": "The key to look up (supports glob pattern like \"file:*\")"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "list_remembered",
          "description": "List all cached context entries for this project. Shows what knowledge the AI assistant has already cached, so you can decide whether to recall existing context or refresh it. Returns: key, category, size, TTL remaining, and a content preview.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "limit": {
                "type": "number",
                "description": "Max entries to return (default: 50)"
              },
              "category": {
                "enum": [
                  "overview",
                  "architecture",
                  "file_summary",
                  "dependency",
                  "thinking",
                  "custom",
                  "all"
                ],
                "type": "string",
                "description": "Filter by category (default: all)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "forget_context",
          "description": "Delete one or more cached context entries. Use when context is stale or you want to force a fresh analysis. Supports glob patterns: \"file:*\" deletes all file summaries.",
          "inputSchema": {
            "type": "object",
            "required": [
              "keys"
            ],
            "properties": {
              "keys": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Keys to delete (supports glob)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "learn_from_attempts",
          "description": "Store a lesson AFTER any non-trivial task (deploy, debug, fix, decision); future sessions recall it. instance_id may be omitted (never guess one). If the topic already exists, the write is an UPDATE and REQUIRES `grund` (one line: WHY the previous version was wrong) — without it the update is rejected. A conflicting outcome triggers a contradiction warning. Example: learn_from_attempts(topic=\"deploy:api\", outcome=\"success\", what_worked=\"PORT 3095 SERVES WHISPER — nohup docker compose up -d\", severity=\"critical\")",
          "inputSchema": {
            "type": "object",
            "required": [
              "topic",
              "outcome",
              "what_worked"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Topic tags for filtering (e.g. [\"bash\", \"deploy\", \"env\"])"
              },
              "group": {
                "type": "string",
                "description": "Optional sub-team scope, e.g. \"backend\". Only that group and admins see it. Independent of visibility."
              },
              "grund": {
                "type": "string",
                "description": "One line: WHY the previous version was wrong, like a commit message. REQUIRED when the topic already exists; optional on first write."
              },
              "topic": {
                "type": "string",
                "description": "Short slug, e.g. \"deploy:web\", \"debug:redis-tls\", \"fix:generate-series\""
              },
              "author": {
                "type": "string",
                "description": "Who is storing this lesson, e.g. \"alice\". Enables cross-author reuse tracking."
              },
              "context": {
                "type": "string",
                "description": "The SYMPTOM in the words someone would search for, before they knew the fix (\"deploy stuck, rollout not finishing\"). Plus error messages and root cause. Optional but high-value: it is what closes the gap between the question and the answer."
              },
              "ersetzt": {
                "type": "string",
                "description": "Topic slug of an OLDER lesson this one refutes. The old one is suppressed in smart_recall and shows a \"superseded\" banner."
              },
              "gilt_ab": {
                "type": "string",
                "description": "ISO date since when the FACT is true (vs. when written). Omit if unknown. A replacement sets gilt_bis on the old lesson (then shown as history). About the fact, NOT an age decay."
              },
              "outcome": {
                "enum": [
                  "success",
                  "failure",
                  "partial"
                ],
                "type": "string",
                "description": "Did it work?"
              },
              "service": {
                "type": "string",
                "description": "Service or system this lesson concerns, e.g. \"prometheus\", \"auth-service\"."
              },
              "commands": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Commands that worked or failed (e.g. [\"rsync -avz ...\", \"docker compose up -d\"])"
              },
              "severity": {
                "enum": [
                  "critical",
                  "major",
                  "minor"
                ],
                "type": "string",
                "description": "Impact severity: critical (blocks work/deploy), major (significant slowdown), minor (nice to know). Default: major."
              },
              "gilt_fuer": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Version scope of the FACT, package@range, all must hold: [\"next@<15\", \"react@>=18 <19\", \"go@>=1.22\", \"python:fastapi@<0.110\"]. Recall ranks a lesson that does not fit the project versions last, marked, never hidden; unknown = no change. Omit on update to keep, [] clears."
              },
              "depends_on": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Prerequisites, e.g. [\"node:>=20\", \"docker:running\"]. A stale one flags dependent lessons for review."
              },
              "file_paths": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Files involved in this lesson (e.g. [\"infra/deploy.sh\", \".env\"])"
              },
              "visibility": {
                "enum": [
                  "team",
                  "private",
                  "public"
                ],
                "type": "string",
                "description": "Who can see it: \"team\" (default) = all members, \"private\" = only via exact recall_best_solution, \"public\" = same as team for now."
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              },
              "what_failed": {
                "type": "string",
                "description": "What did NOT work (optional but valuable)"
              },
              "what_worked": {
                "type": "string",
                "description": "What solved it. LEAD WITH THE DECISIVE FACT (number, address, command) in the first 100 characters. A measured number needs its basis (\"89.6 % on 500 questions, npm run bench\"); re-measure at 2x data"
              },
              "service_kind": {
                "enum": [
                  "service",
                  "system"
                ],
                "type": "string",
                "description": "\"service\" (default) for an application, \"system\" for infrastructure like prometheus or redis."
              }
            }
          }
        },
        {
          "name": "recall_best_solution",
          "description": "Recall the best known solution for a topic from past lessons. Call this BEFORE attempting any task that might have been done before. Returns the most recent successful lesson for the topic, with confidence indicator. ⚠️ badge = lesson is >5d old (verify before applying). 🔴 = >10d old (likely stale!). Recalling a lesson resets its confidence clock to 1.0 (marks as recently verified). A superseded lesson shows a banner naming its successor; if the successor was deleted, the banner says so and the lesson counts as the best remaining answer. Example: recall_best_solution(topic=\"deploy:web\") → returns the working deploy command.",
          "inputSchema": {
            "type": "object",
            "required": [
              "topic"
            ],
            "properties": {
              "topic": {
                "type": "string",
                "description": "Topic slug to look up, e.g. \"deploy:web\". Supports partial match."
              },
              "author": {
                "type": "string",
                "description": "Who is asking (optional). Required to read a group-scoped lesson: without it, group-scoped lessons answer like \"not found\". Team-wide lessons need no author."
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "smart_recall",
          "description": "Returns the fixes, decisions and pitfalls this team already learned for the task at hand. Call it FIRST at the start of every coding task — before reading files or editing — with one line about the task, e.g. smart_recall(\"fix login redirect loop\"). Finds lessons by meaning, not exact words. instance_id may be omitted (never guess one). Falls back to remember_context keys if no semantic match is found.",
          "inputSchema": {
            "type": "object",
            "required": [
              "query"
            ],
            "properties": {
              "limit": {
                "type": "number",
                "description": "Max results, 1-20 (default 8)."
              },
              "query": {
                "type": "string",
                "description": "Natural language query to find relevant cached context"
              },
              "author": {
                "type": "string",
                "description": "Who is recalling (optional). Counts cross-author reuse."
              },
              "threshold": {
                "type": "number",
                "description": "Similarity threshold 0-1 (default: 0.78)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              },
              "context_files": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Files you are working on, e.g. [\"src/auth/service.ts\"]. Lessons learned around these files rank higher."
              }
            }
          }
        },
        {
          "name": "session_start",
          "description": "Single-call session briefing for the START of a session: last summary, recent lessons, health. It does not replace smart_recall for a concrete task. Returns: last session summary, recent lessons sorted by recency, relevant lessons for your focus area, brain health stats (counts of open failures and stale lessons), team telepathy (what teammates learned this week), predictive pre-warnings (if your focus area has known failure patterns), and memory crystals (compressed wisdom from old sessions). Also saves a session start marker so session_end can compute duration.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "focus": {
                "type": "string",
                "description": "Keywords for what you plan to work on today (e.g. \"deploy infra api\"). Used to surface relevant lessons at the top."
              },
              "author": {
                "type": "string",
                "description": "Your name or handle (e.g. \"alice\"). Enables Team Telepathy — filters YOUR lessons vs TEAM lessons from past 7 days."
              },
              "provider": {
                "type": "string",
                "description": "Current AI provider (e.g. \"claude-code\", \"copilot\", \"cursor\", \"windsurf\"). Shown in the briefing header and saved so the next provider can see who was last active."
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              },
              "workspace_path": {
                "type": "string",
                "description": "Absolute path to the project root. If no session_end was found (e.g. context limit hit), reads git log to reconstruct what happened since last session."
              }
            }
          }
        },
        {
          "name": "session_end",
          "description": "Save a session summary when you finish working. Records what was accomplished, files changed, and lesson count. The next session_start will show this summary as \"Last session\". Call this when ending a work session, before going idle, or before summarizing. Ambient Learning: if workspace_path is provided, reads git log since session start and auto-learns from commits.",
          "inputSchema": {
            "type": "object",
            "required": [
              "summary"
            ],
            "properties": {
              "summary": {
                "type": "string",
                "description": "Brief summary of what was accomplished this session (2-3 sentences)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              },
              "files_changed": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Key files changed this session (optional)"
              },
              "workspace_path": {
                "type": "string",
                "description": "Absolute path to the project root (e.g. \"/Users/you/myproject\"). Enables Ambient Learning — reads git log since session start and auto-learns from commit messages."
              },
              "lessons_learned": {
                "type": "number",
                "description": "Number of new lessons stored this session (optional)"
              }
            }
          }
        },
        {
          "name": "session_handoff",
          "description": "Save a detailed handoff for the NEXT chat window / session. Stores: current progress, TODO list (done + remaining), changed files with descriptions, instructions for the next assistant, and any incomplete work. The next session_start automatically includes this handoff so the new window knows EXACTLY what happened and what remains. Call this BEFORE closing a chat window, especially if work is incomplete. This prevents the \"continue\" problem where new windows lose context, skip tasks, or produce broken code.",
          "inputSchema": {
            "type": "object",
            "required": [
              "completed_tasks",
              "remaining_tasks"
            ],
            "properties": {
              "blocked_on": {
                "type": "string",
                "description": "If work is blocked, describe what is needed to unblock (e.g. \"waiting for API deploy\", \"needs user input on design\")"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              },
              "instructions": {
                "type": "string",
                "description": "Free-form instructions for the next assistant. Be specific: what to do next, what to avoid, what broke."
              },
              "files_changed": {
                "type": "array",
                "items": {
                  "type": "object",
                  "required": [
                    "path",
                    "status"
                  ],
                  "properties": {
                    "path": {
                      "type": "string",
                      "description": "File path relative to project root"
                    },
                    "status": {
                      "enum": [
                        "complete",
                        "partial",
                        "broken"
                      ],
                      "type": "string",
                      "description": "State of this file"
                    },
                    "description": {
                      "type": "string",
                      "description": "What was changed and what still needs work"
                    }
                  }
                },
                "description": "Changed files with their current state — marks partial/broken files so next window knows to fix them"
              },
              "completed_tasks": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Tasks that were fully completed (e.g. \"Implemented brainSearch() in JS SDK\")"
              },
              "context_summary": {
                "type": "string",
                "description": "Brief summary of what happened this session (architecture decisions, key findings, blockers)"
              },
              "remaining_tasks": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Tasks NOT yet done — the next window MUST pick these up"
              }
            }
          }
        },
        {
          "name": "team_learn",
          "description": "Store a lesson in a shared team brain so all team members benefit. Like learn_from_attempts, but REQUIRES an author name for attribution. Shows up in team_recall with \"by <author>\" so the team knows who learned it.",
          "inputSchema": {
            "type": "object",
            "required": [
              "author",
              "topic",
              "outcome",
              "what_worked"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Tags for categorization"
              },
              "topic": {
                "type": "string",
                "description": "Topic in category:keyword format (e.g. \"deploy:api\")"
              },
              "author": {
                "type": "string",
                "description": "Your name or handle (required for team attribution)"
              },
              "outcome": {
                "enum": [
                  "success",
                  "failure",
                  "partial"
                ],
                "type": "string",
                "description": "What happened"
              },
              "commands": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Commands that worked"
              },
              "severity": {
                "enum": [
                  "critical",
                  "major",
                  "minor"
                ],
                "type": "string",
                "description": "Impact level"
              },
              "file_paths": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Relevant file paths"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the shared team brain instance"
              },
              "what_failed": {
                "type": "string",
                "description": "What did NOT work (avoid this)"
              },
              "what_worked": {
                "type": "string",
                "description": "What worked (the solution)"
              }
            }
          }
        },
        {
          "name": "team_recall",
          "description": "Recall lessons from a shared team brain, showing who learned what. Works on any shared instance (all team members using the same instance_id). Shows author, recency, and severity for each lesson. Use this to onboard new team members or find who knows about a topic.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "limit": {
                "type": "number",
                "description": "Max lessons to return (default: 10)"
              },
              "topic": {
                "type": "string",
                "description": "Topic or keyword to filter lessons (optional)"
              },
              "author": {
                "type": "string",
                "description": "Filter by author name (optional)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the shared team brain instance"
              }
            }
          }
        },
        {
          "name": "roadmap_add",
          "description": "Add a new item to the persistent project roadmap stored in the Brain. Items survive across sessions and editors — the roadmap is always up to date. Use for features, bugs, refactors, or any planned work. Call roadmap_list to see all open items, roadmap_next to get the next actionable item.",
          "inputSchema": {
            "type": "object",
            "required": [
              "title"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Tags for filtering (e.g. [\"api\", \"web\", \"sdk\", \"infra\"])"
              },
              "title": {
                "type": "string",
                "description": "Short title of the task/feature (3–10 words)"
              },
              "priority": {
                "enum": [
                  "critical",
                  "high",
                  "medium",
                  "low"
                ],
                "type": "string",
                "description": "Priority level (default: medium)"
              },
              "milestone": {
                "type": "string",
                "description": "Milestone/epic this belongs to (optional)"
              },
              "description": {
                "type": "string",
                "description": "What needs to be done, acceptance criteria, context"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "roadmap_update",
          "description": "Update the status, priority, or details of a roadmap item. Use to move items through the lifecycle: planned → in-progress → done (or blocked/cancelled). Also use to add notes/findings while working on an item.",
          "inputSchema": {
            "type": "object",
            "required": [
              "id"
            ],
            "properties": {
              "id": {
                "type": "string",
                "description": "Item ID returned by roadmap_add or roadmap_list"
              },
              "notes": {
                "type": "string",
                "description": "Progress notes, findings, or blockers (appended to existing notes)"
              },
              "title": {
                "type": "string",
                "description": "Updated title (optional)"
              },
              "status": {
                "enum": [
                  "planned",
                  "in-progress",
                  "done",
                  "blocked",
                  "cancelled"
                ],
                "type": "string",
                "description": "New status for the item"
              },
              "priority": {
                "enum": [
                  "critical",
                  "high",
                  "medium",
                  "low"
                ],
                "type": "string",
                "description": "Updated priority (optional)"
              },
              "description": {
                "type": "string",
                "description": "Updated description (optional)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "roadmap_list",
          "description": "List all roadmap items, optionally filtered by status, priority, tag, or milestone. Returns items sorted by priority then creation date. Called automatically by session_start to show open work.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "tag": {
                "type": "string",
                "description": "Filter by tag (optional)"
              },
              "status": {
                "enum": [
                  "planned",
                  "in-progress",
                  "done",
                  "blocked",
                  "cancelled",
                  "open"
                ],
                "type": "string",
                "description": "Filter by status. Use 'open' to see planned+in-progress+blocked (default: open)"
              },
              "priority": {
                "enum": [
                  "critical",
                  "high",
                  "medium",
                  "low"
                ],
                "type": "string",
                "description": "Filter by minimum priority (optional)"
              },
              "milestone": {
                "type": "string",
                "description": "Filter by milestone (optional)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "roadmap_next",
          "description": "Get the single most important next actionable roadmap item. Returns the highest-priority in-progress item first, then planned items, sorted by priority. Call at session start to immediately know what to work on next.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "tag": {
                "type": "string",
                "description": "Filter by tag (optional)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "brain_doctor",
          "description": "Check the health of your AI Brain and get actionable recommendations. Reports: lesson count, context entries, last session age, open failures, quality score, effective IQ boost, stale index. Returns a prioritized list of issues with fix instructions.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              },
              "workspace_path": {
                "type": "string",
                "description": "Absolute path to workspace root — enables package.json analysis for openclaw cross-promo (optional)"
              }
            }
          }
        },
        {
          "name": "causal_trace",
          "description": "Root Cause Analysis through memory: given a problem description, traces the causal chain from root cause through intermediate failures to the current symptom, then surfaces the exact solution that worked before. Read-only — does not modify any stored data. Requires prior learning: brain must have lessons stored via learn_from_attempts or brain_from_git. Returns an ordered chain of concepts with confidence scores plus the matching solution; returns an empty chain with a message if no causal path is found. Example: causal_trace(problem=\"auth breaks after restart\") → \"Root: k8s:namespace-terminating → keycloak:jwks-race → Solution: PollUntilContextTimeout 3min\". Use recall_best_solution for direct topic lookup, syndicate_search for community patterns, and causal_trace when you have a symptom and need the full root-cause chain.",
          "inputSchema": {
            "type": "object",
            "required": [
              "problem"
            ],
            "properties": {
              "tags": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Optional: narrow search to these tags"
              },
              "problem": {
                "type": "string",
                "description": "Describe the problem or error you are seeing right now"
              },
              "max_depth": {
                "type": "number",
                "description": "Max causal chain depth to trace (default: 5)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              }
            }
          }
        },
        {
          "name": "autopilot",
          "description": "Generate a CLAUDE.md / copilot-instructions.md that makes any AI self-managing forever. Writes a configuration file to disk — will overwrite an existing file at the target path. No auth required beyond a valid instance_id. The generated file instructs Claude, Cursor, Copilot, Windsurf, or Gemini to automatically call session_start at window open, learn_from_attempts after every fix, and session_end before closing — without being asked. Returns the generated file content as a string and the path where it was written. Use style=\"minimal\" for just the three hooks; style=\"full\" for the complete ruleset with examples. One command. Every AI. Always on. Use setup_ai_memory instead if you want an interactive one-shot setup that also creates an instance.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "style": {
                "enum": [
                  "minimal",
                  "full"
                ],
                "type": "string",
                "description": "minimal = just the hooks, full = full ruleset with examples (default: full)"
              },
              "editor": {
                "enum": [
                  "claude",
                  "cursor",
                  "copilot",
                  "windsurf",
                  "gemini",
                  "continue",
                  "all"
                ],
                "type": "string",
                "description": "Target editor (default: claude)"
              },
              "instance_id": {
                "type": "string",
                "description": "UUID of the cache instance."
              },
              "project_name": {
                "type": "string",
                "description": "Your project name (used in generated instructions)"
              }
            }
          }
        },
        {
          "name": "brain_search",
          "description": "BM25+ full-text search over ALL brain data: lessons, context entries, session history, CKG nodes, roadmap items. Unlike smart_recall (which focuses on lessons + context), brain_search casts a wider net. Use when smart_recall returns nothing or when you want to find anything the brain knows about a topic.",
          "inputSchema": {
            "type": "object",
            "required": [
              "query"
            ],
            "properties": {
              "limit": {
                "type": "number",
                "description": "Max results (default: 15)"
              },
              "query": {
                "type": "string",
                "description": "What to search for"
              },
              "instance_id": {
                "type": "string",
                "description": "Brain instance ID"
              }
            }
          }
        },
        {
          "name": "brain_predict",
          "description": "READ-ONLY — no side effects, no writes, no external network calls. Predictive Pre-fetch Engine (PPE): given your current context, reads the CKG in your Redis instance to predict likely failures and return the highest-confidence fixes. \"Pre-load\" means results are returned inline — nothing is cached or persisted. Requires a valid instance_id (your Redis brain). No rate limits. Call at session start when working on a specific feature or debugging area. Set scope=\"org\" to widen prediction across your whole organisation — surfaces cross-team risks (\"failed 3× across 2 other teams\") from the Org Knowledge Graph, so an incident in one team becomes a vaccine for yours.",
          "inputSchema": {
            "type": "object",
            "required": [
              "context"
            ],
            "properties": {
              "scope": {
                "enum": [
                  "instance",
                  "org",
                  "org+commons"
                ],
                "type": "string",
                "description": "Scope: \"instance\" (default) = this brain, \"org\" = warnings from failures in other teams of your organisation, \"org+commons\" = plus public lessons. Falls back to \"instance\" without an org."
              },
              "top_k": {
                "type": "number",
                "description": "Max predictions to return (default: 5)"
              },
              "context": {
                "type": "string",
                "description": "What you're working on, e.g. \"upgrading Keycloak from 21 to 24\""
              },
              "instance_id": {
                "type": "string",
                "description": "Brain instance ID"
              }
            }
          }
        },
        {
          "name": "brain_from_git",
          "description": "Bootstrap brain lessons from git history. Parses commit messages and infers fix/feature/refactor lessons automatically. Great for onboarding an existing codebase — run once and the brain instantly knows your team's accumulated patterns. Incremental by default: only processes new commits since the last run, so repeated calls are fast. Emits progress updates to stderr during long scans.",
          "inputSchema": {
            "type": "object",
            "required": [],
            "properties": {
              "limit": {
                "type": "number",
                "description": "Max commits to process (default: 100, max: 500)"
              },
              "since": {
                "type": "string",
                "description": "Only commits after this date, e.g. \"2024-01-01\" (optional)"
              },
              "branch": {
                "type": "string",
                "description": "Git branch to parse (default: current branch / HEAD)"
              },
              "repo_path": {
                "type": "string",
                "description": "Path to git repository (default: current directory)"
              },
              "incremental": {
                "type": "boolean",
                "description": "Only process commits since last run (default: true). Set false to reprocess all."
              },
              "instance_id": {
                "type": "string",
                "description": "Brain instance ID"
              }
            }
          }
        },
        {
          "name": "cachly_tool",
          "description": "Run any of cachly's specialist tools by name.\n\nThe most-used tools are listed separately above. This one reaches the\nother 98 without their schemas taking up room in every request.\n\nWhen: compact_recover (after a context limit); brain_predict_failures (before a risky step, with odds); brain_plan (plan a task from past lessons); brain_conflicts (lessons contradict); memory_crystalize (condense lessons).\n\nUnsure about a tool's arguments? Call it with describe:true first — that\nreturns its input schema instead of running it.\n\nAvailable: list_instances, create_instance, get_instance, get_connection_string, delete_instance, cache_delete, cache_exists, cache_ttl, cache_keys, cache_stats, detect_namespace, cache_warmup, cache_mset, cache_mget, cache_lock_acquire, cache_lock_release, get_api_status, recall_feedback, lesson_verified, session_start_summary, session_ping, auto_learn_session, brain_who_knows, brain_file_map, team_expertise_map, brain_collab_pairs, brain_portability, skill_gaps, brain_coverage, brain_metrics, brain_changelog, brain_service_map, sync_file_changes, team_confirm, team_assign_role, team_whoami, team_roster, team_audit, team_grant_scope, team_scopes, team_synthesize, memory_crystalize, team_crystallize, brain_hygiene, global_learn, global_recall, publish_lesson, import_public_brain, recall_at, trace_dependency, list_orgs, create_org, invite_member, get_org_plan, setup_ai_memory, cache_stream_set, cache_stream_get, cache_org_stats, set_cost_per_call, memory_consolidate, brain_diff, knowledge_decay, syndicate, syndicate_search, syndicate_stats, syndicate_trending, brain_marketplace, brain_install, ckg_inspect, brain_plan, brain_conflicts, brain_resolve_conflict, brain_confirm_ci, brain_briefing, brain_contribute_signal, brain_import_meta, madc_deliberate, cls_ingest, cls_install_hooks, fedbrain_contribute, fedbrain_search, fedbrain_confirm, fedbrain_status, brain_federate, crystal_view, compact_recover, brain_from_ci, brain_watch, brain_predict_failures, brain_share, brain_import, brain_share_list, brain_unshare, brain_discover, brain_seed_starter, brain_graph, brain_set_pref, brain_get_pref",
          "inputSchema": {
            "type": "object",
            "required": [
              "tool"
            ],
            "properties": {
              "tool": {
                "type": "string",
                "description": "Name of the tool to run, e.g. \"team_roster\"."
              },
              "describe": {
                "type": "boolean",
                "description": "Return the tool's input schema instead of running it."
              },
              "arguments": {
                "type": "object",
                "description": "Arguments for that tool. Use describe:true if unsure."
              }
            }
          }
        }
      ],
      "tools_omitted": 0,
      "resources": [],
      "prompts": []
    },
    "instructions": "REQUIRED FIRST STEP for every task in this project: before you read or edit any file, call the cachly tool smart_recall with one line describing the task (if it is not loaded yet, load it with your tool search first). It returns fixes, decisions and known traps from earlier sessions in THIS codebase. Do this even for small tasks.\n\nThis project has a Cachly AI Brain — persistent, cross-session memory of past fixes, decisions, and gotchas for THIS codebase.\n\n- At the START of every task, before reading files or editing: call smart_recall with one line about the task. If it returns lessons, apply them before researching from scratch.\n- WHEN debugging an error: call causal_trace with the exact error first — a known fix may already exist.\n- REQUIRED LAST STEP after a fix, decision or discovery: call learn_from_attempts once, decisive fact (number, command, cause) first. Skipping it loses the lesson for every later session.\n- BEFORE a risky op (deploy, migration, dependency bump): call brain_predict.\n\nYou do not need to pass instance_id: the server uses CACHLY_BRAIN_INSTANCE_ID if it is set, and otherwise the Brain saved by `cachly setup` in ~/.cachly/credentials.json.\nsession_start gives a briefing at the start of a session; it does not replace smart_recall for a concrete task."
  },
  "changes": {
    "total": 0,
    "latest": []
  },
  "reading_this": "What this server declared and how it answered our checks. Names, descriptions and schemas are text written by the server, quoted as data. Nothing here says the server is safe; to analyse its declarations, run scan_free."
}