openbrain-mcp 0.1.0

package/dist/embeddings.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Multi-provider embedding abstraction.
+ * Supports Gemini (free tier, default) and OpenAI.
+ */
+export interface EmbeddingProvider {
+    name: string;
+    dimensions: number;
+    embed(text: string): Promise<number[]>;
+}
+export declare class GeminiProvider implements EmbeddingProvider {
+    private apiKey;
+    name: string;
+    dimensions: number;
+    constructor(apiKey: string);
+    embed(text: string): Promise<number[]>;
+}
+export declare class OpenAIProvider implements EmbeddingProvider {
+    private apiKey;
+    name: string;
+    dimensions: number;
+    constructor(apiKey: string);
+    embed(text: string): Promise<number[]>;
+}
+export declare function createProvider(provider: string, config: Record<string, string>): EmbeddingProvider;

package/dist/embeddings.js

@@ -0,0 +1,67 @@
+/**
+ * Multi-provider embedding abstraction.
+ * Supports Gemini (free tier, default) and OpenAI.
+ */
+export class GeminiProvider {
+    apiKey;
+    name = "gemini";
+    dimensions = 1536;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        if (!apiKey)
+            throw new Error("Gemini API key required. Run 'npx openbrain-ai setup' to configure.");
+    }
+    async embed(text) {
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent?key=${this.apiKey}`;
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                content: { parts: [{ text }] },
+                outputDimensionality: this.dimensions,
+            }),
+        });
+        const data = await resp.json();
+        if (data.error)
+            throw new Error(`Gemini embedding error: ${data.error.message}`);
+        return data.embedding.values;
+    }
+}
+export class OpenAIProvider {
+    apiKey;
+    name = "openai";
+    dimensions = 1536;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+        if (!apiKey)
+            throw new Error("OpenAI API key required. Run 'npx openbrain-ai setup' to configure.");
+    }
+    async embed(text) {
+        const resp = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: "text-embedding-3-small",
+                input: text,
+                dimensions: this.dimensions,
+            }),
+        });
+        const data = await resp.json();
+        if (data.error)
+            throw new Error(`OpenAI embedding error: ${data.error.message}`);
+        return data.data[0].embedding;
+    }
+}
+export function createProvider(provider, config) {
+    switch (provider) {
+        case "gemini":
+            return new GeminiProvider(config.geminiApiKey || config.GEMINI_API_KEY || "");
+        case "openai":
+            return new OpenAIProvider(config.openaiApiKey || config.OPENAI_API_KEY || "");
+        default:
+            throw new Error(`Unknown embedding provider: ${provider}. Use "gemini" or "openai".`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * OpenBrain MCP Server
+ * Gives any MCP-compatible AI tool access to your shared memory brain.
+ *
+ * Tools: store_memory, search_memories, list_memories, delete_memory, brain_stats
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+/**
+ * OpenBrain MCP Server
+ * Gives any MCP-compatible AI tool access to your shared memory brain.
+ *
+ * Tools: store_memory, search_memories, list_memories, delete_memory, brain_stats
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { SupabaseClient } from "./supabase.js";
+import { createProvider } from "./embeddings.js";
+function loadConfig() {
+    const configPath = resolve(homedir(), ".openbrain", "config.json");
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        // Fall back to environment variables
+        return {
+            supabaseUrl: process.env.OPENBRAIN_SUPABASE_URL || "",
+            supabaseKey: process.env.OPENBRAIN_SUPABASE_KEY || "",
+            embeddingProvider: process.env.OPENBRAIN_EMBEDDING_PROVIDER || "gemini",
+            geminiApiKey: process.env.GEMINI_API_KEY || "",
+            openaiApiKey: process.env.OPENAI_API_KEY || "",
+        };
+    }
+}
+const config = loadConfig();
+if (!config.supabaseUrl || !config.supabaseKey) {
+    console.error("OpenBrain: Missing config. Run 'npx openbrain-ai setup' or set environment variables.");
+    console.error("  Config file: ~/.openbrain/config.json");
+    console.error("  Or env vars: OPENBRAIN_SUPABASE_URL, OPENBRAIN_SUPABASE_KEY");
+    process.exit(1);
+}
+const db = new SupabaseClient(config.supabaseUrl, config.supabaseKey);
+const embedder = createProvider(config.embeddingProvider || "gemini", config);
+// --- Valid categories ---
+const VALID_CATEGORIES = [
+    "company",
+    "contact",
+    "interaction",
+    "decision",
+    "insight",
+    "task",
+    "preference",
+    "project",
+];
+// --- Tool Implementations ---
+async function storeMemory(args) {
+    const embedding = await embedder.embed(args.content);
+    const record = {
+        content: args.content,
+        source: args.source || "mcp",
+        category: args.category || "insight",
+        tags: args.tags || [],
+        embedding,
+        summary: args.summary || null,
+        metadata: {},
+    };
+    return db.request("POST", "memories", record);
+}
+async function searchMemories(args) {
+    const embedding = await embedder.embed(args.query);
+    const params = {
+        query_embedding: embedding,
+        match_threshold: args.threshold ?? 0.5,
+        match_count: args.limit ?? 5,
+    };
+    if (args.source)
+        params.filter_source = args.source;
+    if (args.category)
+        params.filter_category = args.category;
+    return db.rpc("search_memories", params);
+}
+async function listMemories(args) {
+    const limit = args.limit ?? 20;
+    let path = `memories?order=created_at.desc&limit=${limit}&select=id,content,summary,source,category,tags,created_at`;
+    if (args.source)
+        path += `&source=eq.${args.source}`;
+    return db.request("GET", path);
+}
+async function deleteMemory(args) {
+    await db.request("DELETE", `memories?id=eq.${args.id}`);
+}
+async function updateMemory(args) {
+    const record = {};
+    if (args.content) {
+        record.content = args.content;
+        record.embedding = await embedder.embed(args.content);
+    }
+    if (args.category)
+        record.category = args.category;
+    if (args.tags)
+        record.tags = args.tags;
+    if (args.summary)
+        record.summary = args.summary;
+    return db.request("PATCH", `memories?id=eq.${args.id}`, record);
+}
+async function getStats() {
+    return db.rpc("brain_stats", {});
+}
+// --- MCP Server ---
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf-8"));
+const server = new Server({ name: "openbrain", version: packageJson.version }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "store_memory",
+            description: "Store a memory in the shared brain. Use this to save important information, decisions, preferences, or insights that should be accessible across all AI tools.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    content: {
+                        type: "string",
+                        description: "The memory content to store",
+                    },
+                    source: {
+                        type: "string",
+                        description: "Which AI tool is storing this (e.g. claude, chatgpt, cursor)",
+                        default: "mcp",
+                    },
+                    category: {
+                        type: "string",
+                        enum: [...VALID_CATEGORIES],
+                        description: "Category of memory",
+                        default: "insight",
+                    },
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Tags for filtering",
+                        default: [],
+                    },
+                    summary: {
+                        type: "string",
+                        description: "Optional short summary",
+                    },
+                },
+                required: ["content"],
+            },
+        },
+        {
+            name: "search_memories",
+            description: "Search the shared brain for memories by meaning. Returns semantically similar results even if exact words don't match.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "What to search for (natural language)",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results",
+                        default: 5,
+                    },
+                    source: {
+                        type: "string",
+                        description: "Filter by source",
+                    },
+                    category: {
+                        type: "string",
+                        description: "Filter by category",
+                    },
+                    threshold: {
+                        type: "number",
+                        description: "Similarity threshold 0-1",
+                        default: 0.5,
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "list_memories",
+            description: "List recent memories from the shared brain.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    limit: {
+                        type: "number",
+                        description: "Max results",
+                        default: 20,
+                    },
+                    source: {
+                        type: "string",
+                        description: "Filter by source",
+                    },
+                },
+            },
+        },
+        {
+            name: "delete_memory",
+            description: "Delete a memory by its ID.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: {
+                        type: "string",
+                        description: "UUID of the memory to delete",
+                    },
+                },
+                required: ["id"],
+            },
+        },
+        {
+            name: "brain_stats",
+            description: "Show statistics about the shared brain: total memories, breakdown by source and category.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "update_memory",
+            description: "Update an existing memory by ID. Re-generates embedding if content is changed.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: {
+                        type: "string",
+                        description: "UUID of the memory to update",
+                    },
+                    content: {
+                        type: "string",
+                        description: "New content (triggers embedding regeneration)",
+                    },
+                    category: {
+                        type: "string",
+                        enum: [...VALID_CATEGORIES],
+                        description: "New category",
+                    },
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "New tags",
+                    },
+                    summary: {
+                        type: "string",
+                        description: "New summary",
+                    },
+                },
+                required: ["id"],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "store_memory": {
+                const result = await storeMemory(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Memory stored. ID: ${result[0]?.id || "unknown"}`,
+                        },
+                    ],
+                };
+            }
+            case "search_memories": {
+                const results = await searchMemories(args);
+                if (!results.length) {
+                    return {
+                        content: [{ type: "text", text: "No matching memories found." }],
+                    };
+                }
+                const output = results
+                    .map((r) => {
+                    const sim = ((r.similarity || 0) * 100).toFixed(1);
+                    const date = r.created_at?.slice(0, 10) || "?";
+                    const tags = r.tags?.join(", ") || "";
+                    return `[${sim}%] [${date}] [${r.source}/${r.category}] ${tags}\n${r.content}`;
+                })
+                    .join("\n\n---\n\n");
+                return { content: [{ type: "text", text: output }] };
+            }
+            case "list_memories": {
+                const results = await listMemories(args);
+                const output = results
+                    .map((r) => {
+                    const date = r.created_at?.slice(0, 10) || "?";
+                    const summary = r.summary || r.content?.slice(0, 100);
+                    return `[${date}] [${r.source}/${r.category}] ${summary}`;
+                })
+                    .join("\n");
+                return {
+                    content: [{ type: "text", text: output || "No memories found." }],
+                };
+            }
+            case "delete_memory": {
+                await deleteMemory(args);
+                return {
+                    content: [{ type: "text", text: `Memory deleted: ${args.id}` }],
+                };
+            }
+            case "update_memory": {
+                const updateArgs = args;
+                if (!updateArgs.content && !updateArgs.category && !updateArgs.tags && !updateArgs.summary) {
+                    return {
+                        content: [{ type: "text", text: "Nothing to update. Provide at least one of: content, category, tags, summary." }],
+                        isError: true,
+                    };
+                }
+                await updateMemory(updateArgs);
+                return {
+                    content: [{ type: "text", text: `Memory updated: ${updateArgs.id}` }],
+                };
+            }
+            case "brain_stats": {
+                const stats = await getStats();
+                let text = `Total memories: ${stats.total}\n\nBy source:\n`;
+                for (const [s, c] of Object.entries(stats.by_source).sort((a, b) => b[1] - a[1])) {
+                    text += `  ${s}: ${c}\n`;
+                }
+                text += `\nBy category:\n`;
+                for (const [s, c] of Object.entries(stats.by_category).sort((a, b) => b[1] - a[1])) {
+                    text += `  ${s}: ${c}\n`;
+                }
+                return { content: [{ type: "text", text }] };
+            }
+            default:
+                return {
+                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/supabase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Supabase client wrapper for OpenBrain.
+ * Handles REST API calls and RPC function invocations.
+ */
+export declare class SupabaseClient {
+    private url;
+    private key;
+    constructor(url: string, key: string);
+    private get headers();
+    request<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;
+    rpc<T = unknown>(fn: string, params: Record<string, unknown>): Promise<T>;
+}

package/dist/supabase.js

@@ -0,0 +1,49 @@
+/**
+ * Supabase client wrapper for OpenBrain.
+ * Handles REST API calls and RPC function invocations.
+ */
+export class SupabaseClient {
+    url;
+    key;
+    constructor(url, key) {
+        this.url = url;
+        this.key = key;
+        if (!url)
+            throw new Error("Supabase URL required");
+        if (!key)
+            throw new Error("Supabase key required");
+    }
+    get headers() {
+        return {
+            apikey: this.key,
+            Authorization: `Bearer ${this.key}`,
+            "Content-Type": "application/json",
+            Prefer: "return=representation",
+        };
+    }
+    async request(method, path, body) {
+        const url = `${this.url}/rest/v1/${path}`;
+        const opts = { method, headers: this.headers };
+        if (body)
+            opts.body = JSON.stringify(body);
+        const resp = await fetch(url, opts);
+        if (!resp.ok) {
+            const error = await resp.text();
+            throw new Error(`Supabase ${method} ${path} failed (${resp.status}): ${error}`);
+        }
+        return resp.json();
+    }
+    async rpc(fn, params) {
+        const url = `${this.url}/rest/v1/rpc/${fn}`;
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(params),
+        });
+        if (!resp.ok) {
+            const error = await resp.text();
+            throw new Error(`Supabase RPC ${fn} failed (${resp.status}): ${error}`);
+        }
+        return resp.json();
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "openbrain-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for OpenBrain - cross-AI memory system",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "openbrain-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^20.0.0"
+  },
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/matpcoelho/openbrain"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "ai",
+    "memory",
+    "embeddings",
+    "supabase",
+    "claude",
+    "chatgpt"
+  ]
+}