bikky 0.3.13 → 0.4.1

package/dist/mcp/api.js

@@ -1,32 +1,37 @@
 /**
- * External API helpers — Qdrant REST client, LLM chat, logging.
- * Credentials come from config (~/.bikky/config.json) or env vars.
+ * External API helpers — Qdrant REST client pool, LLM chat, logging.
+ *
+ * Multi-destination model: write operations resolve to one Destination
+ * (see ../routing.ts) and operate against that destination's QdrantClient
+ * via the QdrantPool (see ../lib/qdrant-pool.ts). Read/search operations may
+ * resolve a search scope and fan out across multiple destinations.
+ *
+ * The legacy single-Qdrant API is kept around for back-compat where call sites
+ * have not yet been refactored — they all route to a "default" destination
+ * synthesized from the top-level qdrant_url/qdrant_api_key/collection.
  */
 import fs from "node:fs";
 import path from "node:path";
 import { embed, getEmbeddingDimensions, getEmbeddingConfig, initEmbedding, chatCompletion, initLLM } from "../llm/index.js";
 export { embed, getEmbeddingDimensions, getEmbeddingConfig, initEmbedding };
 import { createLogger } from "../logger.js";
-import { BIKKY_DIR, LOG_DIR, loadConfig } from "../config.js";
-import { QdrantClient } from "../lib/qdrant-client.js";
+import { BIKKY_DIR, LOG_DIR, loadConfig, getEffectiveDestinations } from "../config.js";
+import { QdrantPool } from "../lib/qdrant-pool.js";
+import { resolveDestination, buildResolver } from "../routing.js";
 // ---------------------------------------------------------------------------
-// Config
+// Boot dirs / log
 // ---------------------------------------------------------------------------
 export const MEMORY_DIR = BIKKY_DIR;
-let collectionName = "bikky";
-export function getCollection() { return collectionName; }
-export function setCollection(name) {
-    collectionName = name;
-    rebuildClient();
-}
 fs.mkdirSync(MEMORY_DIR, { recursive: true });
 fs.mkdirSync(LOG_DIR, { recursive: true });
-let llmInitialized = false;
+export const log = createLogger("memory-mcp", path.join(LOG_DIR, "mcp.log"), {
+    maxSize: 2 * 1024 * 1024,
+    maxFiles: 3,
+});
+const qdrantLogAdapter = (level, msg) => log(level, msg);
 // ---------------------------------------------------------------------------
 // Runtime state — populated at startup
 // ---------------------------------------------------------------------------
-export let qdrantUrl = null;
-export let qdrantApiKey = null;
 export let ready = false;
 /**
  * Reason the system is not ready, when known. Set by `setSetupError` from the
@@ -35,45 +40,69 @@ export let ready = false;
  * instead of a generic "setup_required".
  */
 export let setupError = null;
-let client = null;
-export function setQdrantUrl(v) {
-    qdrantUrl = v ? v.replace(/\/+$/, "") : v;
-    rebuildClient();
-}
-export function setQdrantApiKey(v) {
-    qdrantApiKey = v;
-    rebuildClient();
-}
+let pool = null;
+let llmInitialized = false;
 export function setReady(v) { ready = v; }
 export function setSetupError(v) { setupError = v; }
 // ---------------------------------------------------------------------------
-// Logging (to file only — stdout/stderr are MCP stdio transport)
+// Pool lifecycle
 // ---------------------------------------------------------------------------
-export const log = createLogger("memory-mcp", path.join(LOG_DIR, "mcp.log"), {
-    maxSize: 2 * 1024 * 1024,
-    maxFiles: 3,
-});
-// Adapter to bridge QdrantClient's QdrantLogFn signature to our file logger.
-const qdrantLogAdapter = (level, msg) => log(level, msg);
-function rebuildClient() {
-    if (qdrantUrl && collectionName) {
-        const cfg = loadConfig();
-        client = new QdrantClient({
-            url: qdrantUrl,
-            apiKey: qdrantApiKey,
-            collection: collectionName,
-            timeoutMs: cfg.qdrant_client.timeout_ms,
-            retries: cfg.qdrant_client.retries,
-            retryBaseDelayMs: cfg.qdrant_client.retry_base_delay_ms,
-            log: qdrantLogAdapter,
-        });
+/**
+ * (Re)build the destination pool from the current config. Idempotent — safe
+ * to call after configure_credentials updates the on-disk config.
+ */
+export function rebuildPool() {
+    const cfg = loadConfig();
+    const destinations = getEffectiveDestinations(cfg);
+    if (destinations.length === 0) {
+        pool = null;
+        return;
+    }
+    pool = new QdrantPool(destinations, {
+        client: cfg.qdrant_client,
+        log: qdrantLogAdapter,
+    });
+}
+export function getPool() {
+    if (!pool) {
+        throw new Error("Qdrant pool not initialized — no destinations configured. " +
+            "Use configure_credentials or set QDRANT_URL " +
+            "(QDRANT_API_KEY is optional for local / self-hosted instances).");
     }
-    else {
-        client = null;
+    return pool;
+}
+/** Whether at least one destination is configured. */
+export function hasPool() {
+    return pool !== null;
+}
+/** All destination names currently in the pool, in registration order. */
+export function destinationNames() {
+    return pool?.names() ?? [];
+}
+/** All Destination objects in the pool. */
+export function listDestinations() {
+    return pool?.destinations() ?? [];
+}
+/** True if any destination's collection is confirmed ready. */
+export function anyCollectionReady() {
+    if (!pool)
+        return false;
+    for (const name of pool.names()) {
+        if (pool.isCollectionReady(name))
+            return true;
     }
+    return false;
+}
+/** Resolve a destination from caller input. Throws if not configured/found. */
+export function resolveDest(input) {
+    return resolveDestination(input, listDestinations());
+}
+/** Build a resolver closure from the current pool's destinations. */
+export function makeResolver() {
+    return buildResolver(listDestinations());
 }
 // ---------------------------------------------------------------------------
-// LLM Chat Completion (for distillation)
+// LLM Chat Completion (unchanged — single global LLM config)
 // ---------------------------------------------------------------------------
 export async function chatComplete(systemPrompt, userPrompt) {
     ensureLLMInitialized();
@@ -89,10 +118,6 @@ export async function chatComplete(systemPrompt, userPrompt) {
         throw new Error("LLM chat completion failed");
     return result;
 }
-/**
- * Run a pre-rendered prompt (from src/prompts/*) through the LLM. The
- * RenderedPrompt already carries messages, response_format, temperature, etc.
- */
 export async function chatCompleteRendered(opts) {
     ensureLLMInitialized();
     const result = await chatCompletion(opts);
@@ -121,53 +146,90 @@ function ensureLLMInitialized() {
     llmInitialized = true;
 }
 // ---------------------------------------------------------------------------
-// Qdrant REST Client
+// Qdrant REST helpers — destination-scoped
 // ---------------------------------------------------------------------------
-function getClient() {
-    if (!client) {
-        throw new Error("Qdrant client not initialized — URL missing. " +
-            "Use configure_credentials or set QDRANT_URL " +
-            "(QDRANT_API_KEY is optional for local / self-hosted instances).");
-    }
-    return client;
+export async function qdrantReq(destination, method, urlPath, body) {
+    return getPool().client(destination.name).request(method, urlPath, body);
 }
-export async function qdrantReq(method, urlPath, body) {
-    return getClient().request(method, urlPath, body);
+export async function ensureCollection(destination, indexes) {
+    await getPool().ensureCollection(destination.name, getEmbeddingDimensions(), indexes);
+    log("INFO", `Collection '${destination.collection}' (destination '${destination.name}') ready (vector size ${getEmbeddingDimensions()}, ${indexes.length} indexes)`);
 }
-export async function ensureCollection(indexes) {
-    await getClient().ensureCollection(getEmbeddingDimensions(), indexes);
-    log("INFO", `Collection '${getCollection()}' ready (vector size ${getEmbeddingDimensions()}, ${indexes.length} indexes)`);
+/** Run ensureCollection for every destination in the pool. Failures don't stop the loop. */
+export async function ensureCollectionsAll(indexes) {
+    const p = getPool();
+    const results = [];
+    for (const dest of p.destinations()) {
+        try {
+            await p.ensureCollection(dest.name, getEmbeddingDimensions(), indexes);
+            log("INFO", `Collection '${dest.collection}' (destination '${dest.name}') ready`);
+            results.push({ destination: dest, ok: true, error: null });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log("WARN", `ensureCollection failed for destination '${dest.name}': ${msg}`);
+            results.push({ destination: dest, ok: false, error: msg });
+        }
+    }
+    return results;
 }
-export async function qdrantUpsert(id, vector, payload) {
-    return qdrantReq("PUT", `/collections/${getCollection()}/points`, {
+export async function qdrantUpsert(destination, id, vector, payload) {
+    return qdrantReq(destination, "PUT", `/collections/${destination.collection}/points`, {
         points: [{ id, vector, payload }],
     });
 }
-export async function qdrantSearch(vector, filter, limit = 5) {
-    return qdrantReq("POST", `/collections/${getCollection()}/points/search`, {
+export async function qdrantSearch(destination, vector, filter, limit = 5) {
+    return qdrantReq(destination, "POST", `/collections/${destination.collection}/points/search`, {
         vector,
         filter: filter ?? undefined,
         limit,
         with_payload: true,
     });
 }
-export async function qdrantScroll(filter, limit = 10) {
-    return qdrantReq("POST", `/collections/${getCollection()}/points/scroll`, {
+export async function qdrantScroll(destination, filter, limit = 10) {
+    return qdrantReq(destination, "POST", `/collections/${destination.collection}/points/scroll`, {
         filter,
         limit,
         with_payload: true,
     });
 }
-export async function qdrantSetPayload(ids, payload) {
-    return qdrantReq("POST", `/collections/${getCollection()}/points/payload`, {
+export async function qdrantSetPayload(destination, ids, payload) {
+    return qdrantReq(destination, "POST", `/collections/${destination.collection}/points/payload`, {
         points: ids,
         payload,
     });
 }
-export async function qdrantGetPoints(ids) {
-    return qdrantReq("POST", `/collections/${getCollection()}/points`, {
+export async function qdrantGetPoints(destination, ids) {
+    return qdrantReq(destination, "POST", `/collections/${destination.collection}/points`, {
         ids,
         with_payload: true,
     });
 }
+// ---------------------------------------------------------------------------
+// Cross-destination fan-out helpers
+// ---------------------------------------------------------------------------
+/**
+ * Look up a point by ID across every destination. Returns the first hit found
+ * (and which destination it lives in), or null. Used by `memory_forget`,
+ * `memory_verify`, `memory_report_outcome`, and any other ID-based op where
+ * the caller doesn't know upfront which destination owns the ID.
+ */
+export async function findPointById(id) {
+    const p = getPool();
+    // Sequential rather than parallel: most lookups will hit the first / default
+    // destination, so we'd waste round-trips by always fanning out.
+    for (const dest of p.destinations()) {
+        try {
+            const res = await qdrantGetPoints(dest, [id]);
+            const point = res.result?.[0];
+            if (point)
+                return { destination: dest, point };
+        }
+        catch {
+            // Destination may be down; keep scanning.
+            continue;
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=api.js.map

package/dist/mcp/helpers.d.ts

@@ -11,7 +11,6 @@ export interface StructuredFact {
     domain?: string;
     kind?: string;
     memory_subtype?: string | null;
-    workspace_id?: string;
     actor_id?: string;
     source?: string;
     entities: string[];

package/dist/mcp/helpers.js

@@ -97,10 +97,9 @@ export function isStale(payload) {
 export const MEMORY_RECALL_EXCLUDED_KINDS = ["telemetry"];
 /** Build a Qdrant filter object from optional params. */
 export function buildFilter(params = {}) {
-    const { category, domain, kind, memory_subtype, workspace_id, includeLegacyWorkspace = false, actor_id, entity, session_id, episode_id, workstream_key, task_key, repo, branch, review_status, since, until, excludeSuperseded = true, excludeKinds = [], metadata, } = params;
+    const { category, domain, kind, memory_subtype, actor_id, entity, session_id, episode_id, workstream_key, task_key, repo, branch, review_status, since, until, excludeSuperseded = true, excludeKinds = [], metadata, } = params;
     const must = [];
     const must_not = [];
-    const should = [];
     if (excludeSuperseded) {
         must.push({ is_null: { key: "superseded_by" } });
     }
@@ -116,14 +115,6 @@ export function buildFilter(params = {}) {
     if (memory_subtype) {
         must.push({ key: "memory_subtype", match: { value: memory_subtype } });
     }
-    if (workspace_id) {
-        if (includeLegacyWorkspace) {
-            should.push({ key: "workspace_id", match: { value: workspace_id } }, { is_empty: { key: "workspace_id" } });
-        }
-        else {
-            must.push({ key: "workspace_id", match: { value: workspace_id } });
-        }
-    }
     if (actor_id) {
         must.push({ key: "actor_id", match: { value: actor_id } });
     }
@@ -160,11 +151,10 @@ export function buildFilter(params = {}) {
     for (const excludedKind of excludeKinds) {
         must_not.push({ key: "kind", match: { value: excludedKind } });
     }
-    if (must.length === 0 && should.length === 0 && must_not.length === 0)
+    if (must.length === 0 && must_not.length === 0)
         return undefined;
     return {
         must,
-        ...(should.length > 0 ? { should } : {}),
         ...(must_not.length > 0 ? { must_not } : {}),
     };
 }
@@ -183,8 +173,6 @@ export function formatFact(point) {
         parts.push(`kind: ${p.kind}`);
     if (p.memory_subtype)
         parts.push(`subtype: ${p.memory_subtype}`);
-    if (p.workspace_id && p.workspace_id !== "default")
-        parts.push(`workspace: ${p.workspace_id}`);
     if (p.actor_id)
         parts.push(`actor: ${p.actor_id}`);
     if (p.workstream_key)
@@ -246,7 +234,6 @@ export function structuredFact(point) {
         ...(p.domain ? { domain: p.domain } : {}),
         ...(p.kind ? { kind: p.kind } : {}),
         ...(p.memory_subtype ? { memory_subtype: p.memory_subtype } : {}),
-        ...(p.workspace_id ? { workspace_id: p.workspace_id } : {}),
         ...(p.actor_id ? { actor_id: p.actor_id } : {}),
         ...(p.source ? { source: p.source } : {}),
         entities: p.entities ?? [],

package/dist/mcp/index.js

@@ -14,18 +14,12 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { QDRANT_INDEXES } from "./taxonomy.js";
-import { log, setQdrantUrl, setQdrantApiKey, setReady, setCollection, setSetupError, ensureCollection, initEmbedding, } from "./api.js";
+import { log, rebuildPool, hasPool, setReady, setSetupError, ensureCollectionsAll, initEmbedding, } from "./api.js";
 import { registerTools } from "./tools.js";
-import { loadConfig } from "../config.js";
+import { loadConfig, getEffectiveDestinations } from "../config.js";
 export async function startMcpServer() {
     log("INFO", `Starting bikky MCP server (PID ${process.pid})`);
     const cfg = loadConfig();
-    // Resolve credentials from config (which already merges env vars)
-    const qUrl = cfg.qdrant_url?.replace(/\/+$/, "") || null;
-    const qKey = cfg.qdrant_api_key || null;
-    setQdrantUrl(qUrl);
-    setQdrantApiKey(qKey);
-    setCollection(cfg.collection);
     // Initialize embedding provider — wrapped so an unknown provider name or
     // misconfiguration produces a setup_required status instead of crashing the
     // MCP stdio transport. The server always comes up; tools degrade via
@@ -50,20 +44,41 @@ export async function startMcpServer() {
         log("ERROR", `Embedding init failed: ${msg}`);
         // Continue — server will report setup_required for memory tools.
     }
-    if (qUrl) {
+    // Build the destination pool from config. Each destination is its own
+    // QdrantClient; missing destinations leave the server in setup_required.
+    try {
+        rebuildPool();
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        setSetupError(`Destination pool init failed: ${msg}`);
+        log("ERROR", `Destination pool init failed: ${msg}`);
+    }
+    if (hasPool()) {
         try {
-            await ensureCollection(QDRANT_INDEXES);
-            setReady(true);
-            log("INFO", `Memory system ready ✓ (Qdrant ${qKey ? "with" : "without"} api-key auth)`);
+            const results = await ensureCollectionsAll(QDRANT_INDEXES);
+            const ok = results.filter((r) => r.ok);
+            const failed = results.filter((r) => !r.ok);
+            for (const r of ok) {
+                log("INFO", `Destination '${r.destination.name}' ready ✓ (${r.destination.collection})`);
+            }
+            for (const r of failed) {
+                log("ERROR", `Destination '${r.destination.name}' failed: ${r.error}`);
+            }
+            setReady(ok.length > 0);
+            if (failed.length > 0 && ok.length === 0) {
+                setSetupError(`All destinations failed to initialize. First error: ${failed[0]?.error ?? "(none)"}`);
+            }
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
             setSetupError(`Qdrant initialization failed: ${msg}`);
-            log("ERROR", `Failed to initialize collection: ${msg}`);
+            log("ERROR", `Failed to initialize collections: ${msg}`);
         }
     }
     else {
-        log("INFO", "Memory not configured — missing: qdrant-url. Use get_setup_status + configure_credentials.");
+        const dests = getEffectiveDestinations(cfg);
+        log("INFO", `Memory not configured — no destinations (got ${dests.length}). Use get_setup_status + configure_credentials.`);
     }
     const mcp = new McpServer({
         name: "bikky",

package/dist/mcp/tools.d.ts

@@ -2,12 +2,5 @@
  * MCP tool definitions for memory.
  */
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-interface WorkspaceScope {
-    workspaceId?: string;
-    actorId?: string;
-    includeLegacy: boolean;
-}
-export declare function resolveScope(workspaceId?: string, includeLegacyWorkspace?: boolean, actorId?: string): WorkspaceScope;
 export declare function registerTools(mcp: McpServer): void;
-export {};
 //# sourceMappingURL=tools.d.ts.map