0nmcp 2.8.0 → 2.9.1

package/catalog.js

@@ -1833,6 +1833,91 @@ export const SERVICE_CATALOG = {
     }),
   },
 
+  // ── Ollama (Local AI) ──────────────────────────────────────
+  ollama: {
+    name: "Ollama",
+    type: "ai",
+    description: "Local AI inference — chat completions, embeddings, model management. Free, private, no API costs.",
+    baseUrl: "http://localhost:11434",
+    authType: "none",
+    credentialKeys: [],
+    capabilities: [
+      { name: "generate_text", actions: ["create"], description: "Generate text completions with local models (Llama, Mistral, etc.)" },
+      { name: "chat_completion", actions: ["create"], description: "Multi-turn chat with local models" },
+      { name: "create_embedding", actions: ["create"], description: "Create text embeddings locally" },
+      { name: "manage_models", actions: ["list", "pull", "delete", "show"], description: "List, pull, inspect, and delete local models" },
+    ],
+    endpoints: {
+      chat_completion:  { method: "POST", path: "/api/chat", body: { model: "llama3.1", messages: [], stream: false } },
+      generate:         { method: "POST", path: "/api/generate", body: { model: "llama3.1", prompt: "", stream: false } },
+      create_embedding: { method: "POST", path: "/api/embed", body: { model: "llama3.1", input: "" } },
+      list_models:      { method: "GET",  path: "/api/tags" },
+      show_model:       { method: "POST", path: "/api/show", body: { name: "" } },
+      pull_model:       { method: "POST", path: "/api/pull", body: { name: "", stream: false } },
+      delete_model:     { method: "DELETE", path: "/api/delete", body: { name: "" } },
+      list_running:     { method: "GET",  path: "/api/ps" },
+    },
+    authHeader: () => ({
+      "Content-Type": "application/json",
+    }),
+  },
+
+  // ── Reddit ──────────────────────────────────────────────────
+  reddit: {
+    name: "Reddit",
+    type: "social",
+    description: "Social platform — posts, comments, subreddits, user profiles, search, monitoring via Reddit Data API. IMPORTANT: Reddit requires pre-approved OAuth apps as of Nov 2025. Auto-posting must comply with Reddit's Responsible Builder Policy. Default mode is MANUAL — auto mode requires double confirmation.",
+    baseUrl: "https://oauth.reddit.com",
+    authType: "oauth",
+    credentialKeys: ["accessToken", "refreshToken", "clientId", "clientSecret", "username"],
+    safetyConfig: {
+      defaultMode: "manual",
+      autoModeRequiresDoubleConfirmation: true,
+      minPostDelayMs: 600000,
+      minCommentDelayMs: 300000,
+      maxPostsPerHour: 3,
+      maxCommentsPerHour: 10,
+      rateLimitPerMinute: 60,
+      disclaimer: "Reddit aggressively bans automated promotional activity. Accounts suspected of bot behavior may be required to pass human verification (passkeys, biometrics, or government ID). All automated accounts must carry an [APP] label. Respect the 90/10 rule: 90% genuine value, 10% promotional. Each subreddit has its own rules — check before posting.",
+    },
+    capabilities: [
+      { name: "manage_posts", actions: ["create", "list", "get", "delete"], description: "Submit text/link posts to subreddits and manage them" },
+      { name: "manage_comments", actions: ["create", "list", "get", "delete"], description: "Post comments and replies on Reddit threads" },
+      { name: "manage_subreddits", actions: ["get", "list", "search"], description: "Browse and search subreddit info, rules, and hot/new/top posts" },
+      { name: "manage_profile", actions: ["get"], description: "View authenticated user profile, karma, and account age" },
+      { name: "search_content", actions: ["search"], description: "Search Reddit posts, comments, and subreddits" },
+      { name: "monitor_mentions", actions: ["search"], description: "Monitor keyword mentions across Reddit for brand/topic tracking" },
+      { name: "manage_messages", actions: ["list", "send"], description: "Read and send private messages" },
+    ],
+    endpoints: {
+      submit_post:          { method: "POST", path: "/api/submit", contentType: "application/x-www-form-urlencoded", body: { sr: "", kind: "self", title: "", text: "" } },
+      submit_link:          { method: "POST", path: "/api/submit", contentType: "application/x-www-form-urlencoded", body: { sr: "", kind: "link", title: "", url: "" } },
+      get_post:             { method: "GET",  path: "/r/{subreddit}/comments/{postId}" },
+      delete_thing:         { method: "POST", path: "/api/del", contentType: "application/x-www-form-urlencoded", body: { id: "" } },
+      get_user_posts:       { method: "GET",  path: "/user/{username}/submitted", query: ["sort", "t", "limit"] },
+      post_comment:         { method: "POST", path: "/api/comment", contentType: "application/x-www-form-urlencoded", body: { thing_id: "", text: "" } },
+      get_comments:         { method: "GET",  path: "/r/{subreddit}/comments/{postId}", query: ["sort", "limit", "depth"] },
+      get_subreddit:        { method: "GET",  path: "/r/{subreddit}/about" },
+      get_subreddit_rules:  { method: "GET",  path: "/r/{subreddit}/about/rules" },
+      get_hot:              { method: "GET",  path: "/r/{subreddit}/hot", query: ["limit", "after"] },
+      get_new:              { method: "GET",  path: "/r/{subreddit}/new", query: ["limit", "after"] },
+      get_top:              { method: "GET",  path: "/r/{subreddit}/top", query: ["t", "limit", "after"] },
+      search_subreddits:    { method: "GET",  path: "/subreddits/search", query: ["q", "limit", "sort"] },
+      list_my_subreddits:   { method: "GET",  path: "/subreddits/mine/subscriber", query: ["limit", "after"] },
+      search_posts:         { method: "GET",  path: "/search", query: ["q", "type", "sort", "t", "limit", "restrict_sr", "sr"] },
+      get_me:               { method: "GET",  path: "/api/v1/me" },
+      get_user:             { method: "GET",  path: "/user/{username}/about" },
+      get_user_comments:    { method: "GET",  path: "/user/{username}/comments", query: ["sort", "t", "limit"] },
+      get_inbox:            { method: "GET",  path: "/message/inbox", query: ["limit", "after"] },
+      send_message:         { method: "POST", path: "/api/compose", contentType: "application/x-www-form-urlencoded", body: { to: "", subject: "", text: "" } },
+      vote:                 { method: "POST", path: "/api/vote", contentType: "application/x-www-form-urlencoded", body: { id: "", dir: 1 } },
+    },
+    authHeader: (creds) => ({
+      "Authorization": `Bearer ${creds.accessToken}`,
+      "User-Agent": `0nMCP:RedditService:1.0.0 (by /u/${creds.username || "0nMCP"})`,
+    }),
+  },
+
 };
 
 // ── Helpers ────────────────────────────────────────────────

package/engine/brain.js

@@ -0,0 +1,738 @@
+// ============================================================
+// 0nMCP — Brain Compiler & Behavior Engine
+// ============================================================
+// Merges BotCoaches concept into 0nAI. Portable AI behavior
+// packages (.brain files) that can be imported into any app
+// on any LLM.
+//
+// The Three-Layer Model:
+//   BRAIN  = Trained Behavior (portable .brain file)
+//   SKULL  = Application Container (0nCore, Marketplace, any app)
+//   BODY   = LLM Compute (Claude, GPT, Gemini, Grok, Llama)
+//
+// 6 MCP Tools:
+//   brain_create    — Create a new brain project
+//   brain_build     — Add knowledge/reasoning/behavior/skills
+//   brain_train     — Run scenario-based training with evaluation
+//   brain_compile   — Compile to portable .brain file
+//   brain_import    — Import .brain and convert to system prompt
+//   brain_list      — List all brain projects
+//
+// Database: Supabase (pwujhhmlrtxjmjzyttwn)
+// ============================================================
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+
+const BRAINS_DIR = join(homedir(), ".0n", "brains");
+
+// ── .brain file format version ────────────────────────────
+const BRAIN_VERSION = "1.0.0";
+const BRAIN_FORMAT = "0nai-brain";
+
+/**
+ * Register brain engine tools on an MCP server instance.
+ *
+ * @param {import("@modelcontextprotocol/sdk/server/mcp.js").McpServer} server
+ * @param {import("zod").ZodType} z
+ * @param {object} [supabase]
+ */
+export function registerBrainTools(server, z, supabase) {
+
+  async function getSupabase() {
+    if (supabase) return supabase;
+    try {
+      const { createClient } = await import("@supabase/supabase-js");
+      const url = process.env.SUPABASE_URL || "https://pwujhhmlrtxjmjzyttwn.supabase.co";
+      const key = process.env.SUPABASE_SERVICE_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY;
+      if (!key) throw new Error("No Supabase service key");
+      supabase = createClient(url, key);
+      return supabase;
+    } catch (err) {
+      throw new Error(`Supabase not available: ${err.message}`);
+    }
+  }
+
+  // ─── brain_create ─────────────────────────────────────────
+  server.tool(
+    "brain_create",
+    `Create a new brain project. A brain is a portable AI behavior package
+with knowledge, reasoning patterns, behavior rules, and skills.
+
+Example: brain_create({ name: "CRM Expert", domain: "crm", description: "Knows all 245 CRM tools" })
+Example: brain_create({ name: "SXO Writer", domain: "content", traits: ["professional", "data-driven"] })`,
+    {
+      name: z.string().describe("Brain name"),
+      domain: z.string().describe("Domain: crm, content, sales, support, development, automation, general"),
+      description: z.string().optional().describe("What this brain does"),
+      traits: z.array(z.string()).optional().describe("Personality traits: professional, thorough, concise, etc."),
+      base_brain: z.string().optional().describe("ID of brain to fork from"),
+    },
+    async ({ name, domain, description, traits, base_brain }) => {
+      try {
+        const sb = await getSupabase();
+
+        let brain_data = {
+          format: BRAIN_FORMAT,
+          version: BRAIN_VERSION,
+          identity: { name, domain, description: description || "", author: "RocketOpp", trained_by: "0nAI" },
+          knowledge: { concepts: [], facts: [], rules: [], glossary: [] },
+          reasoning: {
+            decomposition: [],
+            decision_making: [],
+            question_asking: [],
+          },
+          behavior: {
+            personality: { traits: traits || ["professional", "helpful"], boundaries: [] },
+            communication: { style: "adaptive", verbosity: "balanced" },
+            interaction: { greeting_patterns: [], error_handling: [] },
+          },
+          skills: { modules: [], tool_mapping: [] },
+          evaluation: { scenarios: [], rubric: null, benchmarks: [] },
+          training: { iterations: [], final_score: 0, method: "simulated" },
+        };
+
+        // Fork from existing brain
+        if (base_brain) {
+          const { data: parent } = await sb.from("bc_brains").select("brain_data").eq("id", base_brain).single();
+          if (parent?.brain_data) {
+            brain_data = { ...parent.brain_data, identity: { ...parent.brain_data.identity, name, domain, description: description || "" } };
+          }
+        }
+
+        const { data, error } = await sb.from("bc_brains").insert({
+          name,
+          domain,
+          description: description || "",
+          brain_data,
+          status: "draft",
+          version: "0.1.0",
+          training_score: 0,
+        }).select("id, name, domain, status, version").single();
+
+        if (error) throw error;
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "created", brain: data,
+          message: `Brain "${name}" created. Use brain_build to add knowledge, reasoning, behavior, and skills.`,
+          next_steps: [
+            `brain_build({ brain_id: "${data.id}", layer: "knowledge", action: "add", items: [...] })`,
+            `brain_build({ brain_id: "${data.id}", layer: "reasoning", action: "add", items: [...] })`,
+            `brain_build({ brain_id: "${data.id}", layer: "behavior", action: "set", config: {...} })`,
+          ],
+        }, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── brain_build ──────────────────────────────────────────
+  server.tool(
+    "brain_build",
+    `Add knowledge, reasoning patterns, behavior rules, or skills to a brain.
+
+Layers:
+  knowledge  — concepts, facts, rules, glossary terms
+  reasoning  — decomposition patterns, decision frameworks, question triggers
+  behavior   — personality traits, communication style, boundaries
+  skills     — capability modules, tool mappings
+  scenarios  — test scenarios with expected behavior
+
+Example: brain_build({ brain_id: "uuid", layer: "knowledge", action: "add", items: [
+  { type: "fact", content: "0nMCP has 819 tools across 54 services" },
+  { type: "rule", content: "Never say GHL — always say CRM" },
+  { type: "concept", name: "Radial Burst", definition: "Fan-out content to all channels simultaneously" }
+]})
+
+Example: brain_build({ brain_id: "uuid", layer: "scenarios", action: "add", items: [
+  { input: "How do I create a contact?", expected: "Should reference CRM contacts API, never say GHL", difficulty: "easy" }
+]})`,
+    {
+      brain_id: z.string().describe("Brain ID"),
+      layer: z.enum(["knowledge", "reasoning", "behavior", "skills", "scenarios"]).describe("Which layer to build"),
+      action: z.enum(["add", "set", "remove", "clear"]).describe("add items, set config, remove by index, clear layer"),
+      items: z.array(z.record(z.any())).optional().describe("Items to add (for knowledge, reasoning, skills, scenarios)"),
+      config: z.record(z.any()).optional().describe("Config to set (for behavior)"),
+      indices: z.array(z.number()).optional().describe("Indices to remove"),
+    },
+    async ({ brain_id, layer, action, items, config, indices }) => {
+      try {
+        const sb = await getSupabase();
+        const { data: brain, error: fetchErr } = await sb.from("bc_brains").select("*").eq("id", brain_id).single();
+        if (fetchErr || !brain) throw new Error("Brain not found");
+
+        const bd = brain.brain_data;
+
+        if (layer === "knowledge") {
+          if (action === "add" && items) {
+            bd.knowledge.facts = bd.knowledge.facts || [];
+            bd.knowledge.concepts = bd.knowledge.concepts || [];
+            bd.knowledge.rules = bd.knowledge.rules || [];
+            bd.knowledge.glossary = bd.knowledge.glossary || [];
+            for (const item of items) {
+              const type = item.type || "fact";
+              if (type === "fact") bd.knowledge.facts.push({ content: item.content, source: item.source || "manual" });
+              else if (type === "concept") bd.knowledge.concepts.push({ name: item.name, definition: item.definition || item.content });
+              else if (type === "rule") bd.knowledge.rules.push({ rule: item.content || item.rule, priority: item.priority || "normal" });
+              else if (type === "term") bd.knowledge.glossary.push({ term: item.term || item.name, definition: item.definition || item.content });
+            }
+          } else if (action === "clear") {
+            bd.knowledge = { concepts: [], facts: [], rules: [], glossary: [] };
+          }
+        }
+
+        else if (layer === "reasoning") {
+          if (action === "add" && items) {
+            for (const item of items) {
+              const cat = item.category || "decomposition";
+              bd.reasoning[cat] = bd.reasoning[cat] || [];
+              bd.reasoning[cat].push({ pattern: item.pattern || item.content, when: item.when, example: item.example });
+            }
+          } else if (action === "clear") {
+            bd.reasoning = { decomposition: [], decision_making: [], question_asking: [] };
+          }
+        }
+
+        else if (layer === "behavior") {
+          if (action === "set" && config) {
+            if (config.traits) bd.behavior.personality.traits = config.traits;
+            if (config.boundaries) bd.behavior.personality.boundaries = config.boundaries;
+            if (config.style) bd.behavior.communication.style = config.style;
+            if (config.verbosity) bd.behavior.communication.verbosity = config.verbosity;
+            if (config.greeting_patterns) bd.behavior.interaction.greeting_patterns = config.greeting_patterns;
+            if (config.error_handling) bd.behavior.interaction.error_handling = config.error_handling;
+          } else if (action === "clear") {
+            bd.behavior = { personality: { traits: [], boundaries: [] }, communication: { style: "adaptive", verbosity: "balanced" }, interaction: { greeting_patterns: [], error_handling: [] } };
+          }
+        }
+
+        else if (layer === "skills") {
+          if (action === "add" && items) {
+            bd.skills.modules = bd.skills.modules || [];
+            for (const item of items) {
+              bd.skills.modules.push({ name: item.name, description: item.description || "", capabilities: item.capabilities || [] });
+            }
+          } else if (action === "clear") {
+            bd.skills = { modules: [], tool_mapping: [] };
+          }
+        }
+
+        else if (layer === "scenarios") {
+          if (action === "add" && items) {
+            bd.evaluation.scenarios = bd.evaluation.scenarios || [];
+            for (const item of items) {
+              bd.evaluation.scenarios.push({
+                input: item.input,
+                context: item.context || null,
+                expected: item.expected || null,
+                difficulty: item.difficulty || "medium",
+                category: item.category || "general",
+              });
+            }
+          } else if (action === "remove" && indices) {
+            bd.evaluation.scenarios = bd.evaluation.scenarios.filter((_, i) => !indices.includes(i));
+          } else if (action === "clear") {
+            bd.evaluation.scenarios = [];
+          }
+        }
+
+        // Save
+        const { error: updateErr } = await sb.from("bc_brains").update({
+          brain_data: bd,
+          updated_at: new Date().toISOString(),
+        }).eq("id", brain_id);
+        if (updateErr) throw updateErr;
+
+        // Count items per layer
+        const counts = {
+          knowledge: (bd.knowledge.concepts?.length || 0) + (bd.knowledge.facts?.length || 0) + (bd.knowledge.rules?.length || 0) + (bd.knowledge.glossary?.length || 0),
+          reasoning: Object.values(bd.reasoning).reduce((s, arr) => s + (arr?.length || 0), 0),
+          behavior: bd.behavior.personality.traits?.length || 0,
+          skills: bd.skills.modules?.length || 0,
+          scenarios: bd.evaluation.scenarios?.length || 0,
+        };
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "updated", brain_id, layer, action, counts,
+          message: `Brain "${brain.name}" updated. ${layer} now has ${counts[layer]} items.`,
+        }, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── brain_train ──────────────────────────────────────────
+  server.tool(
+    "brain_train",
+    `Run scenario-based training on a brain. Executes each scenario against
+the brain's compiled prompt, evaluates responses against expected behavior,
+and scores across multiple dimensions.
+
+This generates training pairs that feed back into the 0nAI training pipeline.
+
+Example: brain_train({ brain_id: "uuid" })
+Example: brain_train({ brain_id: "uuid", scenarios: [0,1,2], provider: "anthropic" })`,
+    {
+      brain_id: z.string().describe("Brain to train"),
+      scenarios: z.array(z.number()).optional().describe("Specific scenario indices to run (default: all)"),
+      provider: z.enum(["local", "anthropic"]).optional().describe("LLM provider (default: local — no API cost)"),
+    },
+    async ({ brain_id, scenarios: scenarioIndices, provider }) => {
+      try {
+        const sb = await getSupabase();
+        const { data: brain } = await sb.from("bc_brains").select("*").eq("id", brain_id).single();
+        if (!brain) throw new Error("Brain not found");
+
+        const bd = brain.brain_data;
+        const allScenarios = bd.evaluation?.scenarios || [];
+
+        if (allScenarios.length === 0) {
+          return { content: [{ type: "text", text: JSON.stringify({
+            status: "no_scenarios",
+            message: "No scenarios defined. Use brain_build to add scenarios first.",
+          }) }] };
+        }
+
+        const toRun = scenarioIndices
+          ? allScenarios.filter((_, i) => scenarioIndices.includes(i))
+          : allScenarios;
+
+        // Compile the brain to a system prompt
+        const systemPrompt = compileBrainToPrompt(bd);
+
+        const results = [];
+        for (const scenario of toRun) {
+          let response;
+          let score;
+
+          if (provider === "anthropic" && process.env.ANTHROPIC_API_KEY) {
+            // Live API call — COSTS MONEY
+            try {
+              const { default: Anthropic } = await import("@anthropic-ai/sdk");
+              const client = new Anthropic();
+              const msg = await client.messages.create({
+                model: "claude-sonnet-4-20250514",
+                max_tokens: 1024,
+                system: systemPrompt,
+                messages: [{ role: "user", content: scenario.input }],
+              });
+              response = msg.content[0]?.text || "";
+            } catch (apiErr) {
+              response = `[API Error: ${apiErr.message}]`;
+            }
+          } else {
+            // Local evaluation — no API cost
+            // Score based on whether the prompt + scenario alignment makes sense
+            response = "[Local mode — no API call. Score based on prompt structure analysis.]";
+          }
+
+          // Score the response
+          score = scoreResponse(response, scenario, bd);
+
+          results.push({
+            input: scenario.input.substring(0, 100),
+            difficulty: scenario.difficulty,
+            score: score.overall,
+            dimensions: score.dimensions,
+            passed: score.overall >= 0.7,
+          });
+
+          // Feed back into training pipeline as a pair
+          if (response && response.length > 20 && !response.startsWith("[Local")) {
+            await sb.from("training_pairs").insert({
+              system_prompt: systemPrompt,
+              user_input: scenario.input,
+              assistant_output: response,
+              domain: brain.domain || "general",
+              difficulty: scenario.difficulty || "medium",
+              quality_score: score.overall,
+              tags: ["brain-training", brain.name],
+              metadata: { brain_id, brain_name: brain.name },
+            }).catch(() => {}); // Don't fail if training tables don't exist
+          }
+        }
+
+        const avgScore = results.length > 0
+          ? Math.round(results.reduce((s, r) => s + r.score, 0) / results.length * 100) / 100
+          : 0;
+
+        const passed = results.filter(r => r.passed).length;
+
+        // Update brain score
+        bd.training.iterations = bd.training.iterations || [];
+        bd.training.iterations.push({
+          date: new Date().toISOString(),
+          scenarios_run: results.length,
+          avg_score: avgScore,
+          passed,
+          failed: results.length - passed,
+        });
+        bd.training.final_score = avgScore;
+
+        await sb.from("bc_brains").update({
+          brain_data: bd,
+          training_score: avgScore,
+          status: avgScore >= 0.85 ? "trained" : "training",
+          updated_at: new Date().toISOString(),
+        }).eq("id", brain_id);
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "trained",
+          brain: brain.name,
+          scenarios_run: results.length,
+          passed,
+          failed: results.length - passed,
+          avg_score: avgScore,
+          threshold: 0.85,
+          verdict: avgScore >= 0.85 ? "READY TO COMPILE" : "NEEDS MORE TRAINING",
+          results,
+          message: avgScore >= 0.85
+            ? `Brain "${brain.name}" passed! Use brain_compile to package it.`
+            : `Brain "${brain.name}" scored ${avgScore}. Add more knowledge/reasoning and retrain.`,
+        }, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── brain_compile ────────────────────────────────────────
+  server.tool(
+    "brain_compile",
+    `Compile a trained brain into a portable .brain file.
+The .brain file can be imported into any app on any LLM.
+
+Also generates the system prompt version for direct use.
+
+Example: brain_compile({ brain_id: "uuid" })
+Example: brain_compile({ brain_id: "uuid", output: "prompt" }) — just get the prompt`,
+    {
+      brain_id: z.string().describe("Brain to compile"),
+      version: z.string().optional().describe("Version tag (default: auto-increment)"),
+      output: z.enum(["file", "prompt", "both"]).optional().describe("Output format (default: both)"),
+    },
+    async ({ brain_id, version, output }) => {
+      try {
+        const sb = await getSupabase();
+        const { data: brain } = await sb.from("bc_brains").select("*").eq("id", brain_id).single();
+        if (!brain) throw new Error("Brain not found");
+
+        const bd = brain.brain_data;
+        const outputMode = output || "both";
+
+        // Generate system prompt
+        const systemPrompt = compileBrainToPrompt(bd);
+
+        // Build .brain file
+        const brainFile = {
+          $brain: {
+            format: BRAIN_FORMAT,
+            version: BRAIN_VERSION,
+            compiled: new Date().toISOString(),
+            compiler: "0nAI Brain Engine v1.0.0",
+          },
+          identity: bd.identity,
+          knowledge: bd.knowledge,
+          reasoning: bd.reasoning,
+          behavior: bd.behavior,
+          skills: bd.skills,
+          evaluation: {
+            scenarios_count: bd.evaluation?.scenarios?.length || 0,
+            final_score: bd.training?.final_score || 0,
+            training_iterations: bd.training?.iterations?.length || 0,
+          },
+          prompt: systemPrompt,
+          checksum: null,
+        };
+
+        // Compute checksum
+        const content = JSON.stringify(brainFile);
+        brainFile.checksum = createHash("sha256").update(content).digest("hex");
+
+        const result = { status: "compiled", brain: brain.name, version: version || brain.version };
+
+        // Save .brain file
+        if (outputMode === "file" || outputMode === "both") {
+          if (!existsSync(BRAINS_DIR)) mkdirSync(BRAINS_DIR, { recursive: true });
+          const filename = `${brain.name.toLowerCase().replace(/\s+/g, "-")}-v${version || brain.version}.brain`;
+          const filePath = join(BRAINS_DIR, filename);
+          writeFileSync(filePath, JSON.stringify(brainFile, null, 2));
+          result.file = filePath;
+          result.size_bytes = Buffer.byteLength(JSON.stringify(brainFile));
+        }
+
+        // Return prompt
+        if (outputMode === "prompt" || outputMode === "both") {
+          result.prompt = systemPrompt;
+          result.prompt_tokens = Math.ceil(systemPrompt.length / 4);
+        }
+
+        result.checksum = brainFile.checksum;
+        result.message = `Brain "${brain.name}" compiled. ${outputMode === "prompt" ? "Prompt ready." : `Saved to ${result.file}`}`;
+
+        // Update DB
+        const newVer = version || incrementVersion(brain.version);
+        await sb.from("bc_brains").update({
+          version: newVer,
+          status: "compiled",
+          updated_at: new Date().toISOString(),
+        }).eq("id", brain_id);
+
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── brain_import ─────────────────────────────────────────
+  server.tool(
+    "brain_import",
+    `Import a .brain file and extract its system prompt for use in any LLM.
+Can import from file path or raw JSON.
+
+Example: brain_import({ path: "~/.0n/brains/crm-expert-v1.0.0.brain" })
+Example: brain_import({ brain_data: {...} })`,
+    {
+      path: z.string().optional().describe("Path to .brain file"),
+      brain_data: z.record(z.any()).optional().describe("Raw brain data JSON"),
+      target_llm: z.enum(["claude", "openai", "gemini", "grok", "generic"]).optional().describe("Target LLM format (default: claude)"),
+    },
+    async ({ path, brain_data, target_llm }) => {
+      try {
+        let brain;
+        if (path) {
+          const resolvedPath = path.replace("~", homedir());
+          if (!existsSync(resolvedPath)) throw new Error(`File not found: ${resolvedPath}`);
+          brain = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+        } else if (brain_data) {
+          brain = brain_data;
+        } else {
+          throw new Error("Provide path or brain_data");
+        }
+
+        // Validate format
+        if (!brain.$brain && !brain.identity) throw new Error("Invalid .brain file format");
+
+        // Extract or regenerate prompt
+        let prompt = brain.prompt;
+        if (!prompt) {
+          prompt = compileBrainToPrompt(brain);
+        }
+
+        // Format for target LLM
+        const llm = target_llm || "claude";
+        let formatted;
+        if (llm === "openai") {
+          formatted = { role: "system", content: prompt };
+        } else if (llm === "gemini") {
+          formatted = { system_instruction: { parts: [{ text: prompt }] } };
+        } else {
+          formatted = { system: prompt };
+        }
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "imported",
+          name: brain.identity?.name || "Unknown",
+          domain: brain.identity?.domain || "general",
+          score: brain.evaluation?.final_score || brain.training?.final_score || 0,
+          prompt_length: prompt.length,
+          prompt_tokens: Math.ceil(prompt.length / 4),
+          target_llm: llm,
+          formatted,
+          prompt,
+          message: `Brain "${brain.identity?.name}" imported. Ready to use with ${llm}.`,
+        }, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── brain_list ───────────────────────────────────────────
+  server.tool(
+    "brain_list",
+    `List all brain projects with their status and training scores.
+
+Example: brain_list({})
+Example: brain_list({ domain: "crm" })
+Example: brain_list({ status: "trained" })`,
+    {
+      domain: z.string().optional().describe("Filter by domain"),
+      status: z.enum(["draft", "training", "trained", "compiled", "published"]).optional().describe("Filter by status"),
+    },
+    async ({ domain, status }) => {
+      try {
+        const sb = await getSupabase();
+        let query = sb.from("bc_brains").select("id, name, domain, description, status, version, training_score, created_at, updated_at")
+          .order("updated_at", { ascending: false });
+        if (domain) query = query.eq("domain", domain);
+        if (status) query = query.eq("status", status);
+
+        const { data, error } = await query;
+        if (error) throw error;
+
+        // Also check local .brain files
+        let localFiles = [];
+        if (existsSync(BRAINS_DIR)) {
+          const { readdirSync } = await import("fs");
+          localFiles = readdirSync(BRAINS_DIR).filter(f => f.endsWith(".brain")).map(f => ({
+            file: f,
+            path: join(BRAINS_DIR, f),
+          }));
+        }
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "ok",
+          count: (data || []).length,
+          brains: data || [],
+          local_files: localFiles,
+          message: `${(data || []).length} brain(s) in database, ${localFiles.length} compiled .brain file(s) in ~/.0n/brains/`,
+        }, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+}
+
+// ── Brain-to-Prompt Compiler ──────────────────────────────
+
+/**
+ * Compile brain data into a system prompt for any LLM.
+ */
+function compileBrainToPrompt(bd) {
+  const sections = [];
+
+  // Identity
+  if (bd.identity) {
+    sections.push(`# ${bd.identity.name}\n\nYou are ${bd.identity.name}. ${bd.identity.description || ""}\nDomain: ${bd.identity.domain || "general"}`);
+  }
+
+  // Knowledge — Rules (highest priority)
+  if (bd.knowledge?.rules?.length) {
+    sections.push("## Rules\n\n" + bd.knowledge.rules.map((r, i) => `${i + 1}. ${r.rule || r.content}`).join("\n"));
+  }
+
+  // Knowledge — Core concepts
+  if (bd.knowledge?.concepts?.length) {
+    sections.push("## Core Concepts\n\n" + bd.knowledge.concepts.map(c =>
+      `**${c.name}**: ${c.definition}`
+    ).join("\n\n"));
+  }
+
+  // Knowledge — Facts
+  if (bd.knowledge?.facts?.length) {
+    sections.push("## Key Facts\n\n" + bd.knowledge.facts.map(f => `- ${f.content}`).join("\n"));
+  }
+
+  // Knowledge — Glossary
+  if (bd.knowledge?.glossary?.length) {
+    sections.push("## Glossary\n\n" + bd.knowledge.glossary.map(t => `- **${t.term}**: ${t.definition}`).join("\n"));
+  }
+
+  // Reasoning patterns
+  const allPatterns = [
+    ...(bd.reasoning?.decomposition || []).map(p => ({ ...p, cat: "Decomposition" })),
+    ...(bd.reasoning?.decision_making || []).map(p => ({ ...p, cat: "Decision Making" })),
+    ...(bd.reasoning?.question_asking || []).map(p => ({ ...p, cat: "Question Asking" })),
+  ];
+  if (allPatterns.length) {
+    sections.push("## Reasoning Patterns\n\n" + allPatterns.map(p =>
+      `### ${p.cat}\n${p.pattern || p.content}${p.when ? `\n**When:** ${p.when}` : ""}${p.example ? `\n**Example:** ${p.example}` : ""}`
+    ).join("\n\n"));
+  }
+
+  // Behavior
+  if (bd.behavior?.personality?.traits?.length) {
+    sections.push("## Behavior\n\n" +
+      `**Traits:** ${bd.behavior.personality.traits.join(", ")}\n` +
+      `**Style:** ${bd.behavior.communication?.style || "adaptive"}\n` +
+      `**Verbosity:** ${bd.behavior.communication?.verbosity || "balanced"}`
+    );
+    if (bd.behavior.personality.boundaries?.length) {
+      sections.push("**Boundaries:**\n" + bd.behavior.personality.boundaries.map(b => `- ${b}`).join("\n"));
+    }
+  }
+
+  // Skills
+  if (bd.skills?.modules?.length) {
+    sections.push("## Skills\n\n" + bd.skills.modules.map(s =>
+      `### ${s.name}\n${s.description}${s.capabilities?.length ? "\n- " + s.capabilities.join("\n- ") : ""}`
+    ).join("\n\n"));
+  }
+
+  return sections.join("\n\n---\n\n");
+}
+
+// ── Response Scoring ──────────────────────────────────────
+
+/**
+ * Score a response against a scenario and brain config.
+ */
+function scoreResponse(response, scenario, bd) {
+  const dimensions = {};
+  let total = 0;
+  let count = 0;
+
+  // Relevance — does the response address the input?
+  const inputWords = new Set(scenario.input.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+  const responseWords = new Set(response.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+  let overlap = 0;
+  for (const w of inputWords) if (responseWords.has(w)) overlap++;
+  dimensions.relevance = inputWords.size > 0 ? Math.min(1, overlap / inputWords.size + 0.3) : 0.5;
+  total += dimensions.relevance; count++;
+
+  // Rule compliance — check against brain rules
+  const rules = bd.knowledge?.rules || [];
+  let ruleScore = 1.0;
+  for (const rule of rules) {
+    const ruleText = (rule.rule || rule.content || "").toLowerCase();
+    // Check for "never" rules
+    if (ruleText.includes("never")) {
+      const forbidden = ruleText.replace(/never\s+(say|use|mention)\s+/i, "").replace(/['"]/g, "").trim().split(/\s*[,—-]\s*/);
+      for (const word of forbidden) {
+        if (word.length > 2 && response.toLowerCase().includes(word.toLowerCase())) {
+          ruleScore -= 0.3;
+        }
+      }
+    }
+  }
+  dimensions.rule_compliance = Math.max(0, ruleScore);
+  total += dimensions.rule_compliance; count++;
+
+  // Completeness — response length relative to expected
+  if (response.length > 50) dimensions.completeness = Math.min(1, response.length / 200);
+  else dimensions.completeness = 0.3;
+  total += dimensions.completeness; count++;
+
+  // Structure — has formatting (headers, lists, code blocks)
+  let structureScore = 0.4;
+  if (response.includes("- ") || response.includes("* ")) structureScore += 0.2;
+  if (response.includes("**") || response.includes("##")) structureScore += 0.2;
+  if (response.includes("```")) structureScore += 0.2;
+  dimensions.structure = Math.min(1, structureScore);
+  total += dimensions.structure; count++;
+
+  // Tone — matches brain personality
+  const traits = bd.behavior?.personality?.traits || [];
+  dimensions.tone = traits.length > 0 ? 0.7 : 0.5; // baseline
+  total += dimensions.tone; count++;
+
+  const overall = count > 0 ? Math.round(total / count * 100) / 100 : 0;
+
+  return { overall, dimensions };
+}
+
+// ── Helpers ───────────────────────────────────────────────
+
+function incrementVersion(ver) {
+  if (!ver) return "0.1.0";
+  const parts = ver.split(".").map(Number);
+  parts[2] = (parts[2] || 0) + 1;
+  return parts.join(".");
+}

package/engine/local-ai.js

@@ -0,0 +1,439 @@
+// ============================================================
+// 0nMCP — Local AI Engine (0nAI ↔ Ollama/Llama)
+// ============================================================
+// Direct interface to local Llama models via Ollama.
+// Zero cost, fully private, no data leaves the machine.
+//
+// 5 MCP Tools:
+//   ai_chat     — Chat with local Llama (with optional brain)
+//   ai_generate — One-shot text generation
+//   ai_models   — List/pull/manage local models
+//   ai_embed    — Create embeddings locally
+//   ai_bench    — Benchmark a prompt across local + cloud models
+//
+// Requires: Ollama running at localhost:11434
+// ============================================================
+
+const OLLAMA_BASE = process.env.OLLAMA_URL || "http://localhost:11434";
+const DEFAULT_MODEL = process.env.OLLAMA_MODEL || "llama3.1";
+
+/**
+ * Register local AI tools on an MCP server instance.
+ *
+ * @param {import("@modelcontextprotocol/sdk/server/mcp.js").McpServer} server
+ * @param {import("zod").ZodType} z
+ */
+export function registerLocalAITools(server, z) {
+
+  // ─── ai_chat ──────────────────────────────────────────────
+  server.tool(
+    "ai_chat",
+    `Chat with your local Llama model. Zero cost, fully private.
+Supports multi-turn conversation, system prompts, and .brain file loading.
+
+Example: ai_chat({ message: "Explain MCP servers in simple terms" })
+Example: ai_chat({ message: "What is 0nMCP?", system: "You are a tech expert" })
+Example: ai_chat({ message: "Score this content", brain: "~/.0n/brains/sxo-writer.brain" })
+Example: ai_chat({ message: "Continue from before", history: [...previous messages...] })
+Example: ai_chat({ message: "Hello", model: "mistral" })`,
+    {
+      message: z.string().describe("Your message to the AI"),
+      system: z.string().optional().describe("System prompt (or use brain parameter)"),
+      brain: z.string().optional().describe("Path to .brain file to load as system prompt"),
+      model: z.string().optional().describe(`Model to use (default: ${DEFAULT_MODEL})`),
+      history: z.array(z.object({
+        role: z.enum(["user", "assistant", "system"]),
+        content: z.string(),
+      })).optional().describe("Previous conversation messages for context"),
+      temperature: z.number().optional().describe("Creativity (0-2, default: 0.7)"),
+      max_tokens: z.number().optional().describe("Max response length (default: 2048)"),
+    },
+    async ({ message, system, brain, model, history, temperature, max_tokens }) => {
+      try {
+        // Load brain file as system prompt if provided
+        let systemPrompt = system || "";
+        if (brain) {
+          const { readFileSync, existsSync } = await import("fs");
+          const { homedir } = await import("os");
+          const resolvedPath = brain.replace("~", homedir());
+          if (existsSync(resolvedPath)) {
+            const brainData = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+            systemPrompt = brainData.prompt || "";
+            if (!systemPrompt && brainData.identity) {
+              // Compile on the fly
+              const { compileBrainToPrompt } = await import("./brain.js").catch(() => ({}));
+              if (compileBrainToPrompt) systemPrompt = compileBrainToPrompt(brainData);
+            }
+          }
+        }
+
+        // Build messages
+        const messages = [];
+        if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
+        if (history) messages.push(...history);
+        messages.push({ role: "user", content: message });
+
+        const startTime = Date.now();
+        const res = await fetch(`${OLLAMA_BASE}/api/chat`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            model: model || DEFAULT_MODEL,
+            messages,
+            stream: false,
+            options: {
+              temperature: temperature ?? 0.7,
+              num_predict: max_tokens || 2048,
+            },
+          }),
+        });
+
+        if (!res.ok) {
+          const errText = await res.text();
+          throw new Error(`Ollama error ${res.status}: ${errText}`);
+        }
+
+        const data = await res.json();
+        const duration = Date.now() - startTime;
+        const response = data.message?.content || "";
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "ok",
+          model: data.model || model || DEFAULT_MODEL,
+          response,
+          stats: {
+            duration_ms: duration,
+            eval_count: data.eval_count,
+            eval_duration_ms: data.eval_duration ? Math.round(data.eval_duration / 1e6) : null,
+            tokens_per_second: data.eval_count && data.eval_duration
+              ? Math.round(data.eval_count / (data.eval_duration / 1e9) * 10) / 10
+              : null,
+            prompt_tokens: data.prompt_eval_count,
+            total_duration_ms: data.total_duration ? Math.round(data.total_duration / 1e6) : duration,
+          },
+          provider: "ollama-local",
+          cost: "$0.00",
+        }, null, 2) }] };
+      } catch (err) {
+        if (err.message?.includes("ECONNREFUSED")) {
+          return { content: [{ type: "text", text: JSON.stringify({
+            status: "offline",
+            error: "Ollama is not running. Start it with: ollama serve",
+            help: "Install: https://ollama.com | Pull a model: ollama pull llama3.1",
+          }) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── ai_generate ──────────────────────────────────────────
+  server.tool(
+    "ai_generate",
+    `One-shot text generation with local Llama. No conversation context.
+Good for: summarization, code generation, analysis, content creation.
+
+Example: ai_generate({ prompt: "Write a Python function to sort a list" })
+Example: ai_generate({ prompt: "Summarize this: ...", model: "llama3.1" })`,
+    {
+      prompt: z.string().describe("The prompt to generate from"),
+      model: z.string().optional().describe(`Model (default: ${DEFAULT_MODEL})`),
+      system: z.string().optional().describe("System prompt"),
+      temperature: z.number().optional().describe("Creativity (0-2, default: 0.7)"),
+      max_tokens: z.number().optional().describe("Max tokens (default: 2048)"),
+      format: z.enum(["text", "json"]).optional().describe("Response format"),
+    },
+    async ({ prompt, model, system, temperature, max_tokens, format }) => {
+      try {
+        const startTime = Date.now();
+        const body = {
+          model: model || DEFAULT_MODEL,
+          prompt,
+          stream: false,
+          options: {
+            temperature: temperature ?? 0.7,
+            num_predict: max_tokens || 2048,
+          },
+        };
+        if (system) body.system = system;
+        if (format === "json") body.format = "json";
+
+        const res = await fetch(`${OLLAMA_BASE}/api/generate`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body),
+        });
+
+        if (!res.ok) throw new Error(`Ollama error ${res.status}: ${await res.text()}`);
+
+        const data = await res.json();
+        const duration = Date.now() - startTime;
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "ok",
+          model: data.model || model || DEFAULT_MODEL,
+          response: data.response || "",
+          stats: {
+            duration_ms: duration,
+            eval_count: data.eval_count,
+            tokens_per_second: data.eval_count && data.eval_duration
+              ? Math.round(data.eval_count / (data.eval_duration / 1e9) * 10) / 10
+              : null,
+          },
+          cost: "$0.00",
+        }, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── ai_models ────────────────────────────────────────────
+  server.tool(
+    "ai_models",
+    `Manage local AI models. List installed, pull new ones, get model info.
+
+Example: ai_models({ action: "list" })
+Example: ai_models({ action: "pull", name: "mistral" })
+Example: ai_models({ action: "info", name: "llama3.1" })
+Example: ai_models({ action: "running" })`,
+    {
+      action: z.enum(["list", "pull", "info", "delete", "running"]).describe("Action to perform"),
+      name: z.string().optional().describe("Model name (for pull/info/delete)"),
+    },
+    async ({ action, name }) => {
+      try {
+        switch (action) {
+          case "list": {
+            const res = await fetch(`${OLLAMA_BASE}/api/tags`);
+            const data = await res.json();
+            const models = (data.models || []).map(m => ({
+              name: m.name,
+              size_gb: Math.round(m.size / 1e9 * 10) / 10,
+              modified: m.modified_at,
+              family: m.details?.family,
+              parameters: m.details?.parameter_size,
+              quantization: m.details?.quantization_level,
+            }));
+            return { content: [{ type: "text", text: JSON.stringify({
+              status: "ok", count: models.length, models,
+              message: models.length === 0
+                ? "No models installed. Pull one with: ai_models({ action: 'pull', name: 'llama3.1' })"
+                : `${models.length} model(s) installed locally.`,
+            }, null, 2) }] };
+          }
+
+          case "running": {
+            const res = await fetch(`${OLLAMA_BASE}/api/ps`);
+            const data = await res.json();
+            return { content: [{ type: "text", text: JSON.stringify({
+              status: "ok",
+              running: (data.models || []).map(m => ({
+                name: m.name, size_gb: Math.round(m.size / 1e9 * 10) / 10,
+                expires: m.expires_at,
+              })),
+            }, null, 2) }] };
+          }
+
+          case "info": {
+            if (!name) throw new Error("Model name required");
+            const res = await fetch(`${OLLAMA_BASE}/api/show`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ name }),
+            });
+            const data = await res.json();
+            return { content: [{ type: "text", text: JSON.stringify({
+              status: "ok", model: name,
+              details: data.details,
+              parameters: data.model_info,
+              template: data.template,
+              system: data.system?.substring(0, 200),
+              license: data.license?.substring(0, 200),
+            }, null, 2) }] };
+          }
+
+          case "pull": {
+            if (!name) throw new Error("Model name required");
+            const res = await fetch(`${OLLAMA_BASE}/api/pull`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ name, stream: false }),
+            });
+            const data = await res.json();
+            return { content: [{ type: "text", text: JSON.stringify({
+              status: data.status || "pulling",
+              model: name,
+              message: `Model "${name}" ${data.status || "pull initiated"}. This may take a while for large models.`,
+            }, null, 2) }] };
+          }
+
+          case "delete": {
+            if (!name) throw new Error("Model name required");
+            const res = await fetch(`${OLLAMA_BASE}/api/delete`, {
+              method: "DELETE",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ name }),
+            });
+            return { content: [{ type: "text", text: JSON.stringify({
+              status: res.ok ? "deleted" : "failed",
+              model: name,
+            }) }] };
+          }
+        }
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── ai_embed ─────────────────────────────────────────────
+  server.tool(
+    "ai_embed",
+    `Create text embeddings locally using Ollama. Free, private.
+Useful for: semantic search, similarity matching, RAG pipelines.
+
+Example: ai_embed({ text: "What is MCP?" })
+Example: ai_embed({ text: ["Hello world", "Hi there"], model: "llama3.1" })`,
+    {
+      text: z.union([z.string(), z.array(z.string())]).describe("Text(s) to embed"),
+      model: z.string().optional().describe(`Model (default: ${DEFAULT_MODEL})`),
+    },
+    async ({ text, model }) => {
+      try {
+        const input = Array.isArray(text) ? text : [text];
+        const res = await fetch(`${OLLAMA_BASE}/api/embed`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ model: model || DEFAULT_MODEL, input }),
+        });
+        if (!res.ok) throw new Error(`Ollama error ${res.status}`);
+        const data = await res.json();
+
+        return { content: [{ type: "text", text: JSON.stringify({
+          status: "ok",
+          model: data.model || model || DEFAULT_MODEL,
+          count: (data.embeddings || []).length,
+          dimensions: data.embeddings?.[0]?.length || 0,
+          embeddings: (data.embeddings || []).map((e, i) => ({
+            text: input[i]?.substring(0, 50) + (input[i]?.length > 50 ? "..." : ""),
+            vector_preview: e.slice(0, 5),
+            dimensions: e.length,
+          })),
+          cost: "$0.00",
+        }, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: JSON.stringify({ status: "failed", error: err.message }) }] };
+      }
+    }
+  );
+
+  // ─── ai_bench ─────────────────────────────────────────────
+  server.tool(
+    "ai_bench",
+    `Benchmark a prompt across local Llama AND cloud models side by side.
+Compare speed, quality, and cost. Cloud calls use real API keys (cost money).
+
+Example: ai_bench({ prompt: "Explain quantum computing in one paragraph" })
+Example: ai_bench({ prompt: "Write a haiku about AI", providers: ["local", "anthropic"] })`,
+    {
+      prompt: z.string().describe("Prompt to benchmark"),
+      system: z.string().optional().describe("System prompt"),
+      providers: z.array(z.enum(["local", "anthropic", "openai", "gemini"])).optional()
+        .describe("Providers to test (default: [local]). WARNING: cloud providers cost money."),
+    },
+    async ({ prompt, system, providers }) => {
+      const targets = providers || ["local"];
+      const results = [];
+
+      for (const provider of targets) {
+        const start = Date.now();
+        let response = "";
+        let tokens = 0;
+        let cost = "$0.00";
+        let error = null;
+
+        try {
+          if (provider === "local") {
+            const body = { model: DEFAULT_MODEL, prompt, stream: false, options: { temperature: 0.7, num_predict: 512 } };
+            if (system) body.system = system;
+            const res = await fetch(`${OLLAMA_BASE}/api/generate`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(body),
+            });
+            const data = await res.json();
+            response = data.response || "";
+            tokens = data.eval_count || 0;
+          }
+
+          else if (provider === "anthropic") {
+            if (!process.env.ANTHROPIC_API_KEY) throw new Error("No ANTHROPIC_API_KEY");
+            const { default: Anthropic } = await import("@anthropic-ai/sdk");
+            const client = new Anthropic();
+            const msg = await client.messages.create({
+              model: "claude-sonnet-4-20250514",
+              max_tokens: 512,
+              system: system || undefined,
+              messages: [{ role: "user", content: prompt }],
+            });
+            response = msg.content[0]?.text || "";
+            tokens = (msg.usage?.input_tokens || 0) + (msg.usage?.output_tokens || 0);
+            cost = `~$${(tokens * 0.000003).toFixed(4)}`;
+          }
+
+          else if (provider === "openai") {
+            if (!process.env.OPENAI_API_KEY) throw new Error("No OPENAI_API_KEY");
+            const messages = [];
+            if (system) messages.push({ role: "system", content: system });
+            messages.push({ role: "user", content: prompt });
+            const res = await fetch("https://api.openai.com/v1/chat/completions", {
+              method: "POST",
+              headers: { "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`, "Content-Type": "application/json" },
+              body: JSON.stringify({ model: "gpt-4o", messages, max_tokens: 512 }),
+            });
+            const data = await res.json();
+            response = data.choices?.[0]?.message?.content || "";
+            tokens = (data.usage?.total_tokens || 0);
+            cost = `~$${(tokens * 0.000005).toFixed(4)}`;
+          }
+
+          else if (provider === "gemini") {
+            if (!process.env.GEMINI_API_KEY) throw new Error("No GEMINI_API_KEY");
+            const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=${process.env.GEMINI_API_KEY}`;
+            const body = { contents: [{ parts: [{ text: prompt }] }], generationConfig: { maxOutputTokens: 512 } };
+            if (system) body.system_instruction = { parts: [{ text: system }] };
+            const res = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+            const data = await res.json();
+            response = data.candidates?.[0]?.content?.parts?.[0]?.text || "";
+            tokens = data.usageMetadata?.totalTokenCount || 0;
+            cost = `~$${(tokens * 0.0000001).toFixed(6)}`;
+          }
+        } catch (e) {
+          error = e.message;
+        }
+
+        const duration = Date.now() - start;
+        results.push({
+          provider,
+          model: provider === "local" ? DEFAULT_MODEL : provider === "anthropic" ? "claude-sonnet" : provider === "openai" ? "gpt-4o" : "gemini-2.0-flash",
+          response: response.substring(0, 300) + (response.length > 300 ? "..." : ""),
+          response_length: response.length,
+          duration_ms: duration,
+          tokens,
+          tokens_per_second: tokens > 0 && duration > 0 ? Math.round(tokens / (duration / 1000)) : null,
+          cost,
+          error,
+        });
+      }
+
+      return { content: [{ type: "text", text: JSON.stringify({
+        status: "ok",
+        prompt: prompt.substring(0, 100),
+        results,
+        fastest: results.filter(r => !r.error).sort((a, b) => a.duration_ms - b.duration_ms)[0]?.provider || "none",
+        cheapest: results.filter(r => !r.error).sort((a, b) => parseFloat(a.cost.replace(/[^0-9.]/g, "")) - parseFloat(b.cost.replace(/[^0-9.]/g, "")))[0]?.provider || "local",
+      }, null, 2) }] };
+    }
+  );
+}

package/index.js

@@ -32,6 +32,8 @@ import { registerContainerTools } from "./vault/tools-container.js";
 import { registerDeedTools } from "./vault/tools-deed.js";
 import { unsealedCache } from "./vault/cache.js";
 import { registerEngineTools, registerTrainingTools, registerFeedTools, registerCouncilTools, registerSxoWriterTools } from "./engine/index.js";
+import { registerBrainTools } from "./engine/brain.js";
+import { registerLocalAITools } from "./engine/local-ai.js";
 import { CapabilityProxy } from "./capability-proxy.js";
 import { SERVICE_CATALOG } from "./catalog.js";
 
@@ -86,6 +88,8 @@ registerTrainingTools(server, z);
 registerFeedTools(server, z);
 registerCouncilTools(server, z);
 registerSxoWriterTools(server, z);
+registerBrainTools(server, z);
+registerLocalAITools(server, z);
 
 // ============================================================
 // VAULT CONTAINER TOOLS (patent-pending 0nVault containers)

package/lib/stats.json

@@ -1,5 +1,5 @@
 {
-  "generated": "2026-03-27T00:44:46.383Z",
+  "generated": "2026-03-28T15:35:11.316Z",
   "catalogVersion": "2.2.0",
   "services": 48,
   "tools": 545,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "0nmcp",
-  "version": "2.8.0",
+  "version": "2.9.1",
   "mcpName": "io.github.0nork/0nMCP",
   "description": "Universal AI API Orchestrator — 819 tools, 48 services, portable AI Brain bundles + machine-bound vault encryption + Application Engine. The most comprehensive MCP server available. Free and open source from 0nORK.",
   "type": "module",
@@ -282,6 +282,6 @@
     "triggers": 155,
     "totalCapabilities": 1078,
     "categories": 21,
-    "lastUpdated": "2026-03-27T00:44:46.383Z"
+    "lastUpdated": "2026-03-28T15:35:11.316Z"
   }
 }

package/tools.js

@@ -7,6 +7,7 @@
 
 import { z } from "zod";
 import { SERVICE_CATALOG, listServices, getService } from "./catalog.js";
+import { registerRedditTools } from "./reddit.js";
 
 /**
  * Register all universal + workflow tools on an MCP server instance.
@@ -383,4 +384,7 @@ Examples:
       }
     );
   }
+
+  // ─── Reddit ────────────────────────────────────────────
+  registerRedditTools(server, z, connections);
 }