prism-coder MCP工具

`prism scan` — security scanner for secrets, Dockerfiles, licenses

<p align="center"> <img src="docs/scm_scan_cli.jpg" alt="prism scan — security scan finding secrets and container issues" width="400" /> </p>

---

Install in all repos (one-time)

bash synalux-private/scripts/install-git-hooks.sh

Or install manually in a single repo

cp hooks/pre-commit .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit cp hooks/pre-push .git/hooks/pre-push && chmod +x .git/hooks/pre-push ```

Default mode is advisory (warn but allow). Set *_MODE=block for hard enforcement. Hooks look for full audit scripts in the repo first (hooks/lib/), then ~/.claude/hooks/ fallback, then minimal inline checks.

---

Quickstart

The free tier needs no account, no API key, and no cloud. Add the server to your MCP client:

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

Open Claude Desktop or Cursor and your agent now has memory backed by a local SQLite database (~/.prism-mcp/data.db).

Optional — local model fleet for offline tool-routing. Pull whichever fits your hardware:

ollama pull dcostenco/prism-coder:2b    # 2.3 GB · mobile / lightweight (99.1% routing accuracy)
ollama pull dcostenco/prism-coder:4b    # 3.4 GB · verifier (100% accuracy)
ollama pull dcostenco/prism-coder:9b    # 5.8 GB · default router (100% accuracy, Qwen3.5)
ollama pull dcostenco/prism-coder:27b   # 16 GB  · complex tasks (100% accuracy)

Prism detects both the namespaced (dcostenco/prism-coder:9b) and bare (prism-coder:9b) Ollama tags automatically.

---

`inference_metrics` — see your local-model usage on demand

Call inference_metrics anytime mid-session to see how many prism_infer calls ran locally vs cloud, with actual token counts:

📊 Inference Metrics — local-model delegation (this session):
  Total calls: 5 — Local: 5 (100%) | Cloud: 0 (0%)
  Tokens: 1,240 in + 380 out = 1,620 total
  Avg latency: 420ms
  By model:
    prism-coder:27b: 3 calls, 1,100 tokens, avg 520ms
    prism-coder:9b: 2 calls, 520 tokens, avg 270ms

The same block also appears automatically in session_save_ledger and session_save_handoff responses at session end.

Note: This tracks prism_infer delegation only — not your host model's (Claude's) own token spend. For that, use Claude Code's /cost command.

Enable via Prism config

prism config set delegation_enabled true ```

When enabled, the agent's task router may delegate qualifying work — bulk classification, field extraction, mechanical formatting — to prism_infer instead of using cloud tokens. The agent always verifies the result and redoes it itself if quality is degraded.

Guardrails: - Off by default — enforced in code, not just convention - Never delegates: code/text that ships to the user, security/safety logic, planning/reasoning, anything where a silent quality drop isn't obvious - Always verifies: checks quality_gate_failed and used_cloud before trusting local output

<details> <summary>How Prism survives context compaction</summary>

The LLM context window is treated as ephemeral scratch space; durable state lives in the persistent store (SQLite locally, the portal in the cloud). Every session begins with a mandatory session_load_context call, so the agent is oriented before it writes a response. When a project exceeds a threshold (default 50 entries), session_compact_ledger summarizes old entries into a rollup, soft-archives the originals, and links them in the graph. See docs/COMPACTION.md </details>

---

Configuration reference

With no variables set, Prism runs fully local. Set PRISM_SYNALUX_API_KEY (and leave PRISM_STORAGE=auto) to use the cloud backend.

---

Code Generation Quality (27B vs Claude Opus)

Three progressively harder Python tasks run through prism_infer(mode:"code", think:true) on the local 27B and compared with Claude Opus. Both produce correct, production-quality code. The 27B is slightly more verbose (docstrings, examples); Opus is slightly tighter (__slots__, early-exit DFS). On routine coding the 27B at $0 replaces cloud calls entirely.

<details> <summary>Local 27B output — Trie with autocomplete (hardest task)</summary>

class TrieNode:
    def __init__(self):
        self.children: dict[str, 'TrieNode'] = {}
        self.is_end_of_word: bool = False

class Trie:
    def __init__(self):
        self.root: TrieNode = TrieNode()

    def insert(self, word: str) -> None:
        node = self.root
        for char in word.lower():
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        node.is_end_of_word = True

    def search(self, word: str) -> bool:
        node = self._get_node(word.lower())
        return node is not None and node.is_end_of_word

    def starts_with(self, prefix: str) -> bool:
        return self._get_node(prefix.lower()) is not None

    def autocomplete(self, prefix: str, limit: int = 5) -> list[str]:
        node = self._get_node(prefix.lower())
        if node is None:
            return []
        results: list[str] = []
        self._collect_words(node, prefix.lower(), results)
        results.sort()
        return results[:limit]

    def _get_node(self, key: str) -> 'TrieNode | None':
        node = self.root
        for char in key:
            if char not in node.children:
                return None
            node = node.children[char]
        return node

    def _collect_words(self, node: TrieNode, prefix: str, results: list[str]) -> None:
        if node.is_end_of_word:
            results.append(prefix)
        for char, child in sorted(node.children.items()):
            self._collect_words(child, prefix + char, results)

</details>

vs AI coding assistants

These tables are the maintainer's assessment as of June 2026. Verify claims that matter to you — products change fast.

vs local AI / memory tools

VS Code Extension — Synalux

Memory-augmented AI inside VS Code with clinical practice management features. Install from the marketplace:

code --install-extension synalux-ai.synalux

AI chat, voice input, SOAP note generator, team collaboration, and video calls — all inside VS Code. Routes through local Ollama by default; cloud on paid tiers.

<details> <summary>Feature details</summary>

- AI: Chat participant (@synalux), multi-agent pipeline, voice input, model switching, 10 tones - Clinical: SOAP note generator, role-based access, document signing, patient board - Collaboration: Team chat, DMs, video calls, customer board, visual builder, DevContainers - Privacy: Local Ollama by default. preferLocal=true tries local first. Enterprise BAA available. </details>