@abderraouf-yt/got-mcp 3.2.1 → 4.0.0

package/README.md

@@ -13,16 +13,14 @@
   <a href="https://github.com/Abderraouf-yt/got-mcp"><img src="https://img.shields.io/github/stars/Abderraouf-yt/got-mcp?style=flat-square&color=ff00ff&label=stars" alt="GitHub stars" /></a>
   <a href="#"><img src="https://img.shields.io/badge/node-%3E%3D20-00e5ff?style=flat-square" alt="Node.js" /></a>
   <a href="#"><img src="https://img.shields.io/badge/MCP-1.26+-ff00ff?style=flat-square" alt="MCP SDK" /></a>
-  <a href="#"><img src="https://img.shields.io/badge/tools-10-00ff88?style=flat-square" alt="Tools" /></a>
+  <a href="#"><img src="https://img.shields.io/badge/tools-15-00ff88?style=flat-square" alt="Tools" /></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-yellow?style=flat-square" alt="License" /></a>
-  <a href="https://got-mcp-visualizer.netlify.app"><img src="https://img.shields.io/badge/demo-live-00e5ff?style=flat-square&logo=netlify" alt="Live Demo" /></a>
   <a href="https://arxiv.org/abs/2308.09687"><img src="https://img.shields.io/badge/GoT-Besta%20et%20al.%202023-ff6b6b?style=flat-square" alt="GoT Paper" /></a>
 </p>
 
 <p align="center">
   <a href="#-quick-start">⚡ Quick Start</a> •
-  <a href="https://got-mcp-visualizer.netlify.app">� Live Demo</a> •
-  <a href="#-tools-10">🛠 Tools</a> •
+  <a href="#-tools-15">🛠 Tools</a> •
   <a href="#-how-it-thinks">🧬 How It Thinks</a> •
   <a href="#-governance">🔒 Governance</a> •
   <a href="#-visualizer">📊 Visualizer</a>
@@ -152,7 +150,7 @@ The demo state ships with the repo in `docs/assets/demo-state.json`.
 
 ---
 
-## 🛠 Tools (10)
+## 🛠 Tools (15)
 
 <table>
 <tr><th>Tool</th><th>What it does</th><th>Category</th></tr>
@@ -166,11 +164,16 @@ The demo state ships with the repo in `docs/assets/demo-state.json`.
 <tr><td><code>get_graph_metrics</code></td><td>Node count, max depth, prune ratio, avg score, status breakdown</td><td>📊 Ops</td></tr>
 <tr><td><code>export_snapshot</code></td><td>Full graph serialization for replay/recovery</td><td>🔁 Replay</td></tr>
 <tr><td><code>restore_snapshot</code></td><td>Restore from previously exported snapshot</td><td>🔁 Replay</td></tr>
+<tr><td><code>reflect_and_refine</code></td><td>Self-reflection: 4-axis confidence + auto-critique + branch</td><td>🔬 v4.0</td></tr>
+<tr><td><code>context_set</code></td><td>Write key-value to shared context store with provenance</td><td>📦 v4.0</td></tr>
+<tr><td><code>context_get</code></td><td>Read value + source from shared context store</td><td>📦 v4.0</td></tr>
+<tr><td><code>context_list</code></td><td>List all context store entries and their sources</td><td>📦 v4.0</td></tr>
+<tr><td><code>export_reasoning_trace</code></td><td>Export winning path as Long CoT trace (DeepSeek-R1/o3 format)</td><td>📤 v4.0</td></tr>
 </table>
 
 ### Edge Relations
 
-`refinement` · `contradiction` · `support` · `branch` · `aggregation`
+`refinement` · `contradiction` · `support` · `branch` · `aggregation` · `reflection`
 
 ### Node Statuses
 
@@ -313,7 +316,9 @@ Based on [Besta et al., 2023 — "Graph of Thoughts"](https://arxiv.org/abs/2308
 | **Converge** | `find_winning_path` — beam search | v3.0 |
 | **Governance** | Engine-level guards + session isolation | v3.0 |
 | **Replay** | `export_snapshot` / `restore_snapshot` | v3.0 |
-| Volume Control | Roadmap | — |
+| **Self-Reflect** | `reflect_and_refine` — 4-axis confidence | v4.0 |
+| **Context Store** | `context_set` / `context_get` / `context_list` | v4.0 |
+| **Reasoning Trace** | `export_reasoning_trace` — Long CoT export | v4.0 |
 | Controller Loop | Roadmap | — |
 
 ---
@@ -338,13 +343,17 @@ thought-graph/
 ├── src/
 │   ├── index.ts              # Bootstrap (Stdio + HTTP)
 │   ├── server/
-│   │   ├── mcp.ts            # 10 MCP tool registrations
-│   │   └── http.ts           # Express bridge + SSE
+│   │   ├── mcp.ts            # 15 MCP tool registrations
+│   │   └── http.ts           # Express bridge (minimal inline CORS)
 │   ├── graph/
 │   │   ├── ThoughtGraph.ts   # Core DAG engine + governance
 │   │   └── index.ts          # Session registry exports
-│   └── types.ts              # GraphLimits, SessionContext, GraphMetrics
-├── visualizer/               # React + Vite dashboard
+│   ├── context/
+│   │   ├── ContextStore.ts   # Shared context store (CA-MCP)
+│   │   └── index.ts          # Context singleton export
+│   └── types.ts              # GraphLimits, ConfidenceVector, ReasoningTrace
+├── visualizer/               # React + Vite dashboard (local only)
+├── evaluations/              # XML evaluation framework
 ├── tests/                    # Unit tests
 ├── docs/assets/              # Demo screenshots & state
 └── dist/                     # Compiled output

package/dist/graph/ThoughtGraph.js

@@ -796,6 +796,194 @@ export class ThoughtGraph {
             exportedAt: new Date().toISOString(),
         };
     }
+    // ==========================================
+    // v4.0: CONTROLLER LOOP — Autonomous GoT Cycle
+    // ==========================================
+    /**
+     * Controller Loop: Autonomous Graph of Thoughts reasoning cycle.
+     *
+     * Orchestrates the full GoT pipeline on a given prompt:
+     *   1. GENERATE — propose initial thoughts from the prompt
+     *   2. EVALUATE — score each active leaf using confidence vectors
+     *   3. BRANCH — create alternatives for mid-scoring thoughts
+     *   4. REFLECT — auto-critique top candidates via reflectAndRefine
+     *   5. PRUNE — remove branches below autoPruneBelow threshold
+     *   6. CONVERGE — find the winning path via beam search
+     *
+     * Governance:
+     *   - maxIterations caps the number of generate→evaluate→prune cycles
+     *   - convergenceThreshold stops early when the best path score exceeds it
+     *   - autoPruneBelow automatically soft-prunes low-scoring branches
+     *   - All existing graph limits (node cap, depth cap, etc.) still apply
+     *
+     * @param prompt - The reasoning question or problem statement
+     * @param thoughts - Array of initial thought branches to explore
+     * @param options - Controller loop configuration
+     * @returns The final winning path, reasoning trace, and iteration metrics
+     */
+    runControllerLoop(prompt, thoughts, options) {
+        const maxIterations = options?.maxIterations ?? 5;
+        const convergenceThreshold = options?.convergenceThreshold ?? 0.85;
+        const autoPruneBelow = options?.autoPruneBelow ?? 0.3;
+        const beamWidth = options?.beamWidth ?? 2;
+        const iterationLog = [];
+        // Step 1: GENERATE — seed the graph with the prompt + initial thoughts
+        const rootId = this.addNode(prompt);
+        this.updateNode(rootId, { score: 0.5, status: "active" });
+        for (const thought of thoughts) {
+            const childId = this.addNode(thought);
+            this.addEdge(rootId, childId, "branch");
+            this.updateNode(childId, { score: 0.5, status: "active" });
+        }
+        let converged = false;
+        let iteration = 0;
+        // Step 2-6: Iterate until convergence or budget exhausted
+        while (iteration < maxIterations && !converged) {
+            iteration++;
+            // --- EVALUATE: score all active leaf nodes ---
+            const activeLeaves = this.getActiveLeaves();
+            let scored = 0;
+            let pruned = 0;
+            let branched = 0;
+            let reflected = 0;
+            for (const leaf of activeLeaves) {
+                // Auto-score based on thought quality heuristics:
+                // - Length factor: longer = more detailed (diminishing returns)
+                // - Depth factor: deeper = more refined thinking
+                // - Specificity: presence of numbers, comparisons, evidence markers
+                const depth = this.getNodeDepth(leaf.id);
+                const lengthScore = Math.min(leaf.thought.length / 500, 1.0);
+                const depthBonus = Math.min(depth * 0.05, 0.2);
+                const specificity = this.estimateSpecificity(leaf.thought);
+                const autoScore = Math.min(Math.round((lengthScore * 0.3 + depthBonus + specificity * 0.5) * 100) / 100, 1.0);
+                this.updateNode(leaf.id, {
+                    score: autoScore,
+                    status: autoScore >= convergenceThreshold ? "validated" : "active",
+                });
+                scored++;
+            }
+            // --- PRUNE: remove low-scoring branches ---
+            const lowScorers = Array.from(this.nodes.values())
+                .filter(n => n.status === "active" && n.score < autoPruneBelow && n.score > 0);
+            for (const weak of lowScorers) {
+                try {
+                    const result = this.pruneFromNode(weak.id, `Auto-pruned: score ${weak.score} < ${autoPruneBelow}`, {
+                        mode: "soft",
+                        decayFactor: 0.3,
+                        trigger: "auto",
+                    });
+                    pruned += result.pruned.length;
+                }
+                catch {
+                    // Skip if prune fails (e.g. cascade limit)
+                }
+            }
+            // --- BRANCH: create alternatives for mid-tier thoughts ---
+            const midTier = Array.from(this.nodes.values())
+                .filter(n => n.status === "active" && n.score >= autoPruneBelow && n.score < convergenceThreshold);
+            for (const mid of midTier.slice(0, 3)) { // Limit branching to top 3
+                const existingChildren = this.edges.filter(e => e.from === mid.id).length;
+                if (existingChildren < this.limits.maxBranchFactor && this.nodes.size < this.limits.maxNodes - 5) {
+                    try {
+                        const altId = this.addNode(`[Alternative] What if we reconsider: ${mid.thought.substring(0, 200)}...`);
+                        this.addEdge(mid.id, altId, "branch");
+                        this.updateNode(altId, { score: 0.5, status: "active" });
+                        branched++;
+                    }
+                    catch {
+                        // Skip if limits hit
+                    }
+                }
+            }
+            // --- REFLECT: critique the best candidates ---
+            const topCandidates = Array.from(this.nodes.values())
+                .filter(n => n.status !== "rejected" && n.score >= 0.5)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, 2);
+            for (const top of topCandidates) {
+                try {
+                    const confidence = {
+                        factual: Math.min(top.score + 0.1, 1),
+                        logical: Math.min(top.score + 0.05, 1),
+                        relevance: Math.min(top.score + 0.15, 1),
+                        novelty: Math.max(top.score - 0.1, 0),
+                    };
+                    this.reflectAndRefine(top.id, `Iteration ${iteration} auto-reflection: evaluating strength of reasoning.`, confidence);
+                    reflected++;
+                }
+                catch {
+                    // Skip if reflection fails
+                }
+            }
+            // --- CONVERGE CHECK ---
+            const winningPath = this.findWinningPath({ beamWidth, scoreThreshold: autoPruneBelow });
+            const avgPathScore = winningPath.path.length > 0
+                ? winningPath.totalScore / winningPath.path.length
+                : 0;
+            iterationLog.push({
+                iteration,
+                nodesScored: scored,
+                nodesPruned: pruned,
+                nodesBranched: branched,
+                nodesReflected: reflected,
+                totalNodes: this.nodes.size,
+                bestPathScore: Math.round(avgPathScore * 100) / 100,
+                converged: avgPathScore >= convergenceThreshold,
+            });
+            if (avgPathScore >= convergenceThreshold) {
+                converged = true;
+            }
+        }
+        // Final convergence
+        const finalPath = this.findWinningPath({ beamWidth, scoreThreshold: 0 });
+        const trace = this.exportReasoningTrace();
+        const metrics = this.getMetrics();
+        this.stateVersion++;
+        this.save();
+        return {
+            converged,
+            iterations: iteration,
+            winningPath: {
+                pathIds: finalPath.pathIds,
+                totalScore: finalPath.totalScore,
+                conclusion: finalPath.path.length > 0
+                    ? finalPath.path[finalPath.path.length - 1].thought
+                    : "No conclusion reached",
+            },
+            trace,
+            metrics,
+            iterationLog,
+        };
+    }
+    /**
+     * Get active leaf nodes (nodes with no outgoing edges that aren't rejected).
+     */
+    getActiveLeaves() {
+        const nodesWithOutgoing = new Set(this.edges.map(e => e.from));
+        return Array.from(this.nodes.values())
+            .filter(n => !nodesWithOutgoing.has(n.id) && n.status !== "rejected");
+    }
+    /**
+     * Estimate the specificity of a thought based on content heuristics.
+     * Higher specificity = more concrete, evidence-based reasoning.
+     */
+    estimateSpecificity(thought) {
+        let score = 0.3; // Base score
+        // Indicators of specific, evidence-based thinking
+        if (/\d+/.test(thought))
+            score += 0.1; // Contains numbers
+        if (/vs\.?|versus|compared|better|worse/i.test(thought))
+            score += 0.1; // Comparisons
+        if (/because|since|therefore|thus|hence/i.test(thought))
+            score += 0.1; // Causal reasoning
+        if (/however|but|although|despite/i.test(thought))
+            score += 0.1; // Nuance
+        if (/example|specifically|for instance/i.test(thought))
+            score += 0.1; // Concreteness
+        if (/\b(data|evidence|research|study|benchmark)\b/i.test(thought))
+            score += 0.1; // Evidence
+        return Math.min(score, 1.0);
+    }
 }
 // ==========================================
 // SESSION REGISTRY (replaces singleton)

package/dist/server/http.js

@@ -1,5 +1,4 @@
 import express from "express";
-import cors from "cors";
 import net from "net";
 import crypto from "crypto";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
@@ -43,15 +42,13 @@ async function findAvailablePort(startPort) {
 export async function startHttpServer() {
     const port = await findAvailablePort(PREFERRED_PORT);
     const app = express();
-    // Allow both the default Vite dev port and any localhost origin for flexibility
-    app.use(cors({
-        origin: [
-            'http://localhost:5173',
-            'http://localhost:5174',
-            'http://127.0.0.1:5173',
-            'http://127.0.0.1:5174',
-        ]
-    }));
+    // Minimal localhost-only CORS (no external dependency needed)
+    app.use((_req, res, next) => {
+        res.header("Access-Control-Allow-Origin", "http://localhost:5173");
+        res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.header("Access-Control-Allow-Headers", "Content-Type");
+        next();
+    });
     app.use(express.json());
     const activeSessions = new Map();
     app.get("/sse", async (req, res) => {

package/dist/server/mcp.js

@@ -473,5 +473,44 @@ export function createServerInstance() {
             return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
+    // ==========================================
+    // v4.0: Controller Loop — Autonomous GoT Orchestrator
+    // ==========================================
+    server.registerTool("run_controller_loop", {
+        description: "Autonomous GoT Controller Loop: Seeds a graph with a prompt + initial thoughts, then iteratively evaluates, branches, reflects, prunes, and converges until a winning path emerges or the iteration budget is exhausted. Returns the winning conclusion, full reasoning trace, and per-iteration metrics.",
+        inputSchema: {
+            prompt: z.string().min(1).max(5000).describe("The reasoning question or problem statement"),
+            thoughts: z.array(z.string().min(1).max(5000)).min(1).max(10).describe("Initial thought branches to explore (1-10)"),
+            maxIterations: z.number().int().min(1).max(20).default(5).describe("Maximum reasoning cycles (default: 5)"),
+            convergenceThreshold: z.number().min(0).max(1).default(0.85).describe("Stop when best path average score exceeds this (default: 0.85)"),
+            autoPruneBelow: z.number().min(0).max(1).default(0.3).describe("Auto soft-prune branches scoring below this (default: 0.3)"),
+            beamWidth: z.number().int().min(1).max(10).default(2).describe("Number of top paths to track during convergence (default: 2)"),
+        },
+        annotations: { destructiveHint: true }
+    }, async ({ prompt, thoughts, maxIterations, convergenceThreshold, autoPruneBelow, beamWidth }) => {
+        try {
+            const result = graph.runControllerLoop(prompt, thoughts, {
+                maxIterations,
+                convergenceThreshold,
+                autoPruneBelow,
+                beamWidth,
+            });
+            notifyUpdate();
+            const summary = [
+                `Controller Loop ${result.converged ? "CONVERGED" : "EXHAUSTED"} after ${result.iterations} iterations.`,
+                `Winning path: ${result.winningPath.pathIds.join(" → ")} (score: ${result.winningPath.totalScore})`,
+                `Conclusion: "${result.winningPath.conclusion.substring(0, 200)}"`,
+                `Graph: ${result.metrics.nodeCount} nodes, ${result.metrics.edgeCount} edges`,
+                `Prune ratio: ${Math.round(result.metrics.pruneRatio * 100)}%`,
+            ].join("\n");
+            return {
+                content: [{ type: "text", text: summary }],
+                structuredContent: result,
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
     return server;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abderraouf-yt/got-mcp",
-  "version": "3.2.1",
+  "version": "4.0.0",
   "description": "Graph of Thoughts (GoT) MCP Server — bounded, auditable reasoning for AI agents",
   "main": "dist/index.js",
   "bin": {
@@ -48,12 +48,10 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "cors": "^2.8.5",
     "express": "^4.21.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/node": "^20.19.30",
     "typescript": "^5.9.3"