🧠 Prism Coder

🌐 Read in your language: 🇬🇧 English · 🇪🇸 Español · 🇫🇷 Français · 🇵🇹 Português · 🇷🇴 Română · 🇺🇦 Українська · 🇷🇺 Русский · 🇩🇪 Deutsch · 🇯🇵 日本語 · 🇰🇷 한국어 · 🇨🇳 中文 · 🇸🇦 العربية

Persistent memory + tool-calling intelligence for AI agents. (formerly Prism MCP)

A Model Context Protocol server that gives Claude, Cursor, and other AI tools a Mind Palace — long-term memory that survives across sessions, with semantic search, cognitive routing, a visual dashboard, and the prism-coder:1b7 / prism-coder:8b / prism-coder:14b / prism-coder:32b LLM fleet for offline tool-calling.

Renamed in v14.0.0: the project is now Prism Coder to cover both the Mind Palace memory server and the prism-coder:1b7 / prism-coder:8b / prism-coder:14b / prism-coder:32b LLM fleet on HuggingFace + Ollama. The npm package stays prism-mcp-server so existing install URLs and mcp.json entries keep working — the prism-coder binary has been the canonical entry point since v12.

What Prism Coder does

💾 Your AI remembers across sessions

Every conversation feeds the Mind Palace. Next session, your AI agent loads the right context automatically — no re-explaining.

🔍 Semantic search over your history

Ask "what did I decide about the auth flow last month?" and get the answer with citations. Vector search + keyword + graph traversal.

🧬 Cognitive routing

Different memory types live in different stores: episodic (what happened), semantic (what's true), procedural (how to do X). The router picks where to store and where to retrieve.

🔄 Proactive session drift detection (new in v15)

Your AI agent can now detect when it has drifted from your original goals — mid-session, automatically — and self-correct before you notice the problem.

Three direct Prism calls:

1. session_save_ledger — snapshot current state
2. session_cognitive_route — compare current work against original goals, returns on_track / minor_drift / major_drift
3. session_compact_ledger — if drifted, compress and reload only what matters

When major drift is detected, the alert routes to the Synalux portal so it's visible across sessions and devices — not just in the current conversation.

Real example it caught: A training session promised BFCL ≥90% for three AI models. The agent spent 3 hours debugging audio bugs instead. The drift check surfaced: "Training goal unmet. Layer3 corpus missing from all training sets. 0 BFCL scores measured." The session immediately re-aligned.

No scripts. No cron. No hooks. Three tool calls, Prism handles the rest.

🛡 Local-first — security + speed

Free tier runs entirely on your machine — SQLite, local embedding model, no API keys, no cloud. Paid tier adds cloud sync via Synalux portal.

Why local models matter:

Install in one command — no config, no keys, no vendor agreements:

ollama pull dcostenco/prism-coder:14b   # 9 GB  · default router · Mac M2+ / iPad Pro
ollama pull dcostenco/prism-coder:4b    # 2.5 GB · verifier · iPhone 15/16 Pro
ollama pull dcostenco/prism-coder:1b7   # 2.2 GB · ultra-low RAM / Apple Watch
ollama pull dcostenco/prism-coder:32b   # 19 GB  · complex tasks · Mac M2 Ultra+
ollama pull dcostenco/prism-coder:8b    # 4.7 GB · balanced · iPhone/iPad 8GB

Prism MCP detects both the namespaced (dcostenco/prism-coder:14b) and bare (prism-coder:14b) Ollama tag forms automatically — nothing else to configure. If you want the bare tags as aliases for direct ollama run prism-coder:14b use, run:

prism register-models           # aliases */prism-coder:* → prism-coder:* via `ollama cp`
prism register-models --dry-run # preview what would be aliased

Cascade architecture

Three-tier local cascade with cloud fallback:

Query arrives
  │
  ▼
prism-coder:14b ── routes (100% eval_300) ──▶  serve  (~3s, 9GB, FREE)
  │                                              │
  │                                    knowledge_search (RAG context)
  │                                              │
  ▼                                              ▼
prism-coder:4b ── verifies claims ──────────▶  grounded response
  │                 (2.5GB, <1s)
  │
  ▼  (complex tasks only, explicit ceiling="32b")
prism-coder:32b ── deep reasoning ──────────▶  serve  (~8s, 19GB, FREE)
  │
  ▼  (cloud fallback when local insufficient)
Claude Sonnet 4 → Claude Opus 4.7 ─────────▶  serve  (cloud, ~$0.01/req)

Mobile / offline cascade (Prism AAC iOS):

prism-coder:14b (iPad Pro 16GB) → prism-coder:4b (iPhone 8GB)
  → prism-coder:1.7b (any device, always fits)

Knowledge ingestion — teach Prism your codebase

Your code knowledge lives in the knowledge graph, not in model weights. Routing stays at 100%.

bash scripts/knowledge-ingest/setup.sh   # one-time setup
# Then every git commit auto-indexes changed files into the knowledge graph

Three entry points:

• MCP tool: knowledge_ingest — AI says "learn this code"
• GitHub webhook: POST /api/github/webhook — auto on push
• REST API: POST /api/v1/prism/ingest — open interface

See KNOWLEDGE_INGESTION.md for full setup guide.

Routing accuracy

Head-to-head: prism-coder:14b vs Claude Opus (25-case benchmark, production system prompt, May 2026):

prism-coder:14b beats Opus on tool routing — 7x faster, free, runs offline.

eval_300 (300 cases, 17 tools + NO_TOOL, 9 categories, 3-seed validated):

Categories: abstention, adversarial traps, cascade, disambiguation, edge cases, multi-intent, natural phrasing, parameter extraction, verifier prompts.

What this means: a child in a hospital without WiFi, a nonverbal adult on an airplane, or a family on a budget gets Claude-grade routing accuracy with zero cloud dependency — the AAC path routes correctly 100% of the time across all tiers.

What it does NOT mean: these scores measure routing precision on a 17-tool taxonomy, not general intelligence. Claude outperforms on everything outside this task. The value is offline reliability at zero cost, not replacing Claude. Code and clinical knowledge come from RAG via knowledge_search.

🔍 L3 Grounding Verifier

When prism_infer receives an evidence payload, the grounding verifier automatically checks the model's response against the provided evidence before returning to the caller. Unverified or hallucinated claims are flagged. This is the third layer (L3) of the cascade — after tool routing (L1) and confidence gating (L2).

🧠 HRR Semantic Drift Detection (v17.0)

Detects when long AI agent sessions drift from their original goal — using Holographic Reduced Representations for temporal trajectory encoding and anomaly detection.

Three domains, one detector:

Research-backed: trajectory association (Frady et al. 2018), HDAD anomaly detection (Wang et al. 2021), unit-modulus projection (Ganesan et al. NeurIPS 2021). 306 tests across 8 files, zero failures. Use session_detect_drift with optional domain parameter.

⚡ Zero-search retrieval (new in v15.8)

Holographic Reduced Representations (HRR) via Rust WASM for instant memory retrieval without a database query.

Three adaptive strategies:

• GloVe embeddings (offline, 50K words) — 87% Top-1 accuracy, stable at 200+ concepts
• API embeddings (Gemini/Voyage) — 90%+ accuracy when online
• NeurIPS 2021 projection — unit-modulus normalization for numerical stability

Retrieval cascade: HRR (~0.2ms) → FTS5 (~50ms) → Supabase (~200ms)

HRR acts as Tier 0 — if confidence is high, FTS5 is skipped entirely. Falls through gracefully when HRR has no match. 97 dedicated tests (72 system + 25 API/client). Built with Rust + rustfft + wasm-bindgen (229KB binary).

HRR AAC prediction benchmark — real-world impact on Prism AAC word prediction (10 scenarios, 54 integration tests):

Top-1 = correct word is tile #1. MRR = Mean Reciprocal Rank. Zero Top-5 regressions in any scenario. HRR encodes bigrams + trigrams from every spoken phrase; probes take ~0.2ms — safe on every keystroke. All Synalux apps (clinical, AAC, PrismCoach) share HRR via the portal /api/v1/hrr endpoint.

Competitive comparison:

🌐 Multi-agent Hivemind

Multiple AI agents share the same Mind Palace. Each agent has a role (dev / qa / pm / etc.) and sees scoped context. Heartbeat + roster for coordination.

Get started

# Install globally
npm install -g prism-mcp-server

# Or use npx (no install)
npx prism-mcp-server

Add to Claude Desktop / Cursor config:

{
  "mcpServers": {
    "prism": {
      "command": "npx",
      "args": ["-y", "prism-mcp-server"]
    }
  }
}

That's it. Open Claude / Cursor and your AI now has memory.

More setup details in docs/SETUP_GEMINI.md.

Monitoring & Observability (new in v16.2)

Built-in Datadog integration — every tool call is logged with tool name, project, and latency. Zero config for self-hosted users (logs to stdout); set DD_API_KEY to send structured logs to Datadog HTTP intake.

# Enable Datadog logging (optional)
export DD_API_KEY=your_datadog_api_key

# Enable OpenTelemetry tracing (optional — works with Jaeger, Zipkin, Datadog, Grafana Tempo)
export PRISM_OTEL_ENABLED=true
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318

What's tracked automatically:

• mcp.tool.success — tool name, project, duration (ms) on every successful call
• mcp.tool.error — tool name, error message, stack trace on failures
• OpenTelemetry spans with tool.name and project attributes on all 50 tool handlers

In-app analytics for paid users (new in v16.2)

Paid Synalux subscribers get a built-in analytics dashboard at /app/memory-analytics:

┌─────────────────────────────────────────────────────────┐
│  Analytics                              [standard] plan │
├─────────────────────────────────────────────────────────┤
│  📝 Sessions: 147  🔄 Handoffs: 23  📚 Knowledge: 89  │
│  📁 Projects: 5    💾 Memory: 42 KB                    │
├─────────────────────────────────────────────────────────┤
│  Today's Usage    🧠 47/200  🔎 12/50  💬 85/200       │
├─────────────────────────────────────────────────────────┤
│  30-Day Trend     ▂▃▅▇▆▄▃▅▆▇█▇▅▃▂▃▅▆▇▅▃▂▁▂▃▅▇▆▅▃    │
├─────────────────────────────────────────────────────────┤
│  Top Projects     prism-mcp (45) · portal (32) · ...   │
│  Compaction       3 entries > 5KB — run compact_ledger  │
└─────────────────────────────────────────────────────────┘

• Free tier: paywall with upgrade CTA
• Standard+: session counts, handoffs, knowledge entries, daily quotas with tier limits, 30-day activity trend, project breakdown, compaction candidates

How AI agents use it

(35+ tools total — full TypeScript signatures in src/tools/. Architecture overview in docs/ARCHITECTURE.md.)

Models

Prism Coder inference cascades through fine-tuned models first, with Claude as a quality-gate fallback. Models route through the Synalux router (authentication + subscription required). Cascade: Cloud (OpenRouter) → Ollama local → Claude fallback.

Models use the Synalux SFT corpus (AAC + Prism MCP tool taxonomy + clinical workflows). Internal quality gate: ≥ 90% on the Prism 102-case eval before production promotion.

Training note: Base Qwen3 models are strong tool-routers out of the box. Heavy fine-tuning regresses tool-vs-plain-text decisions; light-touch polish recipes (small corpus, balanced tool/plain-text split) are the published path. Production adapter selection and retrain methodology are managed in the Synalux portal.

Per-category breakdown — Prism 102-case eval (3-seed mean, v36/v7 system prompt, May 2026):

Methodology: 102-case pool across 12 categories. Scores are 3-seed mean (seeds 2027/2028/2029, zero variance across all seeds). All fine-tuned models use the Qwen3 nothink template with keyword-trigger routing prompts and -> respond directly (no tool) for the no-tool class. Full runner: tests/benchmarks/prism-routing-100/benchmark.py · Cascade runner: tests/benchmarks/cascade-14b-32b-opus/cascade_eval.py.

These are NOT general-purpose LLM benchmarks. This eval measures routing precision on 6 specific MCP tools. The prism-coder models are specialists trained on this exact task — they match or exceed Claude on routing while Claude dominates on general reasoning, coding, and open-domain QA. The value is offline reliability at zero cost, not replacing cloud AI.

iOS deployment: On-device inference via llama.cpp Swift SPM. Auto-selects by device RAM: 14B on iPad Pro 16GB (100% routing), 8B on iPhone/iPad 8GB (100%, OOM fallback to 1.7B at 100%). CoreML not viable — coremltools doesn't support Qwen3 attention ops. Integration: LLMEngine.swift → prismNativeBridge.askAI() → token stream. WiFi fallback: Mac Ollama (OLLAMA_HOST=0.0.0.0).

Benchmarks — run them yourself

All benchmarks are open-source. Reproduce every number in this README:

git clone https://github.com/dcostenco/prism-coder
cd prism-coder
pip install anthropic requests

# Per-model solo eval (102 cases, 3 seeds)
python3 tests/benchmarks/prism-routing-100/benchmark.py --models 14b 8b 32b 1b7 opus

# Cascade eval — 14B → 32B → Opus (Claude Opus as etalon)
export ANTHROPIC_API_KEY=sk-ant-...
ollama pull dcostenco/prism-coder:14b dcostenco/prism-coder:32b
python3 tests/benchmarks/cascade-14b-32b-opus/cascade_eval.py

Not a general function-calling benchmark. This measures routing precision on 6 specific MCP tools. We don't claim to beat Claude on general capabilities. We match or exceed Claude on the ONE task that matters for offline AAC: correct tool routing, every time, under 2 seconds, with zero cloud.

Cognitive Dialogue Memory (LoCoMo-Plus Benchmark)

LoCoMo-Plus is a long-context, multi-day dialogue benchmark designed to test an AI agent's memory retention, context awareness, and ability to coherently reference historical dialogue evidence.

The Cognitive subset (401 multi-day dialogue scenarios) was evaluated head-to-head comparing raw baseline models against the Prism-MCP framework (using local SQLite semantic memory). Graded by a neutral gemini-2.5-flash model acting as judge (scoring on coherence, continuity, and fact accuracy):

Key Takeaways:

• Pure attention limits: Even the strongest frontier model tested — Claude Sonnet 4.6 at 72.32% — misses over a quarter of cognitive memory cues without external memory. Gemini 3.5 Flash baseline sits at 59.10%. Both suffer from attention dilution when parsing massive multi-day transcripts directly in active context.
• Prism lifts every model: Prism-MCP yields large gains regardless of base model — from +16.71pp (Claude) to +37.66pp (Gemini 3.5 Flash). Even Claude's stronger native recall benefits from structured retrieval, jumping from 72.32% to 89.03%.
• Best overall: Prism-MCP + Gemini 3.5 Flash achieves the highest score (96.76%), eliminating 92.1% of baseline errors. This makes the cheapest model + Prism more accurate than the most expensive model alone.
• Claude vs Gemini (raw): Claude Sonnet 4.6 outperforms all Gemini baselines by a wide margin (+13.22pp over Flash 3.5, +4.49pp over Pro 3.1), confirming stronger native long-context recall.

{
  "category": "Cognitive",
  "input_prompt": "Caroline said, \"...\"\nMelanie said, \"...\"",
  "trigger": "Melanie said, \"Hey, Caroline! Nice to hear from you! Love the necklace, any special meaning to it?\"",
  "evidence": "Swedish grandmother's necklace was gifted to Caroline",
  "answer": "Yes, this necklace was a gift from my grandmother in my home country, Sweden."
}

# 1. Clone the LoCoMo-Plus evaluation codebase
git clone https://github.com/dcostenco/Locomo-Plus /tmp/Locomo-Plus
cd /tmp/Locomo-Plus

# 2. Run Baseline Gemini 3.1 Pro Evaluation (concurrency 5)
export GOOGLE_API_KEY="your-api-key"
PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/evaluate_qa.py \
  --data-file data/unified_cognitive_only.json \
  --out-file output/gemini_3.1_pro_pred.json \
  --model gemini-3.1-pro-preview \
  --backend call_gemini \
  --concurrency 5

# 3. Run Prism-MCP powered by Gemini 3.1 Pro Evaluation (concurrency 1 to guard SQLite locks)
export PRISM_TEXT_MODEL=gemini-3.1-pro-preview
PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/evaluate_qa.py \
  --data-file data/unified_cognitive_only.json \
  --out-file output/prism_gemini_3.1_pro_pred.json \
  --model gemini-3.1-pro-preview \
  --backend call_prism \
  --concurrency 1

# 4. Run Claude Sonnet 4.6 Baseline Evaluation (concurrency 3, rate-limit safe)
export ANTHROPIC_API_KEY="your-api-key"
PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/evaluate_qa.py \
  --data-file data/unified_cognitive_only.json \
  --out-file output/claude_sonnet46_pred.json \
  --model claude-sonnet-4-6 \
  --backend call_claude \
  --concurrency 3

# 5. Grade results using the LLM-as-a-Judge script
PYTHONPATH=/tmp/Locomo-Plus python3 evaluation_framework/task_eval/llm_as_judge.py \
  --input-file output/prism_gemini_3.1_pro_pred.json \
  --out-file output/prism_gemini_3.1_pro_judged.json \
  --model gemini-2.5-flash \
  --backend call_gemini \
  --concurrency 5 \
  --summary-file output/prism_gemini_3.1_pro_summary.json

Models on HuggingFace

Self-hosted / Local AI (Enterprise)

Run the full Prism model stack on your own hardware — zero cloud, zero latency, full data sovereignty.

Requirements: Mac M2 Pro+ (48GB recommended) or Linux with NVIDIA GPU · Ollama

# On-device tier — 1.1 GB (any machine, iPhone) — 100% routing
ollama pull dcostenco/prism-coder:1b7

# Mobile tier — 4.7 GB (iPhone/iPad 8GB, Mac M1+) — 100% routing
ollama pull dcostenco/prism-coder:8b

# Standard tier — 8.4 GB (Mac 24GB+, iPad Pro 16GB) — 100% routing
ollama pull dcostenco/prism-coder:14b

# Reasoning tier — 16 GB (Mac M2 Ultra+, 30B-A3B MoE) — 100% routing
ollama pull dcostenco/prism-coder:32b

Set LOCAL_LLM_URL=http://localhost:11434 in your portal config. Routing is automatic:

Desktop/server: 14B → 32B → Claude Opus fallback · Mobile/offline: 14B → 8B → 1.7B

iOS/mobile on same WiFi: OLLAMA_HOST=0.0.0.0 ollama serve on the Mac, then point LOCAL_LLM_URL at the Mac's IP.
Routing accuracy (May 2026, v36/v7 system prompt, 3-seed mean): 32B v7 = 100.0% · 8B v36 = 100.0% · 14B v36 = 100.0% · 1.7B v42 = 100.0%
Cascade (14B→32B): 100.0% · Opus solo: 98.3% · Opus engaged: 0% of requests → Full results

Plans

All on-device models are free for every tier — no subscription needed for local inference. Offline translation (1,261 phrases × 20 languages) included in all plans.

Subscribe →

What you can build with it

• Persistent coding assistant that remembers your codebase, your decisions, your team's conventions
• Research agent that builds knowledge over time — Auto-Scholar pipeline ingests papers / docs and synthesizes
• Clinical scribe that retains patient context across visits (HIPAA-compliant cloud + local)
• Customer support agent that learns from every ticket
• Writing assistant that knows your voice, your prior drafts, and what you've already published

Companions

🌐 Website & Docs

synalux.ai/prism-mcp — full documentation, dashboard, subscription plans, and model downloads.

💻 Web IDE — Synalux Coder

Use Prism Coder directly in your browser — no install required. Local-first IDE with the prism-coder agent built in. Connects to GitHub repos, Synalux Mail, Drive, and Source for cross-product workflows.

synalux.ai/coder · also reachable at synalux.ai/prism-ide

🧩 VS Code Extension — Synalux

Memory-augmented AI inside VS Code, powered by Prism. 20 multimodal tools, multi-agent orchestration, 12-language support. Works offline (Ollama) or cloud (OpenRouter). HIPAA-compliant healthcare workflows.

# Install from terminal
code --install-extension synalux-ai.synalux

Or open VS Code → Extensions (⇧⌘X) → search "Synalux" → Install.

📦 npm / npx

# Run without installing (always latest version)
npx prism-mcp-server

# Or install globally
npm install -g prism-mcp-server
prism load my-project

Package: prism-mcp-server on npm

PrismAAC

AAC communication app for non-speaking users. Powered by Prism's spreading-activation phrase ranking + on-device 7B model. macOS / iOS / Android via web. → github.com/dcostenco/prism-aac

🆕 Prism as Foundation (v14.0.0)

As of v14.0.0, Prism's algorithm exports are a stable public contract under SemVer. External systems can port actrActivation.ts (ACT-R cognitive decay), spreadingActivation.ts (the 0.7 similarity + 0.3 activation hybrid score), routerExperience.ts (experience bias with MIN_SAMPLES=5 cold-start gate), compactionHandler.ts (the 25KB prompt-budget cap), and graphMetrics.ts (warning ratios) with citations and pin a Prism version.

Reference consumers

CLI Reference

Prism Coder includes a CLI for session management, code review, and sync operations.

prism load <project>          # Load session context (same as session_load_context MCP tool)
prism save                    # Save session state (ledger + handoff)
prism ledger <project>        # Save a session log entry (same as session_save_ledger)
prism handoff <project>       # Update live project state for next session
prism push                    # Push local SQLite data to Supabase cloud
prism sync                    # Cross-backend data synchronization
prism search <query>          # Search code across repos (exact, regex, symbol, semantic)
prism review <files...>       # AI code review — security, performance, style
prism scan <files...>         # Security scan — secrets, licenses, Dockerfile
prism dora                    # Show DORA metrics for current project
prism scm                     # Source control, AI review, security scanning
prism verify                  # Manage the verification harness
prism status                  # Check verification state and config drift
prism generate                # Bless current rubric as canonical
prism register-models         # Alias dcostenco/prism-coder:* → prism-coder:*

Testing

npm test                           # 2,418 test cases across 81 files (vitest)
npm test -- --coverage             # coverage report
python3 tests/benchmarks/prism-routing-100/benchmark.py --models 1b7 14b 32b

Pinned in CI — 327 tests enforce every constant: ACT-R decay d=0.25, spreading-activation hybrid score 0.7/0.3, experience bias MIN_SAMPLES=5 / MAX_BIAS_CAP=0.15, graph-metrics warning ratios 0.20 / 0.30 / 0.40, compaction's 25KB prompt-budget. CI catches divergence automatically.

Coverage areas:

• HRR zero-search retrieval (97 tests: 3 embedding strategies, edge cases, persistence, adaptive cascade, API client, chat integration)
• Knowledge ingestion (32 tests: chunker, Q&A gen, webhook, security, storage round-trip)
• Prism infer cascade (110 tests: tier selection, cloud fallback, grounding verifier)
• Compaction handler (rollup creation, concurrency guard, LLM failure)
• Model picker (20 tests: 14b default ceiling, 4b verifier, RAM gating)
• Storage round-trip (12 architectural guard tests preventing bypass)
• BCBA skill integration
• Deep storage tier
• Dashboard rendering
• Routing benchmarks (eval_300: 300 cases, 17 tools)

Migration

Local SQLite → Synalux portal

If you've been running Prism on the free tier and want to move historical session data into the paid-tier portal, use the migration script:

# dry run first — prints what would be migrated, hits no network
node scripts/migrate-local-to-portal.mjs --dry-run

# real run — pushes ledger + handoff entries through POST /api/v1/prism/memory
PRISM_SYNALUX_API_KEY=synalux_sk_... \
  node scripts/migrate-local-to-portal.mjs

# scope to one project
node scripts/migrate-local-to-portal.mjs --project=my-project

# include scholar entries (excluded by default — usually large + low-value)
node scripts/migrate-local-to-portal.mjs --include-scholar

What it does: reads ~/.prism-mcp/data.db via @libsql/client (already a runtime dep — no extra install), exchanges the refresh token for a JWT (cached + auto-refreshed before expiry), and POSTs each ledger entry and handoff to the portal. Failures are logged with the source row id; successes are counted at the end.

Credentials: PRISM_SYNALUX_API_KEY from env. If unset, the script also checks ~/prism/.env for PRISM_SYNALUX_API_KEY=... as a convenience for dev workflows.

Idempotency: handoffs are written with the portal's CRDT merge (last-write-wins per project+role); ledger entries are append-only and de-duped server-side by (project, conversation_id, summary). Re-running on the same DB is safe.

One-shot only: this script is a migration tool, not a sync daemon. Once you've moved, set PRISM_STORAGE=synalux (or leave it on auto and let the resolver pick synalux when credentials are present) and the MCP server writes directly to the portal going forward.

Production Infrastructure

Architecture

  CLIENTS
  ┌─────────────────────┐  ┌─────────────────────────────┐
  │  prism-aac (iOS/web)│  │  Claude Code · Cursor · IDE │
  │  Vercel             │  │  MCP config → Railway URL   │
  └──────────┬──────────┘  └─────────────┬───────────────┘
             │ inference                  │ memory
             ▼                            ▼
  ┌──────────────────────┐  ┌─────────────────────────────┐
  │  SYNALUX ROUTER      │  │  prism-mcp SERVER           │
  │  Vercel              │  │                             │
  │  • JWT auth          │  │  Primary   — Railway        │
  │  • tier enforcement  │  │  Standby   — Fly.io         │
  │  • complexity route  │  │  Fallback  — Supabase REST  │
  │  • proxy to cloud    │  │  auto-failover chain        │
  └──────────┬───────────┘  └─────────────┬───────────────┘
             │                            │
             ▼                            ▼
  ┌──────────────────────────────┐  ┌─────────────────────────────┐
  │  OPENROUTER / LOCAL          │  │  SUPABASE                   │
  │                              │  │  session ledgers            │
  │  Cloud: Claude Sonnet 4      │  │  knowledge graph            │
  │  Routing: prism-coder        │  │  handoffs & todos           │
  │   :32b(100%) :14b(100%)      │  │                             │
  │   :8b(100%)  :1b7(100%)      │  │  source of truth            │
  │  Code:    prism-ide          │  │                             │
  │   :14b · :32b                │  │                             │
  └──────────────────────────────┘  └─────────────────────────────┘

Service Routing

LLM Backends

Web Search

TTS (Text-to-Speech)

Other Services

Synalux Inference Router

All Prism AAC model inference is protected behind Synalux as a mandatory router. Models are never accessible directly — all traffic goes through Synalux for auth, billing, and rate limiting.

┌──────────────────────────────────────────────────────────┐
│  CLIENT LAYER                                            │
│  prism-aac (iOS/web)         │   Synalux Portal          │
└──────────────┬───────────────────────────────────────────┘
               │ POST /api/v1/prism-aac/inference
               │ Authorization: Bearer <user-JWT>
               ▼
┌──────────────────────────────────────────────────────────┐
│  SYNALUX ROUTER                                          │
│  1. Verify JWT (no anonymous access)                     │
│  2. Check subscription tier                              │
│  3. Enforce rate limit (per-tier daily cap)               │
│  4. Route to model tier by complexity                    │
│  5. Proxy → OpenRouter / Gemini (key never exposed)      │
│  6. Log → aac_inference_log (audit trail)                │
└──────────┬───────────────────────────────┬───────────────┘
           │                               │
           ▼                               ▼
  ┌────────────────────┐      ┌──────────────────────┐
  │  LOCAL (Ollama)    │      │  CLOUD (OpenRouter)  │
  │  prism-coder:14b   │      │  Claude Sonnet 4     │
  │  prism-coder:8b    │      │  Claude Haiku 3.5    │
  │  prism-coder:1b7   │      │  Gemini 2.5 Flash    │
  │  free, offline     │      │  paid tiers          │
  └────────────────────┘      └──────────────────────┘

On-device (free, offline):
  prism-coder:1b7 GGUF Q4_K_M (1.1 GB) → any Apple device
  prism-coder:8b  GGUF Q4_K_M (4.7 GB) → iPhone/iPad 8 GB+
  prism-coder:14b GGUF Q4_K_M (8.4 GB) → Mac/iPad Pro 16 GB+

HuggingFace: dcostenco/prism-coder-{14b,8b,32b,1.7b} (public GGUF weights)

All on-device models are free for every tier — no subscription needed for local inference. Offline translation (1,261 phrases × 20 languages) included in all plans.

Subscribe →

See docs/WOW_FEATURES.md for the algorithm catalogue. Release notes in docs/releases/v14.0.0-prism-as-foundation.md.

License

AGPL-3.0 — Open source. Same license as Prism AAC. Commercial use via Synalux subscription for hosted/managed deployment.