@rixter145/open-brain 1.0.0

package/README.md

@@ -0,0 +1,204 @@
+# Open Brain – MCP server
+
+One shared memory layer for Cursor, Claude, and any MCP client: thoughts stored in **Postgres + pgvector**, exposed via an **MCP server** with semantic search and capture.
+
+- **Capture**: Save thoughts from any client; each is embedded (OpenAI `text-embedding-3-small`) and stored.
+- **Retrieve**: Semantic search by meaning, list recent thoughts, or view stats.
+- **Same brain everywhere**: One Postgres DB and one MCP server; point Cursor, Claude Desktop, and other clients at it.
+
+## Prerequisites
+
+- **Node.js** 18+
+- **Postgres** 15+ with the **pgvector** extension (e.g. [Supabase](https://supabase.com) free tier, or self‑hosted).
+- **OpenAI API key** (for embeddings), **Google AI Studio API key** (see [Using Google AI Studio](#using-google-ai-studio)), or **Ollama** for free local embeddings (see [Using Ollama](#using-ollama-free-embeddings) below).
+
+## Finish setup on this machine
+
+1. **Build** (in a terminal where Node/npm are available):
+   ```powershell
+   cd "c:\Users\rix\OneDrive\open-brain"
+   npm install
+   npm run build
+   ```
+2. **Env**: Edit `.env` in the project root and set `DATABASE_URL` and your embedding provider key (`OPENAI_API_KEY`, `GOOGLE_API_KEY`, or use `EMBEDDING_PROVIDER=ollama`).
+3. **Database**: If you don’t have a DB yet, follow [Database setup](#1-database-setup) below (Supabase free tier is the easiest). Then run [schema.sql](schema.sql) once.
+4. **Client**: Add the Open Brain MCP server in your MCP client (see [Connect clients](#3-connect-clients) below), then reload.
+
+---
+
+## Using Ollama (free embeddings)
+
+To avoid paying for OpenAI, you can use **Ollama** with **nomic-embed-text** (runs locally, no API key).
+
+1. **Install Ollama** from [ollama.com](https://ollama.com) and start it.
+2. **Pull the embedding model:**  
+   `ollama pull nomic-embed-text`
+3. **In `.env`:** set `EMBEDDING_PROVIDER=ollama`. Optionally set `OLLAMA_HOST=http://localhost:11434` if Ollama runs elsewhere. You do **not** need `OPENAI_API_KEY`.
+4. **Database:** The Ollama model uses **768 dimensions** (not 1536). If you already have a `thoughts` table from the OpenAI schema, drop it and re-run the Ollama schema:  
+   In Supabase SQL Editor, run `DROP TABLE IF EXISTS thoughts;` then paste and run the contents of [schema-ollama.sql](schema-ollama.sql).
+5. **Cursor MCP:** In the Open Brain server env, include `EMBEDDING_PROVIDER=ollama` (and optionally `OLLAMA_HOST`). No `OPENAI_API_KEY` needed.
+6. Restart Cursor (or reload the window).
+
+After that, capture and search use your local Ollama embeddings. You cannot mix OpenAI (1536) and Ollama (768) in the same table.
+
+---
+
+## Using Google AI Studio
+
+To use **Google AI Studio (Gemini)** for embeddings instead of OpenAI:
+
+1. **Get an API key** at [Google AI Studio](https://aistudio.google.com/app/apikey). Sign in, create or select a project, and create an API key.
+2. **In `.env`:** set `EMBEDDING_PROVIDER=google` and `GOOGLE_API_KEY=your-key`. You do **not** need `OPENAI_API_KEY`.
+3. **Database:** Google embeddings use **768 dimensions** (same as Ollama). Use the same schema: if you don’t already have a 768-dim table, run [schema-ollama.sql](schema-ollama.sql) (or run `DROP TABLE IF EXISTS thoughts;` then the contents of schema-ollama.sql).
+4. **Cursor MCP:** In the Open Brain server env, include `EMBEDDING_PROVIDER=google` and `GOOGLE_API_KEY`. No `OPENAI_API_KEY` needed.
+5. Restart Cursor (or reload the window).
+
+You cannot mix different embedding dimensions in the same table (OpenAI 1536 vs Ollama/Google 768).
+
+---
+
+## 1. Database setup
+
+Open Brain needs **Postgres 15+** with the **pgvector** extension. The easiest way is [Supabase](https://supabase.com) (free tier, pgvector included).
+
+### Option A: Supabase (recommended, free)
+
+1. **Create an account**  
+   Go to [supabase.com](https://supabase.com) and sign up (GitHub or email).
+
+2. **Create a project**  
+   - Click **New project**.  
+   - Choose your **organization** (or create one).  
+   - Set **Name** (e.g. `open-brain`), **Database password** (save it somewhere safe), and **Region**.  
+   - Click **Create new project** and wait until it’s ready.
+
+3. **Get the connection string**  
+   - In the left sidebar: **Project Settings** (gear) → **Database**.  
+   - Under **Connection string** choose **URI**.  
+   - Copy the URI. It looks like:  
+     `postgresql://postgres.[ref]:[YOUR-PASSWORD]@aws-0-[region].pooler.supabase.com:6543/postgres`  
+   - Replace `[YOUR-PASSWORD]` with the database password you set in step 2.  
+   - **If your password has special characters** (`@`, `#`, `/`, `%`, etc.), they must be URL-encoded in the URI. Run:  
+     `node scripts/encode-password.mjs "YourPassword"`  
+     and use the output in place of the password in the URL.  
+   - Put this full URI in your `.env` as `DATABASE_URL`.
+
+4. **Run the schema**  
+   - In the left sidebar: **SQL Editor**.  
+   - Click **New query**.  
+   - Open [schema.sql](schema.sql) in this repo, copy its **entire** contents, paste into the editor, and click **Run** (or Ctrl+Enter).  
+   - You should see “Success. No rows returned.” The `thoughts` table and vector index are now created.
+
+5. **Use the same `DATABASE_URL`** in your `.env` and in Cursor’s MCP config for the Open Brain server.
+
+### Option B: Other Postgres (with pgvector)
+
+If you use another host (e.g. Neon, Railway, or your own server):
+
+- Ensure **pgvector** is enabled (run `CREATE EXTENSION IF NOT EXISTS vector;` if needed).
+- Connection string format: `postgresql://USER:PASSWORD@HOST:PORT/DATABASE`.
+- Run the contents of [schema.sql](schema.sql) once (e.g. via `psql $DATABASE_URL -f schema.sql` or your host’s SQL runner).
+
+## 2. Install and run the MCP server
+
+```bash
+cd open-brain
+npm install
+npm run build
+```
+
+Set environment variables (or use a `.env` file with something like `dotenv` if you add it):
+
+- **`DATABASE_URL`** – Postgres connection string (e.g. `postgresql://user:pass@host:5432/dbname`).
+- **`OPENAI_API_KEY`** – OpenAI API key for embeddings (default provider).
+- **`GOOGLE_API_KEY`** – Google AI Studio API key when `EMBEDDING_PROVIDER=google` (get one at [Google AI Studio](https://aistudio.google.com/app/apikey)).
+- **`EMBEDDING_PROVIDER`** – Optional. Set to `ollama`, `google`, or `gemini` to use that provider instead of OpenAI.
+
+Run the server (stdio; clients will start it as a subprocess):
+
+```bash
+npm start
+# or for development: npm run dev
+```
+
+## 3. Connect clients
+
+Any MCP client (Cursor, Claude Desktop, etc.) can connect to Open Brain. Add a server entry that runs the built server and passes the required env.
+
+**Server entry shape:** `command`: `"node"`, `args`: path to `dist/index.js` (absolute path, or relative to the workspace if your client uses this repo as the working directory). Include `env` with `DATABASE_URL` and your embedding provider key (`OPENAI_API_KEY`, or `GOOGLE_API_KEY` + `EMBEDDING_PROVIDER=google`, or use Ollama and set `EMBEDDING_PROVIDER=ollama`).
+
+Example (replace the path and env values with your own):
+
+```json
+{
+  "mcpServers": {
+    "open-brain": {
+      "command": "node",
+      "args": ["/path/to/open_brain/dist/index.js"],
+      "env": {
+        "DATABASE_URL": "postgresql://user:password@host:5432/database",
+        "GOOGLE_API_KEY": "your-key",
+        "EMBEDDING_PROVIDER": "google"
+      }
+    }
+  }
+}
+```
+
+- **Cursor:** Settings → MCP, or project-level `.cursor/mcp.json` (see your client’s docs for config location).
+- **Claude Desktop:** e.g. `%APPDATA%\\Claude\\claude_desktop_config.json` on Windows.
+- **Abacus AI Deep Agent:** [MCP Servers How-to](https://abacus.ai/help/chatllm-ai-super-assistant/mcp-servers) — use the npx config below in MCP JSON Config.
+
+**Using npx (Abacus AI or any stdio client):** Paste this in your client's MCP config (Abacus: only the inner object; Cursor/Claude: nest under `mcpServers`). The package is published as `@rixter145/open-brain`; run `npm publish --access=public` from the repo after `npm login`.
+
+```json
+{
+  "open_brain": {
+    "command": "npx",
+    "args": ["-y", "@rixter145/open-brain"],
+    "env": {
+      "DATABASE_URL": "postgresql://user:password@host:5432/database",
+      "OPENAI_API_KEY": "your-key"
+    }
+  }
+}
+```
+
+For Google or Ollama embeddings, add `EMBEDDING_PROVIDER` and the matching key to `env` (see sections above).
+
+Restart the client after changing the config.
+
+## MCP tools
+
+| Tool | Purpose |
+|------|--------|
+| **capture_thought** | Save a thought (content + optional source). It is embedded and stored. |
+| **search_brain** | Semantic search by meaning (e.g. “career change”, “meeting with Sarah”). |
+| **list_recent** | List recent thoughts (optional: last N days). |
+| **brain_stats** | Count of thoughts and activity in the last 7 and 30 days. |
+
+All tools return plain text (and optional metadata) so any model can interpret the results.
+
+## Embedding model
+
+By default the server uses **OpenAI `text-embedding-3-small`** (1536 dimensions). If `EMBEDDING_PROVIDER=ollama` (or `OPENAI_API_KEY` is unset and `OLLAMA_HOST` is set), it uses **Ollama `nomic-embed-text`** (768 dimensions). If `EMBEDDING_PROVIDER=google` or `gemini`, it uses **Google Gemini text-embedding** (768 dimensions via `outputDimensionality`). Use the matching schema: [schema.sql](schema.sql) for OpenAI (1536 dims), [schema-ollama.sql](schema-ollama.sql) for Ollama or Google (768 dims). Do not change the embedding model without re-embedding existing rows.
+
+## Project layout
+
+- `schema.sql` – Postgres + pgvector schema for OpenAI (1536 dims). `schema-ollama.sql` for Ollama (768 dims).
+- `src/index.ts` – MCP server and tool handlers.
+- `src/db.ts` – Postgres + pgvector access (insert, search, list, stats).
+- `src/embeddings.ts` – Embedding calls (OpenAI, Google Gemini, or Ollama, env-driven).
+
+## Publishing to npm
+
+The package is scoped as `@rixter145/open-brain` (npm rejects unscoped `open-brain` as too similar to existing `openbrain`). To publish so clients can use `npx @rixter145/open-brain` (e.g. Abacus AI):
+
+1. Log in: `npm login` (username, password, email, OTP if 2FA enabled).
+2. From the repo root: `npm publish --access=public`.
+
+The `prepublishOnly` script builds before publish; the package includes only `dist/`.
+
+## Optional: metadata extraction
+
+The plan mentioned optional metadata (people, topics, type, action items) via an LLM call. The current schema and table support these columns; the server currently only stores `content`, `embedding`, and `source`. You can extend `capture_thought` to call an LLM, parse the response, and fill `people`, `topics`, `type`, and `action_items` in `insertThought`.

package/dist/db.d.ts

@@ -0,0 +1,28 @@
+export interface ThoughtRow {
+    id: string;
+    content: string;
+    embedding: number[];
+    people: string[];
+    topics: string[];
+    type: string | null;
+    action_items: string[];
+    source: string | null;
+    created_at: Date;
+}
+export declare function insertThought(params: {
+    content: string;
+    embedding: number[];
+    people?: string[];
+    topics?: string[];
+    type?: string | null;
+    action_items?: string[];
+    source?: string | null;
+}): Promise<ThoughtRow>;
+export declare function searchThoughts(queryEmbedding: number[], limit?: number): Promise<ThoughtRow[]>;
+export declare function listRecentThoughts(limit?: number, days?: number): Promise<ThoughtRow[]>;
+export declare function getBrainStats(): Promise<{
+    total: number;
+    last_7_days: number;
+    last_30_days: number;
+}>;
+export declare function formatThoughtForOutput(t: ThoughtRow): string;

package/dist/db.js

@@ -0,0 +1,131 @@
+import pg from "pg";
+import pgvector from "pgvector/pg";
+let pool = null;
+function getPool() {
+    const url = process.env.DATABASE_URL;
+    if (!url)
+        throw new Error("DATABASE_URL is required");
+    if (!pool) {
+        pool = new pg.Pool({ connectionString: url, max: 5 });
+    }
+    return pool;
+}
+export async function insertThought(params) {
+    const client = await getPool().connect();
+    try {
+        pgvector.registerTypes(client);
+        const embeddingSql = pgvector.toSql(params.embedding);
+        const res = await client.query(`INSERT INTO thoughts (content, embedding, people, topics, type, action_items, source)
+       VALUES ($1, $2::vector, $3::text[], $4::text[], $5, $6::text[], $7)
+       RETURNING id, content, embedding::text, people, topics, type, action_items, source, created_at`, [
+            params.content,
+            embeddingSql,
+            params.people ?? [],
+            params.topics ?? [],
+            params.type ?? null,
+            params.action_items ?? [],
+            params.source ?? null,
+        ]);
+        const row = res.rows[0];
+        if (!row)
+            throw new Error("Insert failed");
+        return parseThoughtRow(row);
+    }
+    finally {
+        client.release();
+    }
+}
+function parseThoughtRow(row) {
+    let vec = [];
+    const e = row.embedding;
+    if (Array.isArray(e))
+        vec = e;
+    else if (typeof e === "string")
+        vec = e.startsWith("[") ? JSON.parse(e) : parsePgVector(e);
+    return {
+        id: row.id,
+        content: row.content,
+        embedding: vec,
+        people: row.people ?? [],
+        topics: row.topics ?? [],
+        type: row.type ?? null,
+        action_items: row.action_items ?? [],
+        source: row.source ?? null,
+        created_at: new Date(row.created_at),
+    };
+}
+function parsePgVector(s) {
+    if (typeof s !== "string")
+        return [];
+    const trimmed = s.replace(/^\[|\]$/g, "").trim();
+    if (!trimmed)
+        return [];
+    return trimmed.split(",").map((n) => parseFloat(n.trim()));
+}
+export async function searchThoughts(queryEmbedding, limit = 10) {
+    const client = await getPool().connect();
+    try {
+        const embeddingSql = pgvector.toSql(queryEmbedding);
+        const res = await client.query(`SELECT id, content, embedding::text, people, topics, type, action_items, source, created_at
+       FROM thoughts
+       ORDER BY embedding <=> $1::vector
+       LIMIT $2`, [embeddingSql, limit]);
+        return res.rows.map(parseThoughtRow);
+    }
+    finally {
+        client.release();
+    }
+}
+export async function listRecentThoughts(limit = 20, days) {
+    const client = await getPool().connect();
+    try {
+        if (days != null) {
+            const res = await client.query(`SELECT id, content, embedding::text, people, topics, type, action_items, source, created_at
+         FROM thoughts
+         WHERE created_at >= now() - ($2::text || ' days')::interval
+         ORDER BY created_at DESC
+         LIMIT $1`, [limit, days]);
+            return res.rows.map(parseThoughtRow);
+        }
+        const res = await client.query(`SELECT id, content, embedding::text, people, topics, type, action_items, source, created_at
+       FROM thoughts
+       ORDER BY created_at DESC
+       LIMIT $1`, [limit]);
+        return res.rows.map(parseThoughtRow);
+    }
+    finally {
+        client.release();
+    }
+}
+export async function getBrainStats() {
+    const client = await getPool().connect();
+    try {
+        const res = await client.query(`SELECT
+         count(*)::text AS total,
+         count(*) FILTER (WHERE created_at >= now() - interval '7 days')::text AS last_7,
+         count(*) FILTER (WHERE created_at >= now() - interval '30 days')::text AS last_30
+       FROM thoughts`);
+        const row = res.rows[0];
+        return {
+            total: parseInt(row?.total ?? "0", 10),
+            last_7_days: parseInt(row?.last_7 ?? "0", 10),
+            last_30_days: parseInt(row?.last_30 ?? "0", 10),
+        };
+    }
+    finally {
+        client.release();
+    }
+}
+export function formatThoughtForOutput(t) {
+    const meta = [];
+    if (t.people?.length)
+        meta.push(`People: ${t.people.join(", ")}`);
+    if (t.topics?.length)
+        meta.push(`Topics: ${t.topics.join(", ")}`);
+    if (t.type)
+        meta.push(`Type: ${t.type}`);
+    if (t.action_items?.length)
+        meta.push(`Action items: ${t.action_items.join("; ")}`);
+    const metaLine = meta.length ? `[${meta.join(" | ")}]\n` : "";
+    return `${metaLine}${t.content}\n— ${t.created_at.toISOString().slice(0, 10)}${t.source ? ` (${t.source})` : ""}`;
+}

package/dist/embeddings.d.ts

@@ -0,0 +1,2 @@
+export declare function embed(text: string): Promise<number[]>;
+export declare const EMBEDDING_DIMS: number;

package/dist/embeddings.js

@@ -0,0 +1,95 @@
+import { GoogleGenAI } from "@google/genai";
+import OpenAI from "openai";
+const OPENAI_MODEL = "text-embedding-3-small";
+const OPENAI_DIMS = 1536;
+const OLLAMA_MODEL = "nomic-embed-text";
+const OLLAMA_DIMS = 768;
+const GOOGLE_MODEL = "gemini-embedding-001";
+const GOOGLE_DIMS = 768;
+let openaiClient = null;
+let googleClient = null;
+function useGoogle() {
+    const p = process.env.EMBEDDING_PROVIDER;
+    return p === "google" || p === "gemini";
+}
+function useOllama() {
+    if (process.env.EMBEDDING_PROVIDER === "ollama")
+        return true;
+    if (!useGoogle() && !process.env.OPENAI_API_KEY?.trim() && process.env.OLLAMA_HOST?.trim())
+        return true;
+    return false;
+}
+function getOpenAIClient() {
+    const key = process.env.OPENAI_API_KEY;
+    if (!key)
+        throw new Error("OPENAI_API_KEY is required for embeddings");
+    if (!openaiClient)
+        openaiClient = new OpenAI({ apiKey: key });
+    return openaiClient;
+}
+function getGoogleClient() {
+    const key = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
+    if (!key?.trim())
+        throw new Error("GOOGLE_API_KEY or GEMINI_API_KEY is required when EMBEDDING_PROVIDER=google");
+    if (!googleClient)
+        googleClient = new GoogleGenAI({ apiKey: key });
+    return googleClient;
+}
+async function embedGoogle(text) {
+    const ai = getGoogleClient();
+    const response = await ai.models.embedContent({
+        model: GOOGLE_MODEL,
+        contents: text.slice(0, 8192),
+        config: { outputDimensionality: GOOGLE_DIMS },
+    });
+    const vec = response.embeddings?.[0]?.values;
+    if (!vec || !Array.isArray(vec) || vec.length !== GOOGLE_DIMS) {
+        throw new Error(`Invalid Google embedding response (expected ${GOOGLE_DIMS} dimensions)`);
+    }
+    return vec;
+}
+async function embedOllama(text) {
+    const base = (process.env.OLLAMA_HOST || "http://localhost:11434").replace(/\/$/, "");
+    const res = await fetch(`${base}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ model: OLLAMA_MODEL, input: text.slice(0, 8192) }),
+    });
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`Ollama embeddings failed: ${res.status} ${err}`);
+    }
+    const data = (await res.json());
+    const vec = data.embeddings?.[0];
+    if (!vec || !Array.isArray(vec) || vec.length !== OLLAMA_DIMS) {
+        throw new Error(`Invalid Ollama embedding response (expected ${OLLAMA_DIMS} dimensions)`);
+    }
+    return vec;
+}
+async function embedOpenAI(text) {
+    const openai = getOpenAIClient();
+    const res = await openai.embeddings.create({
+        model: OPENAI_MODEL,
+        input: text.slice(0, 8191),
+        dimensions: OPENAI_DIMS,
+    });
+    const vec = res.data[0]?.embedding;
+    if (!vec || vec.length !== OPENAI_DIMS)
+        throw new Error("Invalid embedding response");
+    return vec;
+}
+export async function embed(text) {
+    if (useGoogle())
+        return embedGoogle(text);
+    if (useOllama())
+        return embedOllama(text);
+    return embedOpenAI(text);
+}
+function getEmbeddingDims() {
+    if (useGoogle())
+        return GOOGLE_DIMS;
+    if (useOllama())
+        return OLLAMA_DIMS;
+    return OPENAI_DIMS;
+}
+export const EMBEDDING_DIMS = getEmbeddingDims();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/dist/index.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { embed } from "./embeddings.js";
+import { insertThought, searchThoughts, listRecentThoughts, getBrainStats, formatThoughtForOutput, } from "./db.js";
+const server = new McpServer({
+    name: "open-brain",
+    version: "1.0.0",
+});
+// capture_thought: add a thought (content + optional source); embed and store in Postgres
+server.registerTool("capture_thought", {
+    title: "Capture thought",
+    description: "Save a thought into your Open Brain. The content is embedded and stored so it can be found by semantic search later. Optional: set source (e.g. 'cursor', 'claude', 'slack').",
+    inputSchema: z.object({
+        content: z.string().describe("The thought or note to save"),
+        source: z.string().optional().describe("Where this thought came from (e.g. cursor, claude)"),
+    }),
+}, async ({ content, source }) => {
+    try {
+        const vector = await embed(content);
+        const row = await insertThought({
+            content,
+            embedding: vector,
+            source: source ?? null,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Captured thought (id: ${row.id}). You can find it later with search_brain or list_recent.`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Error: ${msg}` }],
+            isError: true,
+        };
+    }
+});
+// search_brain: semantic search by meaning
+server.registerTool("search_brain", {
+    title: "Search brain",
+    description: "Search your Open Brain by meaning. Give a natural language query (e.g. 'career change', 'meeting with Sarah'); returns the most relevant thoughts.",
+    inputSchema: z.object({
+        query: z.string().describe("What to search for (by meaning)"),
+        limit: z.number().min(1).max(50).optional().default(10),
+    }),
+}, async ({ query, limit }) => {
+    try {
+        const queryVector = await embed(query);
+        const thoughts = await searchThoughts(queryVector, limit);
+        const text = thoughts.length === 0
+            ? "No matching thoughts found."
+            : thoughts.map(formatThoughtForOutput).join("\n\n---\n\n");
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Error: ${msg}` }],
+            isError: true,
+        };
+    }
+});
+// list_recent: list recent thoughts (optionally filter by days)
+server.registerTool("list_recent", {
+    title: "List recent thoughts",
+    description: "List thoughts you captured recently. Optionally limit to the last N days (e.g. 7 for this week).",
+    inputSchema: z.object({
+        limit: z.number().min(1).max(100).optional().default(20),
+        days: z.number().min(1).optional().describe("Only show thoughts from the last N days"),
+    }),
+}, async ({ limit, days }) => {
+    try {
+        const thoughts = await listRecentThoughts(limit, days);
+        const text = thoughts.length === 0
+            ? "No thoughts in this range."
+            : thoughts.map(formatThoughtForOutput).join("\n\n---\n\n");
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Error: ${msg}` }],
+            isError: true,
+        };
+    }
+});
+// brain_stats: counts and activity
+server.registerTool("brain_stats", {
+    title: "Brain stats",
+    description: "See how many thoughts are in your Open Brain and recent activity (last 7 and 30 days).",
+    inputSchema: z.object({}),
+}, async () => {
+    try {
+        const stats = await getBrainStats();
+        const text = `Total thoughts: ${stats.total}\nLast 7 days: ${stats.last_7_days}\nLast 30 days: ${stats.last_30_days}`;
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Error: ${msg}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error("Open Brain MCP server error:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@rixter145/open-brain",
+  "version": "1.0.0",
+  "description": "MCP server for Open Brain: Postgres + pgvector shared memory for Cursor, Claude, and any MCP client",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "open-brain": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test:env": "node scripts/test-env.mjs",
+    "init-db": "node scripts/init-db.mjs"
+  },
+  "keywords": [
+    "mcp",
+    "open-brain",
+    "pgvector",
+    "embeddings"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@google/genai": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "dotenv": "^16.4.5",
+    "openai": "^4.77.0",
+    "pg": "^8.13.0",
+    "pgvector": "^0.2.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/pg": "^8.18.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}