@cachly-dev/mcp-server 0.10.6 → 0.10.8

package/src/handlers/syndicate.ts

@@ -4,7 +4,6 @@ import { calculateConfidence } from '../confidence.js';
 import { ckgSlug, ckgUpdateEdge } from '../ckg.js';
 import type { CKGEdge, CKGNode } from '../ckg.js';
 import { keywordSearch, tokenize } from '../search.js';
-import { safeJsonParse } from '../utils.js';
 
 type GetConnection = (instanceId: string) => Promise<Redis>;
 type ApiFetch = <T>(path: string, options?: RequestInit) => Promise<T>;
@@ -293,8 +292,7 @@ export async function handleSyndicateTool(
         for (const ek of [...fromKeys, ...toKeys].slice(0, 50)) {
           const raw = await redis.get(ek);
           if (!raw) continue;
-          const edge = safeJsonParse<CKGEdge | null>(raw, null);
-          if (!edge) continue;
+          const edge: CKGEdge = JSON.parse(raw);
           allEdges.push(edge);
           if (hop < max_hops) {
             if (!visited.has(edge.from)) queue.push({ id: edge.from, hop: hop + 1 });
@@ -368,18 +366,16 @@ export async function handleSyndicateTool(
         for (const nk of nodeKeys.slice(0, 5)) {
           const nodeRaw = await redis.get(nk);
           if (!nodeRaw) continue;
-          const node = safeJsonParse<CKGNode | null>(nodeRaw, null);
-          if (!node) continue;
+          const node: CKGNode = JSON.parse(nodeRaw);
           const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${node.id}`);
           for (const ek of edgeKeys.slice(0, 20)) {
             const edgeRaw = await redis.get(ek);
             if (!edgeRaw) continue;
-            const edge = safeJsonParse<CKGEdge | null>(edgeRaw, null);
-            if (!edge) continue;
+            const edge: CKGEdge = JSON.parse(edgeRaw);
             // Only interested in fixes and co-occurs for prediction
             if (edge.edgeType !== 'fixes' && edge.edgeType !== 'co-occurs' && edge.edgeType !== 'causes') continue;
             const lessonRaw = await redis.get(`cachly:lesson:best:${edge.from}`);
-            const lesson = lessonRaw ? safeJsonParse<{ what_worked?: string; topic: string } | null>(lessonRaw, null) ?? undefined : undefined;
+            const lesson = lessonRaw ? JSON.parse(lessonRaw) : undefined;
             predictions.push({ concept: node.id, edgeType: edge.edgeType, target: edge.to, confidence: edge.confidence, lesson });
           }
         }
@@ -393,17 +389,15 @@ export async function handleSyndicateTool(
       for (const k of lessonKeys) {
         const raw = await redis.get(k);
         if (!raw) continue;
-        {
-          type PredLesson = { topic: string; what_worked?: string; what_failed?: string; outcome: string; severity?: string; ts: string; verified_at?: string; recall_count?: number };
-          const l = safeJsonParse<PredLesson | null>(raw, null);
-          if (!l) continue;
+        try {
+          const l = JSON.parse(raw) as { topic: string; what_worked?: string; what_failed?: string; outcome: string; severity?: string; ts: string; verified_at?: string; recall_count?: number };
           const haystack = [l.topic, l.what_failed ?? '', l.what_worked ?? ''].join(' ').toLowerCase();
           const score = ctxTokens.reduce((s, t) => s + (haystack.includes(t) ? 1 : 0), 0);
           if (score >= 1 && l.outcome !== 'failure') {
             const conf = calculateConfidence(l);
             textPredictions.push({ ...l, confidence: conf });
           }
-        }
+        } catch { /* skip */ }
       }
       textPredictions.sort((a, b) => b.confidence - a.confidence);
 

package/src/handlers/team.ts

@@ -5,7 +5,6 @@ import type { Redis } from 'ioredis';
 import { calculateConfidence, confidenceBadge, CONFIDENCE_STALE_VALUE, CONFIDENCE_WARN_VALUE,
          CONFIDENCE_WARN_DAYS, CONFIDENCE_STALE_DAYS, simpleHash } from '../confidence.js';
 import type { Instance } from './brain.js';
-import { safeJsonParse } from '../utils.js';
 
 type GetConnection = (instanceId: string) => Promise<Redis>;
 type ApiFetch = <T>(path: string, options?: RequestInit) => Promise<T>;
@@ -54,11 +53,10 @@ export async function handleTeamTool(
 
       type Lesson = { topic: string; what_worked: string; outcome: string; file_paths?: string[] };
       const relevant: string[] = [];
-      const sfRaws = lessonKeys.length > 0 ? await redis.mget(...lessonKeys) : [];
-      for (const raw of sfRaws) {
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
         if (!raw) continue;
-        const lesson = safeJsonParse<Lesson | null>(raw, null);
-        if (!lesson) continue;
+        const lesson = JSON.parse(raw) as Lesson;
         // Match by file_paths stored in lesson OR by topic keywords matching file name
         const topicWords = lesson.topic.toLowerCase().split(/[:\-_]/);
         const fileMatches = changed_files.some(f => {
@@ -148,12 +146,10 @@ export async function handleTeamTool(
         author?: string; tags?: string[];
       };
       let lessons: TeamLesson[] = [];
-      if (lessonKeys.length > 0) {
-        const raws = await redis.mget(...lessonKeys);
-        for (const raw of raws) {
-          const l = safeJsonParse<TeamLesson | null>(raw ?? null, null);
-          if (l) lessons.push(l);
-        }
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { lessons.push(JSON.parse(raw) as TeamLesson); } catch { /* skip */ }
       }
 
       // Filter
@@ -282,12 +278,10 @@ export async function handleTeamTool(
 
       type RawLesson = { topic: string; outcome: string; what_worked: string; severity?: string; ts: string; auto_learned?: boolean };
       const allLessons: RawLesson[] = [];
-      if (allLessonKeys.length > 0) {
-        const raws = await redis.mget(...allLessonKeys);
-        for (const raw of raws) {
-          const l = safeJsonParse<RawLesson | null>(raw ?? null, null);
-          if (l) allLessons.push(l);
-        }
+      for (const k of allLessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { allLessons.push(JSON.parse(raw) as RawLesson); } catch { /* skip */ }
       }
 
       // Group lessons by top-level category
@@ -373,17 +367,18 @@ export async function handleTeamTool(
         verified_at?: string; severity?: string; audit_trail?: unknown[];
       };
       const lessons: DrLesson[] = [];
-      if (lessonKeys.length > 0) {
-        const raws = await redis.mget(...lessonKeys);
-        for (const raw of raws) {
-          const l = safeJsonParse<DrLesson | null>(raw ?? null, null);
-          if (l) lessons.push(l);
-        }
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { lessons.push(JSON.parse(raw) as DrLesson); } catch { /* skip */ }
       }
 
       // Last session
       const lastSessionRaw = await redis.get('cachly:session:last');
-      const lastSession = safeJsonParse<{ ts: string; summary: string } | null>(lastSessionRaw, null);
+      let lastSession: { ts: string; summary: string } | null = null;
+      if (lastSessionRaw) {
+        try { lastSession = JSON.parse(lastSessionRaw); } catch { /* ignore */ }
+      }
 
       // Open failures
       const openFailures = lessons.filter(l => l.outcome === 'failure' || l.outcome === 'partial');
@@ -514,24 +509,13 @@ export async function handleTeamTool(
         issues.push(`💡 ${unusedLessons.length} lessons never recalled — verify topics match your workflow`);
       }
 
-      const divider = '─'.repeat(48);
-      const lines = [
-        `🩺 **Brain Doctor**`,
-        `\`${divider}\``,
-        '',
-        '**📊 Health Checks**',
-        ...checks.map(c => '  ' + c),
-        '',
-      ];
+      const lines = ['🩺 **Brain Doctor Report**', '', ...checks.map(c => '  ' + c), ''];
       if (issues.length > 0) {
-        lines.push(`**🔧 Action Items** (${issues.length} issue${issues.length > 1 ? 's' : ''})`);
-        issues.forEach((item, idx) => lines.push(`  ${idx + 1}. ${item}`));
+        lines.push('**Issues to fix:**');
+        for (const i of issues) lines.push('  ' + i);
         lines.push('');
-        lines.push(`_Fix the action items above, then re-run \`brain_doctor\` to verify._`);
       } else {
-        lines.push('**✅ All checks passed** — Brain is healthy!');
-        lines.push('');
-        lines.push('_Keep the brain sharp: `session_start` → work → `learn_from_attempts` → `session_end`_');
+        lines.push('  🎉 Brain looks healthy! Keep calling session_start/session_end.');
       }
       return lines.join('\n');
     }
@@ -552,11 +536,7 @@ export async function handleTeamTool(
         .filter((l): l is NonNullable<typeof l> => l !== null && new Date(l.ts).getTime() <= cutoff)
         .sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
 
-      if (before.length === 0) {
-        const first = safeJsonParse(all[0] ?? null, null as null | { ts?: string });
-        const earliest = first?.ts ? new Date(first.ts).toLocaleDateString('de-DE') : 'unknown';
-        return `📭 No entries for \`${topic}\` found before **${date}**. Earliest entry: ${earliest}.`;
-      }
+      if (before.length === 0) return `📭 No entries for \`${topic}\` found before **${date}**. Earliest entry: ${new Date(JSON.parse(all[0]).ts).toLocaleDateString('de-DE')}.`;
 
       const lines = [
         `🏺 **Brain Archaeology: \`${topic}\` before ${date}**`,
@@ -583,7 +563,7 @@ export async function handleTeamTool(
       const raw = await redis.get(depKey);
       if (!raw) return `📭 No lessons found that depend on \`${dependency}\`.\n\nAdd dependencies via: \`learn_from_attempts(..., depends_on=["${dependency}"])\``;
 
-      const topics: string[] = safeJsonParse<string[]>(raw, []);
+      const topics: string[] = JSON.parse(raw);
       const lines = [
         `🔗 **Causal Chain: \`${dependency}\`** — ${topics.length} dependent lesson${topics.length === 1 ? '' : 's'}`,
         '',
@@ -592,8 +572,7 @@ export async function handleTeamTool(
       for (const t of topics) {
         const lessonRaw = await redis.get(`cachly:lesson:best:${t}`);
         if (!lessonRaw) { lines.push(`  • \`${t}\` _(lesson deleted)_`); continue; }
-        const lesson = safeJsonParse(lessonRaw, null as null | { outcome?: string; severity?: string; needs_review?: boolean });
-        if (!lesson) { lines.push(`  • \`${t}\` _(lesson corrupted)_`); continue; }
+        const lesson = JSON.parse(lessonRaw) as { outcome?: string; severity?: string; needs_review?: boolean };
         const emoji = lesson.outcome === 'success' ? '✅' : lesson.outcome === 'partial' ? '⚠️' : '❌';
         const reviewBadge = lesson.needs_review ? ' 🔍 **needs_review**' : '';
         lines.push(`  ${emoji} \`${t}\` (${lesson.severity ?? 'major'})${reviewBadge}`);
@@ -635,8 +614,8 @@ export async function handleTeamTool(
       // Preserve recall_count on update
       const existing = await redis.get(key);
       if (existing) {
-        const prev = safeJsonParse(existing, null as null | { recall_count?: number });
-        record.recall_count = prev?.recall_count ?? 0;
+        const prev = JSON.parse(existing) as { recall_count?: number };
+        record.recall_count = prev.recall_count ?? 0;
       }
       await redis.set(key, JSON.stringify(record));
       return `🌐 **Global lesson stored**: \`${topic}\`\n\n${lesson}\n\nRecallable from any project via \`global_recall(topic="${topic}")\`.`;
@@ -656,12 +635,10 @@ export async function handleTeamTool(
 
       type GlobalLesson = { topic: string; lesson: string; severity?: string; ts: string; recall_count?: number };
       let lessons: GlobalLesson[] = [];
-      if (keys.length > 0) {
-        const raws = await redis.mget(...keys);
-        for (const raw of raws) {
-          const l = safeJsonParse<GlobalLesson | null>(raw ?? null, null);
-          if (l) lessons.push(l);
-        }
+      for (const k of keys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { lessons.push(JSON.parse(raw) as GlobalLesson); } catch { /* skip */ }
       }
 
       if (topic) {
@@ -678,8 +655,7 @@ export async function handleTeamTool(
         const k = `cachly:global:lesson:${l.topic}`;
         const raw = await redis.get(k);
         if (raw) {
-          const rec = safeJsonParse(raw, null as null | { recall_count?: number });
-          if (!rec) continue;
+          const rec = JSON.parse(raw) as { recall_count?: number };
           rec.recall_count = (rec.recall_count ?? 0) + 1;
           await redis.set(k, JSON.stringify(rec));
         }

package/src/index.ts

@@ -635,7 +635,23 @@ const server = new Server(
   { capabilities: { tools: {} } }
 );
 
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  // When no JWT is set, prepend a one-time sign-up nudge to session_start's description.
+  // The AI assistant surfaces this to the user naturally when it reads available tools.
+  if (!JWT) {
+    const tools = TOOLS.map(t => {
+      if (t.name !== 'session_start') return t;
+      return {
+        ...t,
+        description:
+          `⚡ FREE AI BRAIN — sign up once at https://cachly.dev/sign-up (no credit card) ` +
+          `then run: npx @cachly-dev/mcp-server@latest setup\n\n` + t.description,
+      };
+    });
+    return { tools };
+  }
+  return { tools: TOOLS };
+});
 
 // ── Auto-session management ───────────────────────────────────────────────────
 // Transparently starts a Brain session on the first tool call of a process
@@ -1274,6 +1290,33 @@ if (process.argv[2] === 'setup') {
         console.log('│    • A session summary for next time                │');
       }
       console.log('└──────────────────────────────────────────────────────┘');
+
+      // ── Step 6b: brain_predict preview (only if we have real lessons) ───────
+      if (lessons >= 5) {
+        process.stdout.write('\n⏳ Running predictive risk scan...');
+        try {
+          const predictResult = await handleTool('brain_predict', {
+            instance_id: instance.id,
+            context: 'starting a new development session',
+          });
+          const predictLines = predictResult
+            .split('\n')
+            .filter((l: string) => l.trim())
+            .slice(0, 6);
+          if (predictLines.length > 0) {
+            console.log(' ✓\n');
+            console.log('┌──────────────────────────────────────────────────────┐');
+            console.log('│  🔮  Brain Risk Preview (brain_predict)              │');
+            console.log('├──────────────────────────────────────────────────────┤');
+            for (const pl of predictLines) {
+              console.log(`│  ${pl.slice(0, 51).padEnd(51)} │`);
+            }
+            console.log('└──────────────────────────────────────────────────────┘');
+          } else {
+            console.log(' (no risks found — clean slate!)');
+          }
+        } catch { console.log(' (skipped)'); }
+      }
     } else {
       console.log(' (skipped)');
     }

package/src/tools.ts

@@ -3,6 +3,18 @@
 // ── Tools ─────────────────────────────────────────────────────────────────────
 
 const TOOLS = [
+  // ── Auth / Onboarding ────────────────────────────────────────────────────
+  {
+    name: 'sign_in',
+    description:
+      'Sign in to cachly AI Brain. Call this FIRST if no CACHLY_JWT is configured. ' +
+      'Starts an OAuth 2.0 Device Flow: you visit a short URL in your browser, approve in one click, ' +
+      'and the brain is ready instantly — no copy-paste, no dashboard required. ' +
+      'After sign-in, a free Brain instance is auto-provisioned if you don\'t have one yet. ' +
+      'Once authenticated, all 63 brain tools become available. ' +
+      'IMPORTANT: AI assistants should call this tool proactively at session start when CACHLY_JWT is not set.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
   // ── Instance Management ──────────────────────────────────────────────────
   {
     name: 'list_instances',
@@ -437,11 +449,10 @@ const TOOLS = [
   {
     name: 'get_api_status',
     description:
-      'Full diagnostic for your cachly Brain — call this FIRST whenever anything is not working. ' +
-      'Returns: API reachability, JWT validity + expiry, your user ID, ' +
-      'all Brain instances with live status (🟢 running / 🟡 provisioning / 🔴 stopped), ' +
-      'Redis ping on the active connection, and actionable fix steps for every issue found. ' +
-      'Workflow: run get_api_status → read the issue it flags → fix it → retry your tool.',
+      'Check the cachly API health and your authentication status. ' +
+      'Returns whether the JWT is valid, your user ID (sub claim), ' +
+      'token expiry, and the auth provider (keycloak). ' +
+      'Use this to debug connection issues or verify your CACHLY_JWT is correct.',
     inputSchema: { type: 'object', properties: {}, required: [] },
   },
   // ── Thinking/Context Cache (for AI assistants) ────────────────────────────

package/.github/workflows/publish.yml

@@ -1,45 +0,0 @@
-name: Publish to npm
-
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: npm install --ignore-scripts
-
-      - name: Test
-        run: npm test
-
-      - name: Build
-        run: npm run build
-
-      - name: Check if version is already published
-        id: version_check
-        run: |
-          PKG_VERSION=$(node -p "require('./package.json').version")
-          echo "version=$PKG_VERSION" >> $GITHUB_OUTPUT
-          if npm view "@cachly-dev/mcp-server@$PKG_VERSION" version &>/dev/null; then
-            echo "skip=true" >> $GITHUB_OUTPUT
-            echo "Version $PKG_VERSION already published — skipping."
-          else
-            echo "skip=false" >> $GITHUB_OUTPUT
-            echo "Version $PKG_VERSION is new — will publish."
-          fi
-
-      - name: Publish
-        if: steps.version_check.outputs.skip == 'false'
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LAUNCH_TEXTS.md

@@ -1,182 +0,0 @@
-# Launch Texts — cachly AI Brain
-
----
-
-## Product Hunt
-
-### Tagline (60 chars max)
-Persistent memory + causal AI for Claude, Cursor & Copilot
-
-### Description (260 chars)
-Your AI forgets everything between sessions. cachly fixes that permanently. One command sets it up: detects your editors, writes all configs, bootstraps lessons from your git history. Free forever. No credentials required.
-
-### Full Description
-
-**The problem:** Every morning you re-explain your architecture to your AI. Every bug gets re-researched. Every fix gets re-discovered. The average developer wastes 45 minutes/day on this.
-
-**The fix:** `npx @cachly-dev/mcp-server@latest setup`
-
-One command. It signs you in (one browser click), detects every editor you have (Claude Code, Cursor, Windsurf, VS Code, Copilot, Cline, Zed), writes the correct config for each, bootstraps your Brain from your git history, and installs a git hook that learns from every future commit automatically.
-
-**What your AI gets:**
-- A briefing at every session start: last session, open failures, relevant past fixes
-- Causal root cause analysis: `causal_trace("auth breaks after restart")` → Root cause → Chain → Exact fix from 3 months ago with the command that worked
-- Failure prediction before it happens: `brain_predict` reads your history before every deploy
-- A running "time saved" counter — so you can see the ROI
-
-**What makes it different from mem0, MemGPT, etc.:**
-The `causal_trace` tool. No other memory system builds a Causal Knowledge Graph. Most systems store facts. cachly stores WHY things broke and HOW they were fixed — with the full chain of cause and effect. 30 minutes of git blame in one call.
-
-**Free forever:** 25 MB, German servers, GDPR-compliant, no credit card.
-
-### First Comment (post immediately after launch)
-Hey PH! 👋
-
-I built cachly after watching my AI re-research the same deployment bug for the third time in a month. It had no memory. I did.
-
-The thing I'm most proud of: `causal_trace`. You describe a problem in plain English, and it walks your Brain's Causal Knowledge Graph to find: the root cause, the intermediate failure chain, and the exact fix that worked last time — including the date and the command. Nothing else does this.
-
-5000+ developers are already using the npm package. Would love your feedback on what's missing.
-
-**Commands to try after setup:**
-- `causal_trace(problem="[your last bug]")` — see if it already knows the answer
-- `brain_predict(context="about to deploy")` — what will go wrong?
-- `brain_doctor` — Brain health check
-
----
-
-## Hacker News — Show HN
-
-**Title:**
-Show HN: cachly – causal memory for AI coding assistants (MCP server, free)
-
-**Text:**
-I built cachly after noticing that my AI re-researched the same bug three times in a month. The context window empties, the memory vanishes.
-
-cachly is an MCP server that gives Claude Code, Cursor, Copilot, and Windsurf persistent memory with one command:
-
-  npx @cachly-dev/mcp-server@latest setup
-
-It detects your editors, writes all the MCP configs, bootstraps from your git history, and installs a git hook that learns from every future commit. No credentials needed in any config file — OAuth Device Flow handles auth inline on the first tool call.
-
-The part I think is technically interesting: `causal_trace`. Instead of just storing facts like most memory systems, cachly builds a Causal Knowledge Graph — typed edges: `fixes`, `requires`, `co-occurs`, `causes`, `contradicts`. When you describe a problem, it walks the graph to reconstruct the failure chain and surface the exact fix.
-
-  causal_trace(problem="auth breaks after restart")
-  → Root: k8s:namespace-terminating
-  → Via:  keycloak:jwks-race
-  → Fix:  PollUntilContextTimeout 3min ← worked March 12
-
-Sessions start and end automatically (no manual session_start/session_end). Everything runs in the background.
-
-Free tier: 25 MB, German servers, GDPR. Apache-2.0.
-
-GitHub: https://github.com/cachly-dev/cachly-mcp
-npm: https://www.npmjs.com/package/@cachly-dev/mcp-server
-
-Happy to answer questions about the architecture.
-
----
-
-## Reddit — r/ClaudeAI
-
-**Title:**
-I built persistent memory for Claude Code — no credentials, no config, one command
-
-**Text:**
-After the 10th time explaining my project architecture to Claude, I built cachly.
-
-**What it does:**
-Run `npx @cachly-dev/mcp-server@latest setup` once. It:
-1. Signs you in with one browser click (no credentials in config)
-2. Detects Claude Code, Cursor, Windsurf, VS Code, Cline — writes all configs automatically
-3. Bootstraps your Brain from your git history right away
-4. Installs a git hook so every future commit feeds the brain automatically
-
-From that point, your AI arrives pre-briefed every session. No `session_start` needed — it's automatic.
-
-**The feature I'm most excited about:**
-`causal_trace("auth breaks after restart")` — it doesn't just search for similar lessons, it walks a Causal Knowledge Graph to reconstruct the failure chain and return the exact fix you used before, with commands and file paths.
-
-**Free forever** — 25 MB, German servers, GDPR, no credit card.
-
-GitHub: https://github.com/cachly-dev/cachly-mcp
-
-Would love feedback from this community — what memory features would you most want?
-
----
-
-## Reddit — r/LocalLLaMA
-
-**Title:**
-MCP server that learns from your git history automatically — causal memory for AI coding
-
-**Text:**
-Built this for the problem of AI context loss between sessions. Technical highlights:
-
-- **Causal Knowledge Graph (CKG):** Typed edges (fixes, requires, co-occurs, causes, contradicts). `causal_trace` walks the graph instead of just doing text similarity.
-- **Continuous Learning Stream:** git post-commit hook + GitHub Actions step. Every commit → lessons extracted automatically. Zero `session_end` calls needed.
-- **brain_predict:** Before deploys, reads your CKG for patterns that match past failures and returns probability-weighted warnings.
-- **Memory Crystals:** Compresses 30-50 sessions into a dense snapshot injected at every session start.
-- **11-language BM25+ search:** EN, DE, FR, ES, IT, PT, ZH, JA, KO, AR, HE — cross-lingual retrieval (e.g. `smart_recall("deploy")` finds デプロイ, 部署, 배포).
-
-Works with any MCP host: Claude Code, Cursor, Windsurf, VS Code, Cline, Zed, Continue.dev.
-
-Free tier: 25 MB. Apache-2.0. German servers.
-
-GitHub: https://github.com/cachly-dev/cachly-mcp
-
----
-
-## Twitter/X Thread
-
-**Tweet 1:**
-Your AI forgets everything between sessions.
-I built the fix.
-
-`npx @cachly-dev/mcp-server@latest setup`
-
-One command → persistent AI memory across Claude, Cursor, Copilot, Windsurf.
-Free forever. 🧵
-
-**Tweet 2:**
-The part that took the longest to build: `causal_trace`
-
-You type: "auth breaks after restart"
-
-It returns:
-→ Root: k8s:namespace-terminating
-→ Via: keycloak:jwks-race
-→ Fix: PollUntilContextTimeout 3min ← you used this March 12, it worked
-
-30 minutes of git blame. One call.
-
-**Tweet 3:**
-How setup works:
-1. Run the command
-2. Browser opens → one click sign-in (no password)
-3. It detects every editor you have
-4. Writes MCP config for each automatically
-5. Bootstraps Brain from your git history
-6. Installs git hook for automatic future learning
-
-Restart editor. Done.
-
-**Tweet 4:**
-What your AI sees every morning:
-
-🧠 Session Briefing
-⏱️ Brain saved you ~4h 30m total
-✅ api:auth — Bearer in header, not cookie
-✅ docker:build — ARG changes bust cache
-⚠️ k8s:deploy — namespace terminating race condition
-
-🤝 Your team has 3 new lessons since yesterday
-
-**Tweet 5:**
-Free tier: 25 MB, German servers, GDPR-compliant, no credit card.
-Open source: Apache-2.0
-
-GitHub: github.com/cachly-dev/cachly-mcp
-npm: @cachly-dev/mcp-server
-
-If this saves you time, a ⭐ means a lot.