prism-mcp-server 9.12.0 → 9.13.0

package/README.md

@@ -12,7 +12,7 @@
 
 **Your AI agent forgets everything between sessions. Prism fixes that — then teaches it to think.**
 
-Prism v9.12 is a true **Cognitive Architecture** inspired by human brain mechanics. Beyond flat vector search, your agent now forms principles from experience, follows causal trains of thought, and possesses the self-awareness to know when it lacks information. **Your agents don't just remember; they learn.**
+Prism v9.13 is a true **Cognitive Architecture** inspired by human brain mechanics. Beyond flat vector search, your agent now forms principles from experience, follows causal trains of thought, and possesses the self-awareness to know when it lacks information. **Your agents don't just remember; they learn.** With v9.13, semantic search works **100% offline** — no API keys required.
 
 ```bash
 npx -y prism-mcp-server
@@ -124,16 +124,16 @@ Then open `http://localhost:3001` instead.
 | Time travel & versioning | ✅ | ✅ |
 | Mind Palace Dashboard | ✅ | ✅ |
 | GDPR export (JSON/Markdown/Vault) | ✅ | ✅ |
-| Semantic vector search | ❌ | ✅ `GOOGLE_API_KEY` |
-| Morning Briefings | ❌ | ✅ `GOOGLE_API_KEY` |
-| Auto-compaction | ❌ | ✅ `GOOGLE_API_KEY` |
+| Semantic vector search | ✅ (`embedding_provider=local`) | ✅ (gemini, openai, or voyage) |
+| Morning Briefings | ❌ | ✅ Text provider key |
+| Auto-compaction | ❌ | ✅ Text provider key |
 | Web Scholar research | ❌ | ✅ [`BRAVE_API_KEY`](#environment-variables) + [`FIRECRAWL_API_KEY`](#environment-variables) (or `TAVILY_API_KEY`) |
 | VLM image captioning | ❌ | ✅ Provider key |
-| Autonomous Pipelines (Dark Factory) | ❌ | ✅ `GOOGLE_API_KEY` (or LLM override) |
+| Autonomous Pipelines (Dark Factory) | ❌ | ✅ Text provider key |
 
-> 🔑 The core Mind Palace works **100% offline** with zero API keys. Cloud keys unlock intelligence features. See [Environment Variables](#environment-variables).
+> 🔑 The core Mind Palace works **100% offline** with zero API keys — including semantic vector search with `embedding_provider=local`. Cloud keys unlock text generation features (Briefings, compaction, pipelines). See [Environment Variables](#environment-variables).
 
-> 💰 **API Cost Note:** `GOOGLE_API_KEY` (Gemini) has a generous free tier that covers most individual use. `BRAVE_API_KEY` offers 2,000 free searches/month. `FIRECRAWL_API_KEY` has a free plan with 500 credits. For typical solo development, expect **$0/month** on the free tiers. Only high-volume teams or heavy autonomous pipeline usage will incur meaningful costs.
+> 💰 **API Cost Note:** With `embedding_provider=local`, semantic search is fully free and offline. Cloud providers (`GOOGLE_API_KEY` for Gemini, `VOYAGE_API_KEY`, `OPENAI_API_KEY`) have generous free tiers. `BRAVE_API_KEY` offers 2,000 free searches/month. `FIRECRAWL_API_KEY` has a free plan with 500 credits. For typical solo development, expect **$0/month** on the free tiers.
 
 ---
 
@@ -377,8 +377,7 @@ Then add to your MCP config:
       "command": "node",
       "args": ["/path/to/prism-mcp/dist/server.js"],
       "env": {
-        "BRAVE_API_KEY": "your-key",
-        "GOOGLE_API_KEY": "your-gemini-key"
+        "BRAVE_API_KEY": "your-key"
       }
     }
   }
@@ -432,7 +431,7 @@ Prism can be deployed natively to cloud platforms like [Render](https://render.c
 > `npx` resolves the correct binary automatically, always fetches the latest version, and works identically on macOS, Linux, and Windows. Already installed globally? Run `npm uninstall -g prism-mcp-server` first.
 
 > **❓ Seeing warnings about missing API keys on startup?**
-> That's expected and not an error. `BRAVE_API_KEY` / `GOOGLE_API_KEY` warnings are informational only — core session memory works with zero keys. See [Environment Variables](#environment-variables) for what each key unlocks.
+> That's expected and not an error. API key warnings are informational only — core session memory and semantic search (with `embedding_provider=local`) work with zero keys. See [Environment Variables](#environment-variables) for what each key unlocks.
 
 > 💡 **Do agents auto-load Prism?** Agents using Cursor, Windsurf, or other MCP clients will see the `session_load_context` tool automatically, but may not call it unprompted. Add this to your project's `.cursorrules` (or equivalent system prompt) to guarantee auto-load:
 > ```
@@ -567,12 +566,12 @@ When you trigger a Dark Factory pipeline, Prism doesn't just run your task — i
 Most AI agents have an infinite memory budget. They dump massive, repetitive logs into vector databases until they bankrupt your API budget and choke their own context windows. Prism v9.0 fixes this by introducing **Token-Economic Reinforcement Learning** and **Affect-Tagged Memory**.
 
 ### 💰 Memory-as-an-Economy (The Surprisal Gate)
-Prism assigns every project a strict **Cognitive Budget** (e.g., 2,000 tokens) that persists across sessions. Every time the agent saves a memory, it costs tokens. 
+Prism assigns every project a strict **Cognitive Budget** (e.g., 2,000 tokens) that persists across sessions. Every time the agent saves a memory, it costs tokens.
 
 But not all memories are priced equally. Prism intercepts the save and runs a **Vector-Based Surprisal** calculation against recent memories:
 *   **High Surprisal (Novel thought):** Costs 0.5× tokens. The agent is rewarded for new insights.
 *   **Low Surprisal (Boilerplate):** Costs 2.0× tokens. The agent is penalized for repeating itself.
-*   **Universal Basic Income (UBI):** The budget recovers passively over time (+100 tokens/hour). 
+*   **Universal Basic Income (UBI):** The budget recovers passively over time (+100 tokens/hour).
 
 If an agent is too verbose, it goes into **Cognitive Debt**. You don't need to prompt the agent to "be concise." The physics of the system force the LLM to learn data compression to avoid bankruptcy.
 
@@ -625,7 +624,7 @@ Standard RAG (Retrieval-Augmented Generation) is now a commodity. Everyone has v
                     │
       ┌─────────────┼─────────────┐
       ▼             ▼             ▼
-  [Memory: API     [Memory:      [Memory:       
+  [Memory: API     [Memory:      [Memory:
    timeout error]   DB pool       rate limiter
                     exhaustion]   misconfigured]
       │                │
@@ -680,9 +679,9 @@ rm -rf ~/.prism-mcp
 Prism will recreate the directory with empty databases on next startup.
 
 **What leaves your machine?**
-- **Local mode (default):** Nothing. Zero network calls. All data is on-disk SQLite.
-- **With `GOOGLE_API_KEY`:** Text snippets are sent to Gemini for embedding generation, summaries, and Morning Briefings. No session data is stored on Google's servers beyond the API call.
-- **With `VOYAGE_API_KEY` / `OPENAI_API_KEY`:** Text snippets are sent to providers if selected as your embedding endpoints.
+- **Local mode (default):** Nothing. Zero network calls. All data is on-disk SQLite. With `embedding_provider=local`, even semantic search stays fully offline.
+- **With `GOOGLE_API_KEY`:** Text snippets are sent to Gemini for text generation (summaries, Morning Briefings) and optionally embeddings. No session data is stored on Google's servers beyond the API call.
+- **With `VOYAGE_API_KEY` / `OPENAI_API_KEY`:** Text snippets are sent to providers if selected as your embedding or text endpoints.
 - **With `BRAVE_API_KEY` / `FIRECRAWL_API_KEY`:** Web Scholar queries are sent to Brave/Firecrawl for search and scraping.
 - **With Supabase:** Session data syncs to your own Supabase instance (you control the Postgres database).
 
@@ -1072,13 +1071,17 @@ Requires `PRISM_DARK_FACTORY_ENABLED=true`.
 
 ## Environment Variables
 
-> **🚦 TL;DR — Just want the best experience fast?** Set these three keys and you're done:
+> **🚦 TL;DR — Just want the best experience fast?** Two options:
 > ```
-> GOOGLE_API_KEY=...      # Unlocks: semantic search, Morning Briefings, auto-compaction
+> # Option A: Fully offline (no API keys needed)
+> # Set embedding_provider=local in the Mind Palace dashboard — semantic search works out of the box.
+>
+> # Option B: Cloud-powered (best quality)
+> GOOGLE_API_KEY=...      # Unlocks: Gemini embeddings, Morning Briefings, auto-compaction
 > BRAVE_API_KEY=...       # Unlocks: Web Scholar research + Brave Answers
 > FIRECRAWL_API_KEY=...   # Unlocks: Web Scholar deep scraping (or use TAVILY_API_KEY instead)
 > ```
-> **Zero keys = zero problem.** Core session memory, keyword search, time travel, and the full dashboard work 100% offline. Cloud keys are optional power-ups.
+> **Zero keys = zero problem.** Core session memory, keyword search, semantic search (local embeddings), time travel, and the full dashboard work 100% offline. Cloud keys are optional power-ups.
 
 <details>
 <summary><strong>Full variable reference</strong></summary>
@@ -1091,7 +1094,7 @@ Requires `PRISM_DARK_FACTORY_ENABLED=true`.
 | `PRISM_STORAGE` | No | `"local"` (default) or `"supabase"` — restart required |
 | `PRISM_ENABLE_HIVEMIND` | No | `"true"` to enable multi-agent tools — restart required |
 | `PRISM_INSTANCE` | No | Instance name for multi-server PID isolation |
-| `GOOGLE_API_KEY` | No | Gemini — enables semantic search, Briefings, compaction |
+| `GOOGLE_API_KEY` | No | Gemini — enables Briefings, compaction, and cloud embeddings (not needed with `embedding_provider=local`) |
 | `VOYAGE_API_KEY` | No | Voyage AI — optional premium embedding provider |
 | `OPENAI_API_KEY` | No | OpenAI — optional proxy model and embedding provider |
 | `BRAVE_ANSWERS_API_KEY` | No | Separate Brave Answers key |
@@ -1277,7 +1280,7 @@ Prism MCP is open-source and free for individual developers. For teams and enter
 * **What's included:** Active Directory / custom JWKS auth integration, Air-gapped on-premise deployment, custom OTel Grafana dashboards for cognitive observability, and custom skills/tools development.
 * **Model:** Custom enterprise quote.
 
-**Interested in accelerating your team's autonomous workflows?**  
+**Interested in accelerating your team's autonomous workflows?**
 [📧 Contact us for a consultation](mailto:inquiries@prism-mcp.com) — let's build your organization's cognitive memory engine.
 
 ---
@@ -1332,11 +1335,11 @@ A: Run `npm run build && npm test`, then open the Mind Palace dashboard (`localh
 
 ### 💡 Known Limitations & Quirks
 
-- **LLM-dependent features require an API key.** Semantic search, Morning Briefings, auto-compaction, and VLM captioning need a `GOOGLE_API_KEY` (your Gemini API key) or equivalent provider key. Without one, Prism falls back to keyword-only search (FTS5).
+- **Text generation features require an API key.** Morning Briefings, auto-compaction, and VLM captioning need a cloud provider key (`GOOGLE_API_KEY`, `OPENAI_API_KEY`, or `ANTHROPIC_API_KEY`). Semantic search works offline with `embedding_provider=local` (no key needed). Without any embedding provider, Prism falls back to keyword-only search (FTS5).
 - **Auto-load is model- and client-dependent.** Session auto-loading relies on both the LLM following system prompt instructions *and* the MCP client completing tool registration before the model's first turn. Prism provides platform-specific [Setup Guides](#-setup-guides) and a server-side fallback (v5.2.1) that auto-pushes context after 10 seconds.
 - **MCP client race conditions.** Some MCP clients may not finish tool enumeration before the model generates its first response, causing transient `unknown_tool` errors. This is a client-side timing issue — Prism's server completes the MCP handshake in ~60ms. Workaround: the server-side auto-push fallback and the startup skill's retry logic.
 - **No real-time sync without Supabase.** Local SQLite mode is single-machine only. Multi-device or team sync requires a Supabase backend.
-- **Embedding quality varies by provider.** Gemini `text-embedding-004` and OpenAI `text-embedding-3-small` produce high-quality 768-dim vectors. Prism passes `dimensions: 768` via the Matryoshka API for OpenAI models (native output is 1536-dim; this truncation is lossless and outperforms ada-002 at full 1536 dims). Ollama embeddings (e.g., `nomic-embed-text`) are usable but may reduce retrieval accuracy.
+- **Embedding quality varies by provider.** Gemini `text-embedding-004` and OpenAI `text-embedding-3-small` produce high-quality 768-dim vectors. Prism passes `dimensions: 768` via the Matryoshka API for OpenAI models (native output is 1536-dim; this truncation is lossless and outperforms ada-002 at full 1536 dims). Local embeddings (`nomic-embed-text-v1.5` via `@huggingface/transformers`) provide good quality with zero API cost. Ollama embeddings are usable but may reduce retrieval accuracy.
 - **Dashboard is HTTP-only.** The Mind Palace dashboard at `localhost:3000` does not support HTTPS. For remote access, use a reverse proxy (nginx/Caddy) or SSH tunnel. Basic auth is available via `PRISM_DASHBOARD_USER` / `PRISM_DASHBOARD_PASS`. JWKS JWT auth is available via `PRISM_JWKS_URI` for agent-native authentication (works with Auth0, AgentLair ([llms.txt](https://agentlair.com/llms.txt)), Keycloak, Cognito, or any standard JWKS endpoint).
 - **Long-lived clients can accumulate zombie processes.** MCP clients that run for extended periods (e.g., Claude CLI) may leave orphaned Prism server processes. The lifecycle manager detects true orphans (PPID=1) but allows coexistence for active parent processes. Use `PRISM_INSTANCE` to isolate instances across clients.
 - **Migration is one-way.** Universal Import ingests sessions *into* Prism but does not export back to Claude/Gemini/OpenAI formats. Use `session_export_memory` for portable JSON/Markdown export, or the `vault` format for Obsidian/Logseq-compatible `.zip` archives.

package/dist/dashboard/server.js

@@ -971,10 +971,10 @@ return false;}
                     }
                     catch {
                         res.writeHead(503, { "Content-Type": "application/json" });
-                        return res.end(JSON.stringify({ error: "LLM Provider not configured for semantic search. Provide a GOOGLE_API_KEY or equivalent." }));
+                        return res.end(JSON.stringify({ error: "LLM Provider not configured for semantic search. Configure an embedding provider in the Mind Palace dashboard." }));
                     }
                     const queryEmbedding = await llm.generateEmbedding(queryText);
-                    // We query limit + offset, then slice manually since the storage 
+                    // We query limit + offset, then slice manually since the storage
                     // layer interface limit parameter doesn't natively expose offset.
                     const results = await s.searchMemory({
                         queryEmbedding: JSON.stringify(queryEmbedding),
@@ -1205,7 +1205,7 @@ self.addEventListener('message', (e) => {
     .bg {
       position: fixed;
       inset: 0;
-      background-image: 
+      background-image:
         radial-gradient(circle at 20% 30%, rgba(139, 92, 246, 0.08) 0%, transparent 50%),
         radial-gradient(circle at 80% 70%, rgba(59, 130, 246, 0.06) 0%, transparent 50%);
       z-index: 0;

package/dist/tools/definitions.js

@@ -228,7 +228,7 @@ export const BRAVE_ANSWERS_TOOL = {
 };
 // Analyzes academic research papers using Google's Gemini model.
 // Supports multiple analysis types: summary, critique, literature review, key findings.
-// Requires GOOGLE_API_KEY to be configured.
+// Requires a configured text provider (Gemini, OpenAI, or Anthropic).
 export const RESEARCH_PAPER_ANALYSIS_TOOL = {
     name: "gemini_research_paper_analysis",
     description: "Performs in-depth analysis of research papers using Google's Gemini-2.0-flash model. " +

package/dist/tools/graphHandlers.js

@@ -29,7 +29,7 @@ import { getSetting } from "../storage/configStorage.js";
 // containing: strategy, scores, latency breakdown (embedding/storage/total), and metadata.
 // See src/utils/tracing.ts for full type definitions and design decisions.
 import { createMemoryTrace, traceToContentBlock } from "../utils/tracing.js";
-import { GOOGLE_API_KEY, PRISM_USER_ID } from "../config.js";
+import { PRISM_USER_ID } from "../config.js";
 import { isKnowledgeSearchArgs, isKnowledgeForgetArgs, isSessionSearchMemoryArgs, isKnowledgeVoteArgs, 
 // v4.2: Sync Rules type guard
 isKnowledgeSyncRulesArgs, isSessionIntuitiveRecallArgs, isSessionSynthesizeEdgesArgs, isSessionCognitiveRouteArgs, } from "./sessionMemoryDefinitions.js";
@@ -290,17 +290,6 @@ export async function sessionSearchMemoryHandler(args) {
     // Phase 1: Start total latency timer BEFORE any work (embedding + storage)
     const totalStart = performance.now();
     // Step 1: Generate embedding for the search query
-    if (!GOOGLE_API_KEY) {
-        return {
-            content: [{
-                    type: "text",
-                    text: `❌ Semantic search requires GOOGLE_API_KEY for embedding generation.\n` +
-                        `Set this environment variable and restart the server.\n\n` +
-                        `💡 As a workaround, try knowledge_search (keyword-based) instead.`,
-                }],
-            isError: true,
-        };
-    }
     let queryEmbedding;
     // Phase 1: Start embedding latency timer — isolates Gemini API call time.
     // This is the most variable component: 50ms on a good day, 2000ms under load.
@@ -390,7 +379,7 @@ export async function sessionSearchMemoryHandler(args) {
                         `Tips:\n` +
                         `• Lower the similarity_threshold (e.g., 0.5) for broader results\n` +
                         `• Try knowledge_search for keyword-based matching\n` +
-                        `• Ensure sessions have been saved with embeddings (requires GOOGLE_API_KEY)`,
+                        `• Ensure sessions have been saved with embeddings (requires a configured embedding provider)`,
                 }];
             // Phase 1: Trace is still valuable on empty results — it proves the search
             // executed and reveals whether the bottleneck was embedding or storage.

package/dist/tools/ledgerHandlers.js

@@ -29,7 +29,7 @@ import { getLLMProvider } from "../utils/llm/factory.js";
 import { getCurrentGitState, getGitDrift } from "../utils/git.js";
 import { getSetting, getAllSettings } from "../storage/configStorage.js";
 import { mergeHandoff, dbToHandoffSchema, sanitizeForMerge } from "../utils/crdtMerge.js";
-import { GOOGLE_API_KEY, PRISM_USER_ID, PRISM_AUTO_CAPTURE, PRISM_CAPTURE_PORTS } from "../config.js";
+import { PRISM_USER_ID, PRISM_AUTO_CAPTURE, PRISM_CAPTURE_PORTS } from "../config.js";
 import { captureLocalEnvironment } from "../utils/autoCapture.js";
 import { fireCaptionAsync } from "../utils/imageCaptioner.js";
 import { isSessionSaveLedgerArgs, isSessionSaveHandoffArgs, isSessionLoadContextArgs, isMemoryHistoryArgs, isMemoryCheckoutArgs, // v2.2.0: health check type guard
@@ -134,7 +134,7 @@ export async function sessionSaveLedgerHandler(args) {
         role: effectiveRole, // v3.0: Hivemind role scoping (dashboard fallback)
     });
     // ─── Fire-and-forget embedding generation ───
-    if (GOOGLE_API_KEY && result) {
+    if (result) {
         const embeddingText = [summary, ...(decisions || [])].join("\n");
         const savedEntry = Array.isArray(result) ? result[0] : result;
         const entryId = savedEntry?.id;
@@ -230,7 +230,7 @@ export async function sessionSaveLedgerHandler(args) {
                     (todos?.length ? `TODOs: ${todos.length} items\n` : "") +
                     (files_changed?.length ? `Files changed: ${files_changed.length}\n` : "") +
                     (decisions?.length ? `Decisions: ${decisions.length}\n` : "") +
-                    (GOOGLE_API_KEY ? `📊 Embedding generation queued for semantic search.\n` : "") +
+                    `📊 Embedding generation queued for semantic search.\n` +
                     repoPathWarning +
                     `\nRaw response: ${JSON.stringify(result)}`,
             }],
@@ -450,15 +450,14 @@ export async function sessionSaveHandoffHandler(args, server) {
     // merges contradicting facts in the background (~2-3s).
     //
     // TRIGGER CONDITIONS (all must be true):
-    //   1. GOOGLE_API_KEY is configured (Gemini is available)
-    //   2. The handoff was an UPDATE (not a brand-new project)
-    //   3. key_context was provided (something to merge)
+    //   1. The handoff was an UPDATE (not a brand-new project)
+    //   2. key_context was provided (something to merge)
     //
     // OCC SAFETY:
     //   If the user saves another handoff while the merger runs,
     //   the merger's save will fail with a version conflict. This is
     //   intentional — active user input always wins over background merging.
-    if (GOOGLE_API_KEY && data.status === "updated" && key_context) {
+    if (data.status === "updated" && key_context) {
         // Use dynamic import to avoid loading Gemini SDK if not needed
         import("../utils/factMerger.js").then(async ({ consolidateFacts }) => {
             try {
@@ -805,7 +804,7 @@ export async function sessionLoadContextHandler(args) {
     // ─── SDM Intuitive Recall (v5.5) ───
     // Generate embedding of current context and fetch latent SDM patterns
     let sdmRecallBlock = "";
-    if (level !== "quick" && GOOGLE_API_KEY) {
+    if (level !== "quick") {
         try {
             const activeText = [d.last_summary, d.key_context, ...(d.keywords || [])].filter(Boolean).join(" ");
             if (activeText.length > 10) {
@@ -1233,7 +1232,7 @@ export async function sessionSaveExperienceHandler(args) {
         importance: event_type === "correction" ? 1 : 0,
     });
     // Fire-and-forget embedding generation
-    if (GOOGLE_API_KEY && result) {
+    if (result) {
         const embeddingText = summary;
         const savedEntry = Array.isArray(result) ? result[0] : result;
         const entryId = savedEntry?.id;

package/dist/utils/factMerger.js

@@ -29,7 +29,7 @@
  *   "Merge skipped due to active session."
  *
  * REQUIREMENTS:
- *   - GOOGLE_API_KEY must be set (skips gracefully if not)
+ *   - A text provider must be configured (skips gracefully if not)
  *   - Uses gemini-2.5-flash for speed (~2-3s per merge)
  * ═══════════════════════════════════════════════════════════════════
  */

package/dist/utils/llm/adapters/disabledText.js

@@ -0,0 +1,9 @@
+export class DisabledTextAdapter {
+    async generateText(_prompt, _systemInstruction) {
+        throw new Error("Text generation is not available. " +
+            "Configure an AI provider in the Mind Palace dashboard.");
+    }
+    async generateEmbedding(_text) {
+        throw new Error("[DisabledTextAdapter] Embedding is handled by a separate adapter — this method should not be called directly.");
+    }
+}

package/dist/utils/llm/adapters/local.js

@@ -0,0 +1,114 @@
+import { getSettingSync } from "../../../storage/configStorage.js";
+import { debugLog } from "../../logger.js";
+const EMBEDDING_DIMS = 768;
+const MAX_EMBEDDING_CHARS = 8000;
+const DEFAULT_MODEL = "nomic-ai/nomic-embed-text-v1.5";
+const DEFAULT_REVISION = "main";
+// MODEL_ID_PATTERN allows '.' in the name segment — the separate '..' check below
+// handles directory traversal (e.g., "owner/foo..bar" passes the regex but is invalid).
+const MODEL_ID_PATTERN = /^[a-zA-Z0-9_-]{1,64}\/[a-zA-Z0-9._-]{1,128}$/;
+// Allowed: "main", 40-char commit SHA, semver tag like "v1.5" or "v1.5.0"
+const REVISION_PATTERN = /^(main|[a-f0-9]{40}|v\d+(\.\d+){0,2})$/;
+export class LocalEmbeddingAdapter {
+    /** @internal Resolves once pipeline initialization completes. Callers and tests await this for readiness. */
+    loadPromise;
+    pipe = null;
+    loadError = null;
+    constructor() {
+        this.loadPromise = this.initPipeline();
+    }
+    async generateText(_prompt, _systemInstruction) {
+        throw new Error("LocalEmbeddingAdapter does not support text generation. " +
+            "It is an embedding-only provider. Configure a text provider in the Mind Palace dashboard.");
+    }
+    async generateEmbedding(text) {
+        if (!text || !text.trim()) {
+            throw new Error("[LocalEmbeddingAdapter] generateEmbedding called with empty text");
+        }
+        let inputText = text;
+        if (inputText.length > MAX_EMBEDDING_CHARS) {
+            inputText = inputText.substring(0, MAX_EMBEDDING_CHARS);
+            const lastSpace = inputText.lastIndexOf(" ");
+            if (lastSpace > 0)
+                inputText = inputText.substring(0, lastSpace);
+        }
+        await this.loadPromise;
+        if (this.loadError)
+            throw this.loadError;
+        if (!this.pipe) {
+            throw new Error("[LocalEmbeddingAdapter] Pipeline not initialized and no load error recorded");
+        }
+        const result = await this.pipe(`search_document: ${inputText}`, { pooling: "mean", normalize: true });
+        const tensorData = result.data;
+        if (!tensorData || !(tensorData instanceof Float32Array)) {
+            throw new Error("[LocalEmbeddingAdapter] Unexpected pipeline output shape — expected { data: Float32Array }. " +
+                "This may indicate an incompatible @huggingface/transformers version.");
+        }
+        const vec = Array.from(tensorData);
+        if (vec.length !== EMBEDDING_DIMS) {
+            throw new Error(`[LocalEmbeddingAdapter] Embedding dimension mismatch: expected ${EMBEDDING_DIMS}, got ${vec.length}. ` +
+                `Check the local_embedding_model setting.`);
+        }
+        return vec;
+    }
+    async initPipeline() {
+        const model = process.env.LOCAL_EMBEDDING_MODEL ?? getSettingSync("local_embedding_model", DEFAULT_MODEL);
+        if (!MODEL_ID_PATTERN.test(model) || model.includes("..")) {
+            this.loadError = new Error(`[LocalEmbeddingAdapter] Invalid local_embedding_model: "${model}". ` +
+                `Must be a HuggingFace model ID in "owner/name" format.`);
+            return;
+        }
+        const hfEndpoint = process.env.HF_ENDPOINT;
+        if (hfEndpoint) {
+            try {
+                const parsed = new URL(hfEndpoint);
+                const isTrusted = parsed.hostname === "huggingface.co" ||
+                    parsed.hostname.endsWith(".huggingface.co");
+                if (!isTrusted) {
+                    console.warn(`[LocalEmbeddingAdapter] HF_ENDPOINT hostname "${parsed.hostname}" is not huggingface.co — ` +
+                        `model downloads are redirected. Only set if you control and trust this server.`);
+                }
+            }
+            catch {
+                console.warn(`[LocalEmbeddingAdapter] HF_ENDPOINT is not a valid URL: "${hfEndpoint}". Ignoring.`);
+            }
+        }
+        let transformers;
+        try {
+            transformers = await import("@huggingface/transformers");
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err));
+            this.loadError = e.code === "ERR_MODULE_NOT_FOUND"
+                ? new Error("[LocalEmbeddingAdapter] @huggingface/transformers is not installed. " +
+                    "Run: npm install @huggingface/transformers")
+                : e;
+            return;
+        }
+        const quantized = getSettingSync("local_embedding_quantized", "true") !== "false";
+        const dtype = quantized ? "q8" : "fp32";
+        const revision = getSettingSync("local_embedding_revision", DEFAULT_REVISION);
+        if (!REVISION_PATTERN.test(revision)) {
+            this.loadError = new Error(`[LocalEmbeddingAdapter] Invalid local_embedding_revision: "${revision}". ` +
+                `Allowed values: "main", a 40-char commit SHA, or a semver tag like "v1.5".`);
+            return;
+        }
+        try {
+            const pipelineInstance = await transformers.pipeline("feature-extraction", model, { dtype, revision });
+            this.pipe = pipelineInstance;
+            try {
+                await this.pipe("warmup text", { pooling: "mean", normalize: true });
+                debugLog(`[LocalEmbeddingAdapter] Pipeline ready and warmed up: ${model} (${dtype})`);
+            }
+            catch (warmupErr) {
+                const we = warmupErr instanceof Error ? warmupErr : new Error(String(warmupErr));
+                console.warn(`[LocalEmbeddingAdapter] Warmup failed (non-fatal): ${we.message}. ` +
+                    `First embedding call may be slightly slower.`);
+            }
+        }
+        catch (err) {
+            this.loadError = err instanceof Error ? err : new Error(String(err));
+            console.error(`[LocalEmbeddingAdapter] Failed to load pipeline: ${this.loadError.message}`);
+        }
+    }
+}

package/dist/utils/llm/factory.js

@@ -11,7 +11,7 @@
  *   Two independent settings control text and embedding routing:
  *
  *   text_provider      — "gemini" (default) | "openai" | "anthropic"
- *   embedding_provider — "auto" (default)   | "gemini" | "openai" | "voyage"
+ *   embedding_provider — "auto" (default)   | "gemini" | "openai" | "voyage" | "local"
  *
  *   When embedding_provider = "auto":
  *     * If text_provider is gemini or openai → use same provider for embeddings
@@ -44,6 +44,8 @@ import { GeminiAdapter } from "./adapters/gemini.js";
 import { OpenAIAdapter } from "./adapters/openai.js";
 import { AnthropicAdapter } from "./adapters/anthropic.js";
 import { VoyageAdapter } from "./adapters/voyage.js";
+import { LocalEmbeddingAdapter } from "./adapters/local.js";
+import { DisabledTextAdapter } from "./adapters/disabledText.js";
 import { TracingLLMProvider } from "./adapters/traced.js";
 // Module-level singleton — one composed provider per MCP server process.
 let providerInstance = null;
@@ -54,6 +56,7 @@ function buildTextAdapter(type) {
     switch (type) {
         case "anthropic": return new AnthropicAdapter();
         case "openai": return new OpenAIAdapter();
+        case "none": return new DisabledTextAdapter();
         case "gemini":
         default: return new GeminiAdapter();
     }
@@ -66,6 +69,7 @@ function buildEmbeddingAdapter(type) {
     switch (type) {
         case "openai": return new OpenAIAdapter();
         case "voyage": return new VoyageAdapter();
+        case "local": return new LocalEmbeddingAdapter();
         case "gemini":
         default: return new GeminiAdapter();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "9.12.0",
+  "version": "9.13.0",
   "mcpName": "io.github.dcostenco/prism-mcp",
   "description": "The Mind Palace for AI Agents — a true Cognitive Architecture with Hebbian learning (episodic→semantic consolidation), ACT-R spreading activation (multi-hop causal reasoning), uncertainty-aware rejection gates (agents that know when they don't know), adversarial evaluation (anti-sycophancy), fail-closed Dark Factory pipelines, persistent memory (SQLite/Supabase), multi-agent Hivemind, time travel & visual dashboard. Zero-config local mode.",
   "module": "index.ts",
@@ -80,7 +80,10 @@
     "dark-factory",
     "autonomous-pipeline",
     "fail-closed",
-    "anti-sycophancy"
+    "anti-sycophancy",
+    "local-embeddings",
+    "transformers-js",
+    "nomic-embed"
   ],
   "homepage": "https://github.com/dcostenco/prism-mcp",
   "repository": {
@@ -90,6 +93,7 @@
   "author": "Dmitri Costenco",
   "license": "MIT",
   "devDependencies": {
+    "@huggingface/transformers": "3.1.0",
     "@types/bun": "latest",
     "@types/jsdom": "^28.0.1",
     "@types/mozilla-readability": "^0.2.1",
@@ -99,7 +103,13 @@
     "vitest": "^4.1.1"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "@huggingface/transformers": "~3.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@huggingface/transformers": {
+      "optional": true
+    }
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.81.0",