ollanet 0.2.2 → 0.3.0

package/README.md

@@ -1,9 +1,15 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Catalyst-Forge-LLC/ollanet/main/assets/ollanet-logo.png" alt="ollanet logo" width="360">
+</p>
+
 # ollanet
 
 Chat with **Ollama** servers on **any network you can reach** — LAN, localhost, Tailscale, VPN, or a raw IP.
 
 Scan for models, fire prompts, and continue conversations later by a short hash. No browser UI required.
 
+**Site:** [ollanet.dev](https://ollanet.dev) — Downpress + Cloudflare Pages (`site/`).
+
 ## Origin
 
 This started as a personal little script. I had Ollama running on a laptop on my Tailscale network and wanted an easy way to discover it, poke at the models, and actually talk to them from another machine — without babysitting IPs or opening a browser. One scan/prompt tool later, chats by hash showed up, LAN discovery crept in, and the thing grew into **ollanet**: a tiny CLI for using Ollama over whatever network you already have.
@@ -26,6 +32,26 @@ They share the same Ollama API; Finetuna shapes the models, ollanet finds and ch
 - **Persist** chats as `responses/<hash>.json` with topic, machine, model, timestamps
 - **Continue** any thread with `--chat <hash>`
 - **Configure** per-machine defaults (model, temperature, context, …)
+- **MCP** — `ollanet mcp` exposes scan/prompt/chats as Model Context Protocol tools for agents
+
+## Use cases
+
+The core idea: turn “I have to remember which IP has which models loaded” into a discoverable, stateful, network-native primitive. That unlocks more than interactive chat:
+
+**For agents and automation** — prefer `ollanet mcp` (stdio MCP). The same flows also work via CLI flags:
+
+- **Live model inventory / routing** — `ollanet_scan` (or `scan --json`) lists reachable hosts and models. Route each sub-task to the best host: the big-VRAM box for reasoning, the laptop for quick lookups.
+- **Conversations that survive machines** — chats are stored by short hash with full history. Start a long thread on the GPU box, continue it later with `ollanet_prompt` + `chat_id` (or `--chat <hash>`).
+- **A “talk to any Ollama on my network” tool** — `ollanet_prompt` / `prompt … --json --no-stream`; no hard-coded endpoints.
+- **Fleet health and speed checks** — periodic `ollanet bench <host> --json` builds a record of which model on which machine is currently fastest (or has silently gone offline). Saved results live in `benchmarks/`.
+- **The Finetuna loop** — [Finetuna](https://github.com/Catalyst-Forge-LLC/finetuna) shapes a GPU-tuned named variant on the host; ollanet discovers and uses it from anywhere on the network.
+
+**For humans:**
+
+- **Tailscale-native access** — prompt any machine by MagicDNS name from a laptop or phone (Termux) without babysitting IPs or opening a browser.
+- **A private model mesh** — everyone on a shared tailnet or LAN can discover and use the same Ollama hosts, no public exposure, no central UI.
+- **Multi-GPU lab** — `scan --lan` treats several machines as a pool of inference endpoints; `bench` compares the same model across hardware.
+- **Audit trail / notes** — persisted chat JSON doubles as a research log you can resume from any device.
 
 ## Requirements
 
@@ -105,6 +131,7 @@ ollanet chats --id a1b2c3d4e5f6
 | `ollanet prompt …` | Send a prompt / continue a chat |
 | `ollanet chats` | List or inspect saved transcripts |
 | `ollanet bench …` | Benchmark models for tok/s + lightweight quality checks |
+| `ollanet mcp` | Stdio [MCP](https://modelcontextprotocol.io) server for agents |
 
 ### `scan` options
 
@@ -142,6 +169,36 @@ Machine can be a discovered name, hostname, FQDN, or IP (`192.168.1.50`, `host:1
 - `--json` — list summary JSON
 - `--id <hash>` — show one chat (full JSON with `--json`)
 
+### `mcp`
+
+```bash
+ollanet mcp
+```
+
+Runs a **stdio MCP server** (no extra npm deps). Cursor / Claude Desktop / any MCP host can spawn it and call:
+
+| Tool | What it does |
+|---|---|
+| `ollanet_scan` | Discover hosts + models (`lan`, `all` optional) |
+| `ollanet_prompt` | Prompt a host or continue with `chat_id` |
+| `ollanet_list_chats` | Summarize saved transcripts |
+| `ollanet_get_chat` | Load one chat (full history) |
+
+Example Cursor MCP config (`~/.cursor/mcp.json` or project `.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "ollanet": {
+      "command": "npx",
+      "args": ["-y", "ollanet", "mcp"]
+    }
+  }
+}
+```
+
+Or, from a checkout: `"command": "pnpm"`, `"args": ["ollanet", "--", "mcp"]` (with `cwd` set to the repo). Uses the same config/chats dirs as the CLI (`~/.ollanet/` when installed).
+
 ### `bench`
 
 ```bash

package/dist/cli.js

@@ -17,6 +17,7 @@ Usage:
   ollanet prompt --chat <hash> <prompt...>
   ollanet chats [--json] [--id <hash>]
   ollanet bench <machine|ip> [model...] [--all] [options]
+  ollanet mcp
 
 Examples:
   ollanet scan
@@ -27,6 +28,7 @@ Examples:
   ollanet chats
   ollanet bench localhost --all
   ollanet bench localhost llama3.2:1b --runs 3
+  ollanet mcp                  # stdio MCP server for agents
 
 Config: ~/.ollanet/config.json when installed, ./config.json in a checkout
         (override with OLLANET_CONFIG)
@@ -77,6 +79,11 @@ async function main() {
             await run();
             return;
         }
+        case "mcp": {
+            const { main: run } = await import("./mcp.js");
+            await run();
+            return;
+        }
         default:
             console.error(`Unknown command: ${cmd}\n`);
             process.stderr.write(HELP);

package/dist/mcp.js

@@ -0,0 +1,285 @@
+/**
+ * ollanet mcp — stdio MCP server (zero deps).
+ *
+ * Speaks the Model Context Protocol over stdin/stdout so agents (Cursor,
+ * Claude Desktop, etc.) can discover hosts, prompt models, and continue chats.
+ *
+ *   ollanet mcp
+ *
+ * stdout is reserved for JSON-RPC; log only to stderr.
+ */
+import { createInterface } from "node:readline";
+import { readFile } from "node:fs/promises";
+import { listChats, loadChat } from "./chat-store.js";
+import { projectPath } from "./paths.js";
+import { runPrompt } from "./prompt.js";
+import { scanNetwork } from "./scan.js";
+const PROTOCOL_VERSION = "2024-11-05";
+const TOOLS = [
+    {
+        name: "ollanet_scan",
+        description: "Discover reachable Ollama hosts and list their models. " +
+            "Use this before routing work to pick a host/model. " +
+            "Optional LAN TCP scan (--lan equivalent) and include offline Tailscale peers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lan: {
+                    type: "boolean",
+                    description: "TCP-scan local LAN CIDRs for open Ollama ports (default false)",
+                },
+                all: {
+                    type: "boolean",
+                    description: "Also probe offline Tailscale peers (default false)",
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_prompt",
+        description: "Send a prompt to an Ollama host on the network (or continue a saved chat by id). " +
+            "Returns the assistant reply and chat_id for follow-ups. " +
+            "Machine can be a discovered name, MagicDNS name, hostname, or IP[:port].",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "User message to send",
+                },
+                machine: {
+                    type: "string",
+                    description: "Host name/IP (required for new chats; optional override when continuing)",
+                },
+                model: {
+                    type: "string",
+                    description: "Model name (optional; uses config default or chat model)",
+                },
+                chat_id: {
+                    type: "string",
+                    description: "Continue a saved chat by its hex hash id",
+                },
+                system: {
+                    type: "string",
+                    description: "System prompt (new chats, or if the chat has none yet)",
+                },
+                temperature: { type: "number" },
+                num_predict: { type: "integer" },
+                num_ctx: { type: "integer" },
+                keep_alive: {
+                    description: 'Keep model loaded (e.g. "5m", 0, -1)',
+                },
+                think: {
+                    type: "boolean",
+                    description: "Enable model thinking (default false)",
+                },
+                save: {
+                    type: "boolean",
+                    description: "Persist the transcript (default true)",
+                },
+            },
+            required: ["prompt"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_list_chats",
+        description: "List saved ollanet chat transcripts (id, topic, machine, model, message count).",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "ollanet_get_chat",
+        description: "Load one saved chat by id, including full message history.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chat_id: {
+                    type: "string",
+                    description: "Hex chat hash from a prior prompt",
+                },
+            },
+            required: ["chat_id"],
+            additionalProperties: false,
+        },
+    },
+];
+function writeMessage(msg) {
+    process.stdout.write(`${JSON.stringify(msg)}\n`);
+}
+function ok(id, result) {
+    if (id === undefined)
+        return;
+    writeMessage({ jsonrpc: "2.0", id, result });
+}
+function fail(id, code, message) {
+    if (id === undefined)
+        return;
+    writeMessage({ jsonrpc: "2.0", id, error: { code, message } });
+}
+function textResult(data, isError = false) {
+    const text = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+    return {
+        content: [{ type: "text", text }],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+async function packageVersion() {
+    try {
+        const pkg = JSON.parse(await readFile(projectPath("package.json"), "utf8"));
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function callTool(name, args) {
+    switch (name) {
+        case "ollanet_scan": {
+            const payload = await scanNetwork({
+                lanScan: Boolean(args.lan),
+                includeOffline: Boolean(args.all),
+            });
+            return textResult(payload);
+        }
+        case "ollanet_prompt": {
+            const prompt = typeof args.prompt === "string" ? args.prompt : "";
+            if (!prompt.trim()) {
+                return textResult({ error: "prompt is required" }, true);
+            }
+            const settings = {};
+            if (typeof args.system === "string")
+                settings.system = args.system;
+            if (typeof args.temperature === "number")
+                settings.temperature = args.temperature;
+            if (typeof args.num_predict === "number")
+                settings.num_predict = Math.trunc(args.num_predict);
+            if (typeof args.num_ctx === "number")
+                settings.num_ctx = Math.trunc(args.num_ctx);
+            if (typeof args.think === "boolean")
+                settings.think = args.think;
+            if (args.keep_alive !== undefined) {
+                const raw = args.keep_alive;
+                if (typeof raw === "number")
+                    settings.keep_alive = raw;
+                else if (typeof raw === "string") {
+                    const asNum = Number(raw);
+                    settings.keep_alive =
+                        raw.trim() !== "" && Number.isFinite(asNum) && String(asNum) === raw ? asNum : raw;
+                }
+            }
+            const result = await runPrompt({
+                prompt,
+                machine: typeof args.machine === "string" ? args.machine : undefined,
+                model: typeof args.model === "string" ? args.model : undefined,
+                chatId: typeof args.chat_id === "string" ? args.chat_id : undefined,
+                save: args.save === undefined ? true : Boolean(args.save),
+                settings,
+                writeStdout: false,
+                stream: false,
+                quiet: true,
+            });
+            return textResult(result);
+        }
+        case "ollanet_list_chats": {
+            const chats = await listChats();
+            return textResult(chats.map((c) => ({
+                id: c.id,
+                topic: c.topic,
+                machine: c.machine,
+                model: c.model,
+                messages: c.messages.length,
+                created_at: c.created_at,
+                updated_at: c.updated_at,
+            })));
+        }
+        case "ollanet_get_chat": {
+            const id = typeof args.chat_id === "string" ? args.chat_id : "";
+            if (!id)
+                return textResult({ error: "chat_id is required" }, true);
+            const chat = await loadChat(id);
+            return textResult(chat);
+        }
+        default:
+            return textResult({ error: `Unknown tool: ${name}` }, true);
+    }
+}
+async function handleRequest(msg, version) {
+    const { id, method } = msg;
+    if (!method) {
+        fail(id, -32600, "Invalid Request: missing method");
+        return;
+    }
+    // Notifications (no id) — acknowledge silently.
+    if (method === "notifications/initialized" || method.startsWith("notifications/")) {
+        return;
+    }
+    switch (method) {
+        case "initialize":
+            ok(id, {
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {} },
+                serverInfo: { name: "ollanet", version },
+            });
+            return;
+        case "ping":
+            ok(id, {});
+            return;
+        case "tools/list":
+            ok(id, { tools: TOOLS });
+            return;
+        case "tools/call": {
+            const params = (msg.params ?? {});
+            const name = params.name;
+            if (!name) {
+                fail(id, -32602, "tools/call requires params.name");
+                return;
+            }
+            try {
+                const result = await callTool(name, params.arguments ?? {});
+                ok(id, result);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                ok(id, textResult({ error: message }, true));
+            }
+            return;
+        }
+        default:
+            fail(id, -32601, `Method not found: ${method}`);
+    }
+}
+export async function main() {
+    const version = await packageVersion();
+    console.error(`ollanet mcp ${version} (stdio) — tools: ${TOOLS.map((t) => t.name).join(", ")}`);
+    const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            writeMessage({
+                jsonrpc: "2.0",
+                id: null,
+                error: { code: -32700, message: "Parse error" },
+            });
+            continue;
+        }
+        // JSON-RPC batch
+        if (Array.isArray(msg)) {
+            for (const item of msg) {
+                await handleRequest(item, version);
+            }
+            continue;
+        }
+        await handleRequest(msg, version);
+    }
+}

package/dist/prompt.js

@@ -308,11 +308,13 @@ function formatDuration(ns) {
         return `${ms.toFixed(0)}ms`;
     return `${(ms / 1000).toFixed(1)}s`;
 }
-export async function main() {
-    const parsed = parseArgs(process.argv.slice(2));
-    const { stream, json, save } = parsed;
-    let promptParts = parsed.promptParts;
-    const fromStdin = await readStdinIfPiped();
+/** Programmatic prompt used by CLI `--json` and the MCP server. */
+export async function runPrompt(opts) {
+    const save = opts.save !== false;
+    const stream = opts.stream !== false && opts.writeStdout !== false;
+    const quiet = opts.quiet === true || opts.writeStdout === false;
+    const writeStdout = opts.writeStdout !== false;
+    let promptParts = opts.prompt ? [opts.prompt] : [];
     const config = await loadConfig();
     const { hosts: targets } = await discoverHosts({
         hosts: config.hosts,
@@ -320,50 +322,34 @@ export async function main() {
     });
     let chat;
     let isNewChat = false;
-    let machineQuery = parsed.machine;
-    if (parsed.chatId) {
-        chat = await loadChat(parsed.chatId);
-        // Allow `ollanet prompt <host> --chat HASH "follow-up"` only when the
-        // leading token matches an already-discovered host (not direct-address fallback).
-        if (!machineQuery && promptParts.length >= 2) {
-            const hit = findDiscoveredHost(targets, promptParts[0]);
-            if (hit) {
-                machineQuery = promptParts[0];
-                promptParts = promptParts.slice(1);
-            }
-        }
+    let machineQuery = opts.machine;
+    if (opts.chatId) {
+        chat = await loadChat(opts.chatId);
     }
     machineQuery = machineQuery ?? chat?.machine;
     if (!machineQuery) {
-        console.error("Machine is required for a new chat (or use --chat <hash>).");
-        usage();
+        throw new Error("Machine is required for a new chat (or pass chatId).");
     }
     const host = resolveHost(targets, machineQuery);
     if (!host.online && !host.isSelf && host.source === "tailscale") {
         throw new Error(`Machine "${shortName(host)}" appears offline.`);
     }
     let peeledModel;
-    if (!parsed.chatId && !parsed.model) {
-        const peeled = await maybePeelModel(host, promptParts, fromStdin);
+    if (!opts.chatId && !opts.model) {
+        const peeled = await maybePeelModel(host, promptParts, "");
         peeledModel = peeled.model;
         promptParts = peeled.promptParts;
     }
-    const promptText = [promptParts.join(" ").trim(), fromStdin].filter(Boolean).join("\n\n").trim();
+    const promptText = promptParts.join(" ").trim();
     if (!promptText) {
-        console.error("No prompt provided (pass args and/or pipe stdin).");
-        usage();
+        throw new Error("No prompt provided.");
     }
-    const model = parsed.model ??
-        peeledModel ??
-        chat?.model ??
-        defaultModelForHost(config, host);
+    const model = opts.model ?? peeledModel ?? chat?.model ?? defaultModelForHost(config, host);
     if (!model) {
         throw new Error(`No model specified for "${shortName(host)}" and no default in ${configPath()}.\n` +
-            `Pass a model, use --model <name>, or add it under defaultModels.`);
+            `Pass a model or add it under defaultModels.`);
     }
-    const settings = mergeSettings(
-    // Thinking models otherwise spend the whole num_predict budget on hidden reasoning.
-    { think: false }, config.defaults, machineSettingsForHost(config, host), settingsFromEnv(), chat?.system ? { system: chat.system } : undefined, parsed.settings);
+    const settings = mergeSettings({ think: false }, config.defaults, machineSettingsForHost(config, host), settingsFromEnv(), chat?.system ? { system: chat.system } : undefined, opts.settings);
     if (!chat && save) {
         chat = createChat({
             machine: shortName(host),
@@ -374,7 +360,6 @@ export async function main() {
         isNewChat = true;
     }
     else if (!chat) {
-        // --no-save one-shot: ephemeral transcript for the API call only
         chat = createChat({
             machine: shortName(host),
             model,
@@ -383,26 +368,26 @@ export async function main() {
         isNewChat = true;
     }
     else {
-        if (parsed.settings.system && !chat.system) {
-            chat.system = parsed.settings.system;
+        if (opts.settings?.system && !chat.system) {
+            chat.system = opts.settings.system;
         }
         chat.model = model;
         chat.machine = shortName(host);
     }
     appendMessage(chat, { role: "user", content: promptText });
     const baseUrl = ollamaBaseUrl(host);
-    if (!json) {
-        const src = parsed.model ? "explicit" : chat && !isNewChat ? "chat" : "default";
+    if (!quiet) {
+        const src = opts.model ? "explicit" : chat && !isNewChat ? "chat" : "default";
         const extras = settingsSummary(settings);
-        const chatTag = parsed.chatId ? `  chat=${chat.id}` : "";
+        const chatTag = opts.chatId ? `  chat=${chat.id}` : "";
         console.error(`→ ${shortName(host)} (${host.ip})  model=${model}  [${src}]${chatTag}${extras ? `  ${extras}` : ""}`);
     }
     const { content, thinking, chunk } = await ollamaChat({
         baseUrl,
         model,
         messages: toApiMessages(chat),
-        stream: json ? false : stream,
-        writeStdout: !json,
+        stream: writeStdout ? stream : false,
+        writeStdout,
         timeoutMs: PROMPT_TIMEOUT_MS,
         settings,
     });
@@ -429,30 +414,100 @@ export async function main() {
     }
     if (save) {
         const file = await saveChat(chat);
-        if (!json) {
+        if (!quiet) {
             console.error(`chat ${chat.id}  topic: ${chat.topic}`);
             console.error(`saved ${file}`);
             console.error(`continue: ollanet prompt --chat ${chat.id} "your follow-up"`);
         }
     }
-    if (json) {
-        console.log(JSON.stringify({
-            chat_id: save ? chat.id : null,
-            topic: chat.topic,
-            content,
-            thinking: thinking || null,
-            ollama: chunk,
-        }, null, 2));
-        return;
+    return {
+        chat_id: save ? chat.id : null,
+        topic: chat.topic,
+        content,
+        thinking: thinking || null,
+        machine: shortName(host),
+        model,
+        ollama: chunk,
+    };
+}
+export async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    const { stream, json, save } = parsed;
+    let promptParts = parsed.promptParts;
+    const fromStdin = await readStdinIfPiped();
+    const config = await loadConfig();
+    const { hosts: targets } = await discoverHosts({
+        hosts: config.hosts,
+        discovery: config.discovery,
+    });
+    let machineQuery = parsed.machine;
+    if (parsed.chatId) {
+        // Allow `ollanet prompt <host> --chat HASH "follow-up"` only when the
+        // leading token matches an already-discovered host (not direct-address fallback).
+        if (!machineQuery && promptParts.length >= 2) {
+            const hit = findDiscoveredHost(targets, promptParts[0]);
+            if (hit) {
+                machineQuery = promptParts[0];
+                promptParts = promptParts.slice(1);
+            }
+        }
+    }
+    let peeledModel;
+    if (!parsed.chatId && !parsed.model) {
+        if (!machineQuery) {
+            console.error("Machine is required for a new chat (or use --chat <hash>).");
+            usage();
+        }
+        const host = resolveHost(targets, machineQuery);
+        const peeled = await maybePeelModel(host, promptParts, fromStdin);
+        peeledModel = peeled.model;
+        promptParts = peeled.promptParts;
     }
-    const stats = [
-        chunk.eval_count != null ? `${chunk.eval_count} tokens` : "",
-        chunk.eval_duration
-            ? `${((chunk.eval_count ?? 0) / (chunk.eval_duration / 1e9)).toFixed(1)} tok/s`
-            : "",
-        chunk.total_duration ? formatDuration(chunk.total_duration) : "",
-    ].filter(Boolean);
-    if (stats.length > 0) {
-        console.error(`(${stats.join(" · ")})`);
+    const promptText = [promptParts.join(" ").trim(), fromStdin].filter(Boolean).join("\n\n").trim();
+    if (!promptText) {
+        console.error("No prompt provided (pass args and/or pipe stdin).");
+        usage();
+    }
+    try {
+        const result = await runPrompt({
+            machine: machineQuery,
+            model: parsed.model ?? peeledModel,
+            prompt: promptText,
+            chatId: parsed.chatId,
+            save,
+            settings: parsed.settings,
+            writeStdout: !json,
+            stream: json ? false : stream,
+            quiet: json,
+        });
+        if (json) {
+            console.log(JSON.stringify({
+                chat_id: result.chat_id,
+                topic: result.topic,
+                content: result.content,
+                thinking: result.thinking,
+                ollama: result.ollama,
+            }, null, 2));
+            return;
+        }
+        const chunk = result.ollama;
+        const stats = [
+            chunk.eval_count != null ? `${chunk.eval_count} tokens` : "",
+            chunk.eval_duration
+                ? `${((Number(chunk.eval_count) || 0) / (Number(chunk.eval_duration) / 1e9)).toFixed(1)} tok/s`
+                : "",
+            chunk.total_duration ? formatDuration(Number(chunk.total_duration)) : "",
+        ].filter(Boolean);
+        if (stats.length > 0) {
+            console.error(`(${stats.join(" · ")})`);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.startsWith("Machine is required") || message.startsWith("No prompt")) {
+            console.error(message);
+            usage();
+        }
+        throw err;
     }
 }

package/dist/scan.js

@@ -113,6 +113,49 @@ function printResults(results, networkLabel, sources) {
     }
     console.log(`Found ${found.length} Ollama server(s) with ${found.reduce((n, r) => n + r.models.length, 0)} model entrie(s).`);
 }
+function toPayload(results, networkLabel, sources) {
+    return {
+        network: networkLabel,
+        sources,
+        port: OLLAMA_PORT,
+        scanned: results.length,
+        servers: results
+            .filter((r) => r.ok)
+            .map((r) => ({
+            hostname: r.host.hostname,
+            dnsName: r.host.dnsName,
+            ip: r.host.ip,
+            port: r.host.port,
+            os: r.host.os,
+            source: r.host.source,
+            self: r.host.isSelf,
+            endpoint: `http://${r.host.ip}:${r.host.port}`,
+            models: r.models.map((m) => ({
+                name: m.name,
+                size: m.size,
+                modified_at: m.modified_at,
+                parameter_size: m.details?.parameter_size,
+                quantization_level: m.details?.quantization_level,
+                family: m.details?.family,
+            })),
+        })),
+    };
+}
+/** Programmatic scan used by CLI `--json` and the MCP server. */
+export async function scanNetwork(options = {}) {
+    const config = await loadConfig();
+    const { hosts, sources, networkLabel } = await discoverHosts({
+        hosts: config.hosts,
+        discovery: config.discovery,
+        includeOffline: options.includeOffline ?? false,
+        lanScan: options.lanScan ?? false,
+    });
+    if (hosts.length === 0) {
+        throw new Error("No hosts to scan. Add config.hosts, set OLLANET_HOSTS, or enable Tailscale/LAN discovery.");
+    }
+    const results = await mapPool(hosts, CONCURRENCY, scanHost);
+    return toPayload(results, networkLabel, sources);
+}
 export async function main() {
     const includeOffline = process.argv.includes("--all");
     const jsonOut = process.argv.includes("--json");
@@ -131,32 +174,7 @@ export async function main() {
     }
     const results = await mapPool(hosts, CONCURRENCY, scanHost);
     if (jsonOut) {
-        console.log(JSON.stringify({
-            network: networkLabel,
-            sources,
-            port: OLLAMA_PORT,
-            scanned: results.length,
-            servers: results
-                .filter((r) => r.ok)
-                .map((r) => ({
-                hostname: r.host.hostname,
-                dnsName: r.host.dnsName,
-                ip: r.host.ip,
-                port: r.host.port,
-                os: r.host.os,
-                source: r.host.source,
-                self: r.host.isSelf,
-                endpoint: `http://${r.host.ip}:${r.host.port}`,
-                models: r.models.map((m) => ({
-                    name: m.name,
-                    size: m.size,
-                    modified_at: m.modified_at,
-                    parameter_size: m.details?.parameter_size,
-                    quantization_level: m.details?.quantization_level,
-                    family: m.details?.family,
-                })),
-            })),
-        }, null, 2));
+        console.log(JSON.stringify(toPayload(results, networkLabel, sources), null, 2));
         return;
     }
     printResults(results, networkLabel, sources);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ollanet",
-  "version": "0.2.2",
-  "description": "Chat with Ollama servers on any reachable network — scan hosts, prompt models, continue chats by hash",
+  "version": "0.3.0",
+  "description": "Chat with Ollama servers on any reachable network — scan hosts, prompt models, continue chats by hash, MCP for agents",
   "type": "module",
   "bin": {
     "ollanet": "./dist/cli.js"
@@ -19,10 +19,14 @@
     "prompt": "tsx src/cli.ts prompt",
     "chats": "tsx src/cli.ts chats",
     "bench": "tsx src/cli.ts bench",
+    "mcp": "tsx src/cli.ts mcp",
     "start": "tsx src/cli.ts scan",
     "typecheck": "tsc --noEmit",
     "test": "tsc -p tsconfig.build.json && node --test test/*.test.mjs",
-    "test:only": "node --test test/*.test.mjs"
+    "test:only": "node --test test/*.test.mjs",
+    "site:dev": "pnpm --dir site dev",
+    "site:build": "pnpm --dir site build",
+    "site:deploy": "pnpm --dir site deploy"
   },
   "keywords": [
     "ollama",
@@ -31,7 +35,9 @@
     "chat",
     "lan",
     "tailscale",
-    "network"
+    "network",
+    "mcp",
+    "model-context-protocol"
   ],
   "author": "Catalyst Forge LLC",
   "license": "MIT",
@@ -39,7 +45,7 @@
     "type": "git",
     "url": "git+https://github.com/Catalyst-Forge-LLC/ollanet.git"
   },
-  "homepage": "https://github.com/Catalyst-Forge-LLC/ollanet#readme",
+  "homepage": "https://ollanet.dev",
   "bugs": {
     "url": "https://github.com/Catalyst-Forge-LLC/ollanet/issues"
   },