mnemos-capture 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sofía Padrón Valdez
+
+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,90 @@
+# Mnemos
+
+**Stop saving things you'll never apply.**
+
+Mnemos is a knowledge capture tool for builders who use AI agents. Paste any resource — article, thread, transcript, notes — and an LLM extracts the insight, tags where it applies, and stores it in a GitHub repo you own. Your AI tools (Claude Code, or any MCP-compatible agent) can then pull from that repo directly.
+
+Every capture has an **"Applied to"** field — a concrete connection between what you learned and what you're building. Knowledge doesn't sit in a saved-for-later graveyard. It feeds your workflows.
+
+## Get started
+
+### 1. Sign up (30 seconds)
+
+Go to **[mnemos-capture.vercel.app](https://mnemos-capture.vercel.app)** → **Sign in with GitHub**.
+
+During setup, Mnemos:
+- Creates a knowledge repo in your GitHub account (you own it, it's just Markdown files)
+- Asks for your Anthropic API key (your key, stored in the database — Mnemos never pays for your API calls)
+- Sets a PIN for quick mobile access
+
+No config files. No CLI setup. No cloning repos.
+
+### 2. Capture something
+
+Open the app on any device (phone, tablet, desktop), paste content, hit **Capture**. That's it.
+
+**What the LLM extracts from each capture:**
+- **Core idea** — the actual insight, not a summary
+- **Key takeaways** — specific, opinionated, actionable
+- **Quotes** — only genuinely quotable lines
+- **Mode tags** — where this applies (career, work, founder, life)
+- **Applied to** — one sentence connecting this to something you're building right now
+
+The result is auto-committed to your GitHub knowledge repo as a Markdown file.
+
+### 3. Connect to Claude Code (optional)
+
+After signing up, you get an API key. This lets you connect Mnemos to Claude Code so your agent can capture and search knowledge without leaving the terminal.
+
+Run this once in your terminal:
+
+```bash
+claude mcp add mnemos -- npx mnemos-capture serve-mcp --key <your-api-key>
+```
+
+This installs a small bridge that connects Claude Code to the hosted Mnemos app. Now you can say things like:
+- *"Capture this article about prompt caching"*
+- *"What's in my inbox?"*
+- *"Search my captures for evaluation frameworks"*
+
+> **What's happening under the hood:** `npx mnemos-capture serve-mcp` runs a lightweight local process that translates between Claude Code's stdio protocol and the Mnemos HTTP API. Your API key authenticates the requests. No data is stored locally — everything goes to your GitHub repo via the hosted app.
+
+## How it works
+
+```
+You find something valuable
+        ↓
+Open Mnemos → paste it → hit Capture
+        ↓
+LLM extracts: core idea · takeaways · quotes · context tags · applied to
+        ↓
+Structured Markdown committed to your GitHub knowledge repo
+        ↓
+Your AI tools pull from it via MCP or by reading the repo directly
+```
+
+## Mobile access
+
+Mnemos is a PWA (Progressive Web App). On your phone: open the app URL in Safari or Chrome → Share → **Add to Home Screen**. It looks and feels like a native app — instant capture from anywhere.
+
+## Why GitHub as storage?
+
+Your knowledge lives in a repo you own. No proprietary database, no vendor lock-in. It's version-controlled, portable, and readable as plain Markdown. Clone it, search it with `grep`, back it up — it's just files. And because it's a standard Git repo, any MCP-compatible agent or tool can read from it.
+
+## Tech stack
+
+Next.js · TypeScript (strict) · Anthropic SDK · GitHub OAuth · Vercel Postgres (Neon) · GitHub API · MCP protocol · Tailwind CSS
+
+## Roadmap
+
+- [ ] Multi-provider support (OpenAI, Google — schema is ready, extraction code needs updating)
+- [ ] Batch capture (multiple resources at once)
+- [ ] URL auto-fetch (paste a link, Mnemos fetches the content)
+- [ ] Full-text search across knowledge hub
+- [ ] Browser extension for one-click capture
+- [ ] Settings page (change API key, repo, regenerate MCP key)
+- [ ] Team knowledge hubs (shared captures)
+
+## License
+
+[MIT](LICENSE)

package/dist/cli/index.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+const HOSTED_URL = "https://mnemos-capture.vercel.app";
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (command === "help" || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "serve-mcp") {
+        // MCP server mode — proxies to hosted instance
+        const { serveMcp } = await import("./mcp-server.js");
+        await serveMcp();
+        return;
+    }
+    // Default: open the hosted app
+    console.log("");
+    console.log("  Mnemos — Knowledge capture for agentic workflows\n");
+    console.log(`  Open ${HOSTED_URL} to start capturing.`);
+    console.log("");
+    console.log("  First time? Sign in with GitHub — setup takes 30 seconds.");
+    console.log("");
+    console.log("  Connect to Claude Code:");
+    console.log("  claude mcp add mnemos -- npx mnemos-capture serve-mcp --key YOUR_API_KEY");
+    console.log("");
+    // Try to open the URL in the default browser
+    const { exec } = await import("child_process");
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    exec(`${openCmd} ${HOSTED_URL}`);
+}
+function printHelp() {
+    console.log(`
+  Mnemos — Knowledge capture for agentic workflows
+
+  Usage:
+    npx mnemos-capture              Open Mnemos in your browser
+    npx mnemos-capture serve-mcp    Start the MCP server for Claude Code
+    npx mnemos-capture help         Show this help
+
+  Get started:
+    1. Run: npx mnemos-capture
+    2. Sign in with GitHub (creates your knowledge repo automatically)
+    3. Set a PIN for quick mobile access
+    4. Start capturing!
+
+  Connect to Claude Code:
+    claude mcp add mnemos -- npx mnemos-capture serve-mcp --key YOUR_API_KEY
+  `);
+}
+main().catch((err) => {
+    console.error("Error:", err);
+    process.exit(1);
+});
+export {};

package/dist/cli/mcp-server.js

@@ -0,0 +1,74 @@
+// MCP server that runs locally via stdio and proxies to the hosted Mnemos API.
+// Used by Claude Code: claude mcp add mnemos -- npx mnemos serve-mcp --key <api-key>
+const HOSTED_URL = "https://mnemos-capture.vercel.app/api/mcp";
+function sendMessage(msg) {
+    const json = JSON.stringify(msg);
+    process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+}
+async function proxyToHosted(apiKey, msg) {
+    try {
+        const res = await fetch(HOSTED_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(msg),
+        });
+        const data = (await res.json());
+        sendMessage(data);
+    }
+    catch (err) {
+        sendMessage({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: { code: -32603, message: err instanceof Error ? err.message : "Proxy error" },
+        });
+    }
+}
+export async function serveMcp() {
+    // Parse --key flag
+    const args = process.argv.slice(2);
+    const keyIdx = args.indexOf("--key");
+    const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : undefined;
+    if (!apiKey) {
+        process.stderr.write("\nMnemos MCP server requires an API key.\n");
+        process.stderr.write("Usage: npx mnemos serve-mcp --key <your-api-key>\n\n");
+        process.stderr.write("Get your API key at: https://mnemos-capture.vercel.app/onboard\n\n");
+        process.exit(1);
+    }
+    process.stderr.write("Mnemos MCP server starting (proxying to hosted instance)...\n");
+    let buffer = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+        buffer += chunk;
+        while (true) {
+            const headerEnd = buffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1)
+                break;
+            const header = buffer.slice(0, headerEnd);
+            const match = header.match(/Content-Length:\s*(\d+)/i);
+            if (!match) {
+                buffer = buffer.slice(headerEnd + 4);
+                continue;
+            }
+            const contentLength = parseInt(match[1], 10);
+            const bodyStart = headerEnd + 4;
+            if (buffer.length < bodyStart + contentLength)
+                break;
+            const body = buffer.slice(bodyStart, bodyStart + contentLength);
+            buffer = buffer.slice(bodyStart + contentLength);
+            try {
+                const msg = JSON.parse(body);
+                // Handle notifications/initialized locally (no response needed)
+                if (msg.method === "notifications/initialized")
+                    continue;
+                void proxyToHosted(apiKey, msg);
+            }
+            catch {
+                process.stderr.write(`Failed to parse: ${body}\n`);
+            }
+        }
+    });
+    process.stdin.on("end", () => process.exit(0));
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "mnemos-capture",
+  "version": "1.0.0",
+  "description": "Zero-friction knowledge capture for agentic workflows. Paste anything → Claude extracts insights → auto-commits to your knowledge repo → your Claude Code workflow picks it up.",
+  "type": "module",
+  "bin": {
+    "mnemos-capture": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "build:cli": "tsc -p cli/tsconfig.json",
+    "prepublishOnly": "npm run build:cli"
+  },
+  "keywords": [
+    "ai",
+    "knowledge",
+    "capture",
+    "claude",
+    "claude-code",
+    "mcp",
+    "agents",
+    "agentic",
+    "llm",
+    "workflow"
+  ],
+  "author": "Sofía Padrón Valdez",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Soph20/mnemos-capture.git"
+  },
+  "homepage": "https://github.com/Soph20/mnemos-capture",
+  "files": [
+    "dist/cli/",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.36.3",
+    "@vercel/postgres": "^0.10.0",
+    "next": "^16.1.6",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "autoprefixer": "^10.4.21",
+    "postcss": "^8.5.3",
+    "tailwindcss": "^3.4.17",
+    "typescript": "^5"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}