@melaya/runner 1.0.70 → 1.0.72

package/dist/connection.js

@@ -1083,6 +1083,113 @@ export async function connect(opts) {
     // connector. After that, the LinkedIn pipelines (auto-like / auto-reply
     // / auto-connect) just read LINKEDIN_LI_AT / LINKEDIN_JSESSIONID from
     // env at run time and call Voyager directly with aiohttp.
+    socket.on("rag:retrieve", async (payload, ack) => {
+        const sid = payload?.sessionId;
+        if (!sid)
+            return;
+        ack?.({ ok: true });
+        const embedOnly = payload.mode === "cloud_files";
+        try {
+            const prov = (payload.embedderProvider || "").toLowerCase();
+            if (!["ollama", "lmstudio"].includes(prov)) {
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok: false,
+                    error: "runner retrieval only supports ollama or lmstudio embedders",
+                });
+                return;
+            }
+            const { ensurePythonEnv } = await import("./pythonEnv.js");
+            const env = await ensurePythonEnv(opts.pythonPath, payload.sharedVersion);
+            if (!env.ok) {
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok: false,
+                    error: `venv bootstrap failed: ${env.reason}`,
+                });
+                return;
+            }
+            await ensureSharedModules(opts.serverUrl, payload.sharedVersion);
+            const sharedDir = getSharedDir();
+            const workDir = join(tmpdir(), `melaya-rag-retrieve-${payload.pipelineName}-${Date.now()}`);
+            mkdirSync(workDir, { recursive: true });
+            const { copyFileSync, existsSync } = await import("fs");
+            const candidates = [
+                join(sharedDir, "..", "localRagRetrieve.py"),
+                join(__dirname, "localRagRetrieve.py"),
+                join(__dirname, "..", "localRagRetrieve.py"),
+            ];
+            let found = "";
+            for (const c of candidates) {
+                if (existsSync(c)) {
+                    found = c;
+                    break;
+                }
+            }
+            if (!found) {
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok: false,
+                    error: "localRagRetrieve.py not found in runner package - reinstall @melaya/runner",
+                });
+                return;
+            }
+            const stagedScript = join(workDir, "localRagRetrieve.py");
+            copyFileSync(found, stagedScript);
+            const ragCertBundle = (await import("./pythonEnv.js")).getCertBundlePath();
+            const ragSslEnv = ragCertBundle
+                ? { SSL_CERT_FILE: ragCertBundle, REQUESTS_CA_BUNDLE: ragCertBundle }
+                : {};
+            const proc = spawn(env.pythonPath, [
+                "-u", stagedScript,
+                "--pipeline-name", payload.pipelineName,
+                "--embedder-provider", prov,
+                "--embedder-model", payload.embedderModel,
+                "--query", String(payload.query || ""),
+                "--limit", String(Math.max(1, Math.min(20, Number(payload.limit ?? 5)))),
+                // Mode C: embed only, print the vector; the server does the search.
+                ...(embedOnly ? ["--embed-only"] : []),
+            ], {
+                env: {
+                    ...process.env,
+                    PYTHONPATH: sharedDir,
+                    ...ragSslEnv,
+                },
+                cwd: workDir,
+            });
+            let stdout = "";
+            let stderr = "";
+            proc.stdout.on("data", (data) => { stdout += data.toString("utf-8"); });
+            proc.stderr.on("data", (data) => { stderr += data.toString("utf-8"); });
+            proc.on("close", (code) => {
+                const jsonLine = stdout.split(/\r?\n/).map(s => s.trim()).filter(Boolean).reverse()[0] || "";
+                let parsed = null;
+                try {
+                    parsed = JSON.parse(jsonLine);
+                }
+                catch { /* handled below */ }
+                const ok = code === 0 && parsed?.ok === true;
+                socket.emit("rag:retrieve-result", {
+                    session_id: sid,
+                    ok,
+                    // Mode C (embed-only): carry the query vector; the server searches
+                    // the prod store. Mode B: carry the local search results directly.
+                    vector: embedOnly && Array.isArray(parsed?.vector) ? parsed.vector : undefined,
+                    results: Array.isArray(parsed?.results) ? parsed.results : [],
+                    store_path: parsed?.store_path,
+                    error: ok ? undefined : (parsed?.error || `runner retrieve exit ${code ?? "?"}`),
+                    stderr_tail: stderr.slice(-2000),
+                });
+            });
+        }
+        catch (e) {
+            socket.emit("rag:retrieve-result", {
+                session_id: sid,
+                ok: false,
+                error: e?.message || String(e),
+            });
+        }
+    });
     socket.on("linkedin:start-login", async (req) => {
         const sid = req?.session_id;
         if (!sid)

package/dist/localRagRetrieve.py

@@ -0,0 +1,162 @@
+"""Runner-side RAG retrieval test (local embedder paths).
+
+Two modes, selected by --embed-only:
+  * Mode B (local folder, default): the vector store lives on THIS machine
+    (~/.melaya-runner/rag/<pipeline>/store), so we embed the query AND search
+    locally, returning the matched chunks.
+  * Mode C (cloud files, --embed-only): the chunks were upserted to the
+    PROD-side store during ingest, so they are NOT on this box. We only embed
+    the query with the user's local embedder and return the raw vector; the
+    server searches the prod store by that vector (see builder
+    /docs/retrieval/search_by_vector + runnerNamespace forwarding).
+
+Either way the embedder is local (ollama / lmstudio), which is why this can't
+run server-side: prod has no LM Studio / Ollama to embed the query.
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+
+def _resolve_store_path(pipeline_name: str) -> Path:
+    return Path.home() / ".melaya-runner" / "rag" / pipeline_name / "store"
+
+
+def _build_embedder(provider: str, model: str):
+    if provider == "ollama":
+        from agentscope.embedding import OllamaTextEmbedding
+        dims = {
+            "nomic-embed-text": 768,
+            "nomic-embed-text:v1.5": 768,
+            "mxbai-embed-large": 1024,
+            "all-minilm": 384,
+            "snowflake-arctic-embed": 1024,
+        }
+        dim = dims.get(model.lower())
+        if dim is None:
+            raise ValueError(f"unknown ollama embedding model '{model}'")
+        return OllamaTextEmbedding(model_name=model, dimensions=dim, host=None)
+    if provider == "lmstudio":
+        from agentscope.embedding import OpenAITextEmbedding
+        embedder = OpenAITextEmbedding(
+            api_key="lmstudio",
+            model_name=model,
+            dimensions=768,
+            base_url="http://localhost:1234/v1",
+        )
+        original_create = embedder.client.embeddings.create
+
+        async def _lms_create(**kwargs):
+            kwargs.pop("dimensions", None)
+            return await original_create(**kwargs)
+
+        embedder.client.embeddings.create = _lms_create  # type: ignore[assignment]
+        return embedder
+    raise ValueError(f"unsupported embedder provider '{provider}'")
+
+
+def _extract_text(doc) -> str:
+    content = getattr(doc.metadata, "content", None)
+    if isinstance(content, dict):
+        return str(content.get("text") or "")
+    return str(getattr(content, "text", "") or "")
+
+
+async def _embed_only(args) -> dict:
+    """Mode C: embed the query with the user's LOCAL embedder and return the
+    raw vector. The vectors live in the prod-side store (Mode C ingest upserted
+    them there), so the SERVER does the search — this box only embeds. No store
+    is opened here."""
+    from agentscope.message import TextBlock
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    res = await embedder([TextBlock(type="text", text=str(args.query or "")[:2000])])
+    vector = list(res.embeddings[0])
+    return {"ok": True, "vector": vector}
+
+
+async def _retrieve(args) -> dict:
+    if getattr(args, "embed_only", False):
+        return await _embed_only(args)
+    store_path = _resolve_store_path(args.pipeline_name)
+    if not store_path.exists():
+        return {
+            "ok": False,
+            "error": f"runner RAG store not found: {store_path}",
+            "results": [],
+        }
+
+    import qdrant_client as _qc
+    if not getattr(_qc.AsyncQdrantClient.__init__, "_melaya_patched", False):
+        original_init = _qc.AsyncQdrantClient.__init__
+
+        def _patched_init(self, location=None, **kwargs):
+            if (
+                location
+                and location != ":memory:"
+                and "://" not in str(location)
+                and not kwargs.get("path")
+            ):
+                kwargs["path"] = location
+                location = None
+            original_init(self, location=location, **kwargs)
+
+        _patched_init._melaya_patched = True  # type: ignore[attr-defined]
+        _qc.AsyncQdrantClient.__init__ = _patched_init  # type: ignore[assignment]
+
+    from agentscope.rag import QdrantStore, SimpleKnowledge
+
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    store = QdrantStore(
+        location=str(store_path),
+        collection_name=args.pipeline_name,
+        dimensions=embedder.dimensions,
+        distance="Cosine",
+    )
+    kb = SimpleKnowledge(embedding_store=store, embedding_model=embedder)
+    docs = await kb.retrieve(
+        query=str(args.query or "")[:2000],
+        limit=max(1, min(20, int(args.limit))),
+    )
+    results = []
+    for doc in docs:
+        score = getattr(doc, "score", None)
+        results.append({
+            "source": getattr(doc.metadata, "doc_id", "?"),
+            "chunk_id": getattr(doc.metadata, "chunk_id", "?"),
+            "score": score,
+            "text": _extract_text(doc),
+        })
+    return {
+        "ok": True,
+        "store_path": str(store_path),
+        "results": results,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pipeline-name", required=True)
+    parser.add_argument("--embedder-provider", required=True, choices=["ollama", "lmstudio"])
+    parser.add_argument("--embedder-model", required=True)
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--limit", type=int, default=5)
+    # Mode C: embed the query and print {ok, vector}; do not open a local store.
+    parser.add_argument("--embed-only", dest="embed_only", action="store_true")
+    args = parser.parse_args()
+    try:
+        print(json.dumps(asyncio.run(_retrieve(args)), ensure_ascii=False))
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({
+            "ok": False,
+            "error": f"{type(exc).__name__}: {exc}",
+            "results": [],
+        }), file=sys.stdout)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/dist/localRelay.js

@@ -105,6 +105,48 @@ export function startLocalRelay(socket, verbose, serverUrl) {
                 });
                 return;
             }
+            // ── Mode C RAG search proxy ─────────────────────────────────────
+            // A runner-dispatched pipeline's `rag_retrieve` (Mode C: cloud store +
+            // local embedder) embeds the query locally then POSTs the vector to
+            // `${MEL_BUILDER_URL}/pipelines/<name>/docs/retrieval/search_by_vector`.
+            // We forward it over the authenticated socket (the runner is the trust
+            // anchor) to `runner:ragSearch`, which calls the server's
+            // _forwardSearchByVector → builder search_by_vector on the prod store.
+            const sm = req.method === "POST" && req.url
+                ? req.url.match(/^\/pipelines\/([^/]+)\/docs\/retrieval\/search_by_vector\/?$/)
+                : null;
+            if (sm) {
+                const pipelineName = decodeURIComponent(sm[1]);
+                let sbody = "";
+                req.on("data", (chunk) => { sbody += chunk.toString(); });
+                req.on("end", () => {
+                    const replyOnce = (status, body) => {
+                        if (res.headersSent)
+                            return;
+                        res.writeHead(status, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify(body));
+                    };
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(sbody || "{}");
+                    }
+                    catch {
+                        replyOnce(400, { results: [], error: "invalid_json" });
+                        return;
+                    }
+                    // Relay timeout < the pipeline's urlopen timeout (30s) so the
+                    // pipeline always gets a JSON reply rather than its own abort.
+                    const t = setTimeout(() => replyOnce(504, { results: [], error: "upstream_timeout" }), 25000);
+                    socket.emit("runner:ragSearch", { name: pipelineName, vector: parsed.vector, limit: parsed.limit }, (resp) => {
+                        clearTimeout(t);
+                        if (resp && typeof resp === "object")
+                            replyOnce(200, resp);
+                        else
+                            replyOnce(502, { results: [], error: "no_response" });
+                    });
+                });
+                return;
+            }
             if (req.method !== "POST" || req.url !== expectedPath) {
                 res.writeHead(404);
                 res.end("Not found");

package/localRagRetrieve.py

@@ -0,0 +1,162 @@
+"""Runner-side RAG retrieval test (local embedder paths).
+
+Two modes, selected by --embed-only:
+  * Mode B (local folder, default): the vector store lives on THIS machine
+    (~/.melaya-runner/rag/<pipeline>/store), so we embed the query AND search
+    locally, returning the matched chunks.
+  * Mode C (cloud files, --embed-only): the chunks were upserted to the
+    PROD-side store during ingest, so they are NOT on this box. We only embed
+    the query with the user's local embedder and return the raw vector; the
+    server searches the prod store by that vector (see builder
+    /docs/retrieval/search_by_vector + runnerNamespace forwarding).
+
+Either way the embedder is local (ollama / lmstudio), which is why this can't
+run server-side: prod has no LM Studio / Ollama to embed the query.
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+
+def _resolve_store_path(pipeline_name: str) -> Path:
+    return Path.home() / ".melaya-runner" / "rag" / pipeline_name / "store"
+
+
+def _build_embedder(provider: str, model: str):
+    if provider == "ollama":
+        from agentscope.embedding import OllamaTextEmbedding
+        dims = {
+            "nomic-embed-text": 768,
+            "nomic-embed-text:v1.5": 768,
+            "mxbai-embed-large": 1024,
+            "all-minilm": 384,
+            "snowflake-arctic-embed": 1024,
+        }
+        dim = dims.get(model.lower())
+        if dim is None:
+            raise ValueError(f"unknown ollama embedding model '{model}'")
+        return OllamaTextEmbedding(model_name=model, dimensions=dim, host=None)
+    if provider == "lmstudio":
+        from agentscope.embedding import OpenAITextEmbedding
+        embedder = OpenAITextEmbedding(
+            api_key="lmstudio",
+            model_name=model,
+            dimensions=768,
+            base_url="http://localhost:1234/v1",
+        )
+        original_create = embedder.client.embeddings.create
+
+        async def _lms_create(**kwargs):
+            kwargs.pop("dimensions", None)
+            return await original_create(**kwargs)
+
+        embedder.client.embeddings.create = _lms_create  # type: ignore[assignment]
+        return embedder
+    raise ValueError(f"unsupported embedder provider '{provider}'")
+
+
+def _extract_text(doc) -> str:
+    content = getattr(doc.metadata, "content", None)
+    if isinstance(content, dict):
+        return str(content.get("text") or "")
+    return str(getattr(content, "text", "") or "")
+
+
+async def _embed_only(args) -> dict:
+    """Mode C: embed the query with the user's LOCAL embedder and return the
+    raw vector. The vectors live in the prod-side store (Mode C ingest upserted
+    them there), so the SERVER does the search — this box only embeds. No store
+    is opened here."""
+    from agentscope.message import TextBlock
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    res = await embedder([TextBlock(type="text", text=str(args.query or "")[:2000])])
+    vector = list(res.embeddings[0])
+    return {"ok": True, "vector": vector}
+
+
+async def _retrieve(args) -> dict:
+    if getattr(args, "embed_only", False):
+        return await _embed_only(args)
+    store_path = _resolve_store_path(args.pipeline_name)
+    if not store_path.exists():
+        return {
+            "ok": False,
+            "error": f"runner RAG store not found: {store_path}",
+            "results": [],
+        }
+
+    import qdrant_client as _qc
+    if not getattr(_qc.AsyncQdrantClient.__init__, "_melaya_patched", False):
+        original_init = _qc.AsyncQdrantClient.__init__
+
+        def _patched_init(self, location=None, **kwargs):
+            if (
+                location
+                and location != ":memory:"
+                and "://" not in str(location)
+                and not kwargs.get("path")
+            ):
+                kwargs["path"] = location
+                location = None
+            original_init(self, location=location, **kwargs)
+
+        _patched_init._melaya_patched = True  # type: ignore[attr-defined]
+        _qc.AsyncQdrantClient.__init__ = _patched_init  # type: ignore[assignment]
+
+    from agentscope.rag import QdrantStore, SimpleKnowledge
+
+    embedder = _build_embedder(args.embedder_provider, args.embedder_model)
+    store = QdrantStore(
+        location=str(store_path),
+        collection_name=args.pipeline_name,
+        dimensions=embedder.dimensions,
+        distance="Cosine",
+    )
+    kb = SimpleKnowledge(embedding_store=store, embedding_model=embedder)
+    docs = await kb.retrieve(
+        query=str(args.query or "")[:2000],
+        limit=max(1, min(20, int(args.limit))),
+    )
+    results = []
+    for doc in docs:
+        score = getattr(doc, "score", None)
+        results.append({
+            "source": getattr(doc.metadata, "doc_id", "?"),
+            "chunk_id": getattr(doc.metadata, "chunk_id", "?"),
+            "score": score,
+            "text": _extract_text(doc),
+        })
+    return {
+        "ok": True,
+        "store_path": str(store_path),
+        "results": results,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--pipeline-name", required=True)
+    parser.add_argument("--embedder-provider", required=True, choices=["ollama", "lmstudio"])
+    parser.add_argument("--embedder-model", required=True)
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--limit", type=int, default=5)
+    # Mode C: embed the query and print {ok, vector}; do not open a local store.
+    parser.add_argument("--embed-only", dest="embed_only", action="store_true")
+    args = parser.parse_args()
+    try:
+        print(json.dumps(asyncio.run(_retrieve(args)), ensure_ascii=False))
+    except Exception as exc:  # noqa: BLE001
+        print(json.dumps({
+            "ok": False,
+            "error": f"{type(exc).__name__}: {exc}",
+            "results": [],
+        }), file=sys.stdout)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.70",
+  "version": "1.0.72",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,
@@ -14,11 +14,12 @@
     "dist/**/*.d.ts",
     "dist/**/*.py",
     "localRagIngest.py",
+    "localRagRetrieve.py",
     "nltk_data/**",
     "README.md"
   ],
   "scripts": {
-    "build": "tsc && node -e \"require('fs').copyFileSync('localRagIngest.py','dist/localRagIngest.py')\"",
+    "build": "tsc && node -e \"const fs=require('fs'); fs.copyFileSync('localRagIngest.py','dist/localRagIngest.py'); fs.copyFileSync('localRagRetrieve.py','dist/localRagRetrieve.py')\"",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {