@cognivia/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Manik Maurya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# @cognivia/mcp
+
+A Model Context Protocol server that gives any AI agent Cognivia's learning
+diagnostics as tools: `diagnose_error`, `get_memory_state`, `generate_report`.
+
+```jsonc
+{ "mcpServers": { "cognivia": {
+  "command": "npx", "args": ["-y", "@cognivia/mcp"],
+  "env": { "COGNIVIA_API_KEY": "sk_live_..." } } } }
+```
+
+With a key it proxies to the hosted API; otherwise it computes locally.
+
+MIT · Manik Maurya

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@cognivia/mcp",
+  "version": "0.1.0",
+  "description": "Model Context Protocol server for Cognivia. Gives any AI agent learning diagnostics (error type, memory state, session report) as callable tools.",
+  "type": "module",
+  "bin": { "cognivia-mcp": "server.mjs" },
+  "main": "server.mjs",
+  "files": ["server.mjs", "README.md", "LICENSE"],
+  "keywords": ["cognivia", "mcp", "model-context-protocol", "learning", "diagnostics", "ai-agents"],
+  "homepage": "https://cognivia-platform.vercel.app/intelligence",
+  "repository": { "type": "git", "url": "git+https://github.com/Manik-Maurya/cognivia-platform.git", "directory": "packages/mcp" },
+  "engines": { "node": ">=18" },
+  "dependencies": { "@cognivia/core": "^0.1.0" },
+  "publishConfig": { "access": "public" },
+  "license": "MIT",
+  "author": "Manik Maurya"
+}

package/server.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+// @cognivia/mcp - a Model Context Protocol server that gives any AI agent
+// Cognivia's learning diagnostics as tools. Zero dependencies: newline-delimited
+// JSON-RPC 2.0 over stdio, which every MCP client speaks.
+//
+// Tools:
+//   diagnose_error(subject, question, answer, correct, latencyMs, confidence)
+//   get_memory_state(attempts[])
+//   generate_report(attempts[])
+//
+// All computed by @cognivia/core - the same engine behind the site, console, CLI.
+//
+// Client config (Claude Desktop / any MCP client):
+//   { "mcpServers": { "cognivia": { "command": "node", "args": ["server.mjs"] } } }
+
+import * as core from "@cognivia/core";
+import * as client from "@cognivia/core/client";
+import { createInterface } from "node:readline";
+
+const send = (msg) => process.stdout.write(JSON.stringify(msg) + "\n");
+const ok = (id, result) => send({ jsonrpc: "2.0", id, result });
+const err = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
+
+const TOOLS = [
+  {
+    name: "diagnose_error",
+    description: "Diagnose one answered item: the error type, memory state, and next review, each grounded in memory science.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        subject: { type: "string" }, question: { type: "string" }, answer: { type: "string" },
+        correct: { type: "boolean" }, latencyMs: { type: "number" },
+        confidence: { type: "number", description: "1-5 (or 0-100)" },
+      },
+      required: ["correct"],
+    },
+  },
+  {
+    name: "get_memory_state",
+    description: "Compute the Learning Genome and per-item memory state for a set of attempts from any learning or quiz app.",
+    inputSchema: { type: "object", properties: { attempts: { type: "array" } }, required: ["attempts"] },
+  },
+  {
+    name: "generate_report",
+    description: "Build a full Cognivia Session Report (Learning Genome, per-item diagnosis, recommendation) from a set of attempts.",
+    inputSchema: { type: "object", properties: { attempts: { type: "array" } }, required: ["attempts"] },
+  },
+];
+
+function textResult(obj, text) {
+  return { content: [{ type: "text", text: text || JSON.stringify(obj, null, 2) }], structuredContent: obj };
+}
+
+async function callTool(name, a = {}) {
+  // When COGNIVIA_API_KEY is set, prefer the hosted /v1 API; else compute locally.
+  const remote = client.hasKey();
+  if (name === "diagnose_error") {
+    if (remote) { try { return textResult(await client.diagnoseRemote(a)); } catch (e) { /* fall back */ } }
+    const tag = core.classify(!!a.correct, a.confidence);
+    return textResult({
+      errorType: tag.code, label: tag.label,
+      memoryState: core.memoryState(a), diagnosis: core.diagnosis(a),
+      nextReview: core.reviewFor(tag, a.confidence),
+    });
+  }
+  if (name === "get_memory_state") {
+    const atts = a.attempts || [];
+    return textResult({
+      genome: core.computeGenome(atts),
+      items: atts.map((x, i) => ({ n: i + 1, subject: x.subject || x.topic, memoryState: core.memoryState(x), diagnosis: core.diagnosis(x) })),
+    });
+  }
+  if (name === "generate_report") {
+    if (remote) { try { const rep = await client.reportRemote(a.attempts || []); return textResult(rep, core.renderText(rep)); } catch (e) { /* fall back */ } }
+    const rep = core.buildReport(a.attempts || [], { idPrefix: "CGV-MCP" });
+    return textResult(rep, core.renderText(rep));
+  }
+  throw new Error("unknown tool: " + name);
+}
+
+const rl = createInterface({ input: process.stdin });
+rl.on("line", async (line) => {
+  const s = line.trim();
+  if (!s) return;
+  let msg;
+  try { msg = JSON.parse(s); } catch { return; }
+  const { id, method, params } = msg;
+  try {
+    if (method === "initialize") {
+      ok(id, {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "cognivia", version: "0.1.0" },
+      });
+    } else if (method === "tools/list") {
+      ok(id, { tools: TOOLS });
+    } else if (method === "tools/call") {
+      const { name, arguments: a } = params || {};
+      ok(id, await callTool(name, a || {}));
+    } else if (method === "ping") {
+      ok(id, {});
+    } else if (id !== undefined) {
+      err(id, -32601, "Method not found: " + method);
+    }
+  } catch (e) {
+    if (id !== undefined) err(id, -32000, e.message);
+  }
+});