innernet-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jordan Schuster
+
+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,49 @@
+# innernet-mcp
+
+Read-only MCP server over your [Innernet](https://jointheinner.net/build-your-own) graph.
+Ask your agent about your own network.
+
+```json
+{
+  "mcpServers": {
+    "innernet": {
+      "command": "npx",
+      "args": ["-y", "innernet-mcp"],
+      "env": { "INNERNET_DB_URL": "postgres://user:pass@localhost:5432/innernet" }
+    }
+  }
+}
+```
+
+Or let the CLI write it for you:
+
+```bash
+pnpm innernet mcp --install
+```
+
+## Tools
+
+| Tool | What it answers |
+|---|---|
+| `search_people` | Find someone by name, email, company, title, or handle |
+| `get_person` | The full dossier for one person — every fact with the source it came from |
+| `recent_contact` | Who you have actually been in touch with lately |
+| `gone_quiet` | Real history, no recent contact. The reconnect list |
+
+## Read-only, by construction
+
+Every tool is a `SELECT`. The server has no write path at all — an agent that can rewrite
+your relationship history is a much worse trade than one that can only read it.
+
+Point `INNERNET_DB_URL` at a read-only Postgres role in any setting you care about. The
+server never needs write access, so granting it is pure downside.
+
+## Notes
+
+- Requires a database built by [`innernet-cli`](https://www.npmjs.com/package/innernet-cli).
+- Facts carry a `source_url` and a confidence value. Treat low confidence as a lead, not a
+  fact — a name match is not a person.
+- A missing `INNERNET_DB_URL` is returned to the agent as an error message rather than
+  thrown, so the model can explain what is wrong instead of the call dying.
+
+MIT

package/dist/db.js

@@ -0,0 +1,99 @@
+// Postgres access for the MCP server.
+//
+// Read-only by construction: every statement here is a SELECT, and the
+// connection is opened against whatever role INNERNET_DB_URL carries. Point it
+// at a read-only role in production — the server never needs write access, so
+// granting it is pure downside.
+import postgres from "postgres";
+let _sql = null;
+export function db() {
+    if (_sql)
+        return _sql;
+    const url = process.env.INNERNET_DB_URL;
+    if (!url) {
+        throw new Error("INNERNET_DB_URL is not set. Point it at your Innernet Postgres, e.g. " +
+            "postgres://user:pass@localhost:5432/postgres");
+    }
+    _sql = postgres(url, { max: 4, prepare: false, idle_timeout: 20 });
+    return _sql;
+}
+const PERSON_COLS = `id, display_name, primary_email, title, company,
+                     linkedin_url, github_handle, twitter_handle`;
+/**
+ * Substring search across the fields a human actually remembers someone by.
+ * Deliberately not vector search: an MCP client asks concrete questions, and a
+ * lexical match is explainable in a way a cosine score is not.
+ */
+export async function searchPeople(q, limit) {
+    const sql = db();
+    const like = `%${q}%`;
+    return (await sql.unsafe(`select ${PERSON_COLS}
+       from people
+      where display_name ilike $1
+         or primary_email ilike $1
+         or company ilike $1
+         or title ilike $1
+         or github_handle ilike $1
+         or twitter_handle ilike $1
+      order by display_name asc
+      limit $2`, [like, limit]));
+}
+export async function getPerson(id) {
+    const sql = db();
+    const rows = (await sql.unsafe(`select ${PERSON_COLS} from people where id = $1 limit 1`, [id]));
+    return rows[0] ?? null;
+}
+/**
+ * Facts about a person, best-confidence first.
+ *
+ * `to_regclass` guards the whole call: person_facets only exists once the
+ * enrichment migrations have run, and a fresh install should get an empty
+ * dossier rather than a stack trace about a missing relation.
+ */
+export async function getFacets(personId, limit = 200) {
+    const sql = db();
+    const exists = (await sql.unsafe(`select to_regclass('public.person_facets') is not null as ok`));
+    if (!exists[0]?.ok)
+        return [];
+    return (await sql.unsafe(`select facet_key, facet_value, source_url, confidence
+       from person_facets
+      where person_id = $1
+      order by confidence desc, facet_key asc
+      limit $2`, [personId, limit]));
+}
+/** Who you actually talk to, ranked by volume, within a lookback window. */
+export async function recentContact(days, limit) {
+    const sql = db();
+    return (await sql.unsafe(`select p.id            as person_id,
+            p.display_name  as display_name,
+            count(i.id)::int as interactions,
+            max(i.occurred_at)::text as last_seen
+       from people p
+       join interactions i
+         on i.from_person_id = p.id
+         or p.id = any(i.to_person_ids)
+      where i.occurred_at > now() - ($1 || ' days')::interval
+      group by p.id, p.display_name
+      order by interactions desc
+      limit $2`, [String(days), limit]));
+}
+/**
+ * People you have gone quiet on: a real history, nothing recent.
+ * This is the query the graph exists to answer, so it gets a first-class tool.
+ */
+export async function goneQuiet(days, limit) {
+    const sql = db();
+    return (await sql.unsafe(`select p.id           as person_id,
+            p.display_name as display_name,
+            count(i.id)::int as interactions,
+            max(i.occurred_at)::text as last_seen
+       from people p
+       join interactions i
+         on i.from_person_id = p.id
+         or p.id = any(i.to_person_ids)
+      group by p.id, p.display_name
+     having max(i.occurred_at) < now() - ($1 || ' days')::interval
+        and count(i.id) >= 3
+      order by count(i.id) desc
+      limit $2`, [String(days), limit]));
+}

package/dist/index.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// innernet-mcp — read-only MCP server over your Innernet graph.
+//
+// Every tool is a SELECT. The server cannot mutate your graph, by design: an
+// agent that can rewrite your relationship history is a much worse trade than
+// one that can only read it.
+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 { getFacets, getPerson, goneQuiet, recentContact, searchPeople, } from "./db.js";
+const server = new Server({ name: "innernet", version: "0.1.0" }, { capabilities: { tools: {} } });
+const TOOLS = [
+    {
+        name: "search_people",
+        description: "Search your Innernet graph for people by name, email, company, title, or social handle. " +
+            "Returns matching people with their ids — pass an id to get_person for the full dossier.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Name, company, title, email, or handle fragment." },
+                limit: { type: "number", description: "Max results (default 20, max 100)." },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_person",
+        description: "Get the full dossier for one person by id: their profile plus every enriched fact, " +
+            "each with the source URL it came from and a confidence score.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                person_id: { type: "string", description: "The person's uuid, from search_people." },
+            },
+            required: ["person_id"],
+        },
+    },
+    {
+        name: "recent_contact",
+        description: "Who you have actually been in touch with recently, ranked by interaction volume. " +
+            "Use this to answer 'who am I close to right now'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                days: { type: "number", description: "Lookback window in days (default 90)." },
+                limit: { type: "number", description: "Max results (default 20, max 100)." },
+            },
+        },
+    },
+    {
+        name: "gone_quiet",
+        description: "People you have a real history with but have not spoken to lately — the reconnect list. " +
+            "Answers 'who am I letting drift'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                days: { type: "number", description: "Silence threshold in days (default 180)." },
+                limit: { type: "number", description: "Max results (default 20, max 100)." },
+            },
+        },
+    },
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+/** Clamp a caller-supplied limit; an agent will happily ask for 10000. */
+function clampLimit(v, dflt) {
+    const n = typeof v === "number" && Number.isFinite(v) ? Math.floor(v) : dflt;
+    return Math.min(Math.max(n, 1), 100);
+}
+function clampDays(v, dflt) {
+    const n = typeof v === "number" && Number.isFinite(v) ? Math.floor(v) : dflt;
+    return Math.min(Math.max(n, 1), 3650);
+}
+function ok(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name } = req.params;
+    const args = (req.params.arguments ?? {});
+    try {
+        switch (name) {
+            case "search_people": {
+                const q = String(args.query ?? "").trim();
+                if (!q)
+                    return ok({ error: "query is required and cannot be empty" });
+                const people = await searchPeople(q, clampLimit(args.limit, 20));
+                return ok({ count: people.length, people });
+            }
+            case "get_person": {
+                const id = String(args.person_id ?? "").trim();
+                if (!id)
+                    return ok({ error: "person_id is required" });
+                const person = await getPerson(id);
+                if (!person)
+                    return ok({ error: `no person with id ${id}` });
+                const facets = await getFacets(id);
+                return ok({
+                    person,
+                    facet_count: facets.length,
+                    facets,
+                    note: facets.length === 0
+                        ? "No enriched facts yet — run `innernet enrich` to populate this dossier."
+                        : "Every fact carries the source_url it came from. Treat a low confidence value as a lead, not a fact.",
+                });
+            }
+            case "recent_contact":
+                return ok({ people: await recentContact(clampDays(args.days, 90), clampLimit(args.limit, 20)) });
+            case "gone_quiet":
+                return ok({ people: await goneQuiet(clampDays(args.days, 180), clampLimit(args.limit, 20)) });
+            default:
+                return ok({ error: `unknown tool: ${name}` });
+        }
+    }
+    catch (e) {
+        // Surface the failure to the agent as data rather than throwing: a thrown
+        // error ends the tool call, while a returned one lets the model explain
+        // what went wrong (usually a missing INNERNET_DB_URL).
+        return ok({ error: e.message });
+    }
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);
+// stderr only — stdout is the MCP wire protocol and must stay clean.
+console.error("innernet mcp: ready");

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "innernet-mcp",
+  "version": "0.1.0",
+  "description": "Read-only MCP server over your Innernet graph — search people, pull a dossier, find your warmest intro path.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "innernet-mcp": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "postgres": "^3.4.5",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "author": "Jordan Schuster",
+  "homepage": "https://jointheinner.net/build-your-own",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "contacts",
+    "crm",
+    "personal-graph",
+    "innernet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nayslayer143/innernet.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/nayslayer143/innernet/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}