claude-flow 3.7.0-alpha.49 → 3.7.0-alpha.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.49",
+  "version": "3.7.0-alpha.50",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -1186,5 +1186,98 @@ export const embeddingsTools = [
             }
         },
     },
+    // ============================================================
+    // ADR-121 Phase 9b — batch one-call RAG (alpha.50 CLI)
+    // ============================================================
+    {
+        name: 'embeddings_search_text_batch',
+        description: "Embed N text queries and search a named AnnRouter handle for each, in a single MCP call. Standard shape for question-reformulation RAG (expand one user question into N variants, retrieve top-k for each, merge). Embeddings + searches run in parallel where the backing supports it. Returns one results entry per query in input order, plus aggregate latency. For single-query use embeddings_search_text; for raw vector input use embeddings_ann_router_search.",
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                texts: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of query texts. Order preserved in results.',
+                },
+                name: { type: 'string', description: 'AnnRouter handle name.' },
+                k: { type: 'number', description: 'Nearest neighbors per query.' },
+            },
+            required: ['texts', 'name', 'k'],
+        },
+        handler: async (input) => {
+            const config = loadConfig();
+            if (!config) {
+                return { success: false, error: 'Embeddings not initialized. Run embeddings_init first.' };
+            }
+            const texts = input.texts;
+            const name = input.name;
+            const k = input.k;
+            if (!Array.isArray(texts) || texts.length === 0) {
+                return { success: false, error: 'texts must be a non-empty array' };
+            }
+            // Validate every text upfront so we don't half-embed before failing.
+            for (let i = 0; i < texts.length; i++) {
+                const t = texts[i];
+                if (typeof t !== 'string') {
+                    return { success: false, error: `texts[${i}] is not a string` };
+                }
+            }
+            const { getAnnRouterRegistry } = await import('../memory/ann-router-registry.js');
+            const registry = getAnnRouterRegistry();
+            // Stage 1 — embed all queries in parallel.
+            const embedT0 = Date.now();
+            let embeddings;
+            try {
+                embeddings = await Promise.all(texts.map(t => generateRealEmbedding(t, config.dimension)));
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    name,
+                    error: `batch embed failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+            const embeddingMs = Date.now() - embedT0;
+            // Stage 2 — search each in parallel against the named handle.
+            // Per-query errors are captured into the results entry rather
+            // than aborting the whole batch — callers see which queries
+            // succeeded and which didn't.
+            const searchT0 = Date.now();
+            const results = await Promise.all(embeddings.map(async (emb, i) => {
+                try {
+                    const hits = await registry.search(name, new Float32Array(emb), k);
+                    return { index: i, text: texts[i], success: true, hits };
+                }
+                catch (err) {
+                    return {
+                        index: i,
+                        text: texts[i],
+                        success: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    };
+                }
+            }));
+            const searchMs = Date.now() - searchT0;
+            const successCount = results.filter(r => r.success).length;
+            return {
+                success: successCount === results.length,
+                name,
+                k,
+                queryCount: texts.length,
+                successCount,
+                failureCount: results.length - successCount,
+                results,
+                latency: {
+                    embeddingMs,
+                    searchMs,
+                    totalMs: embeddingMs + searchMs,
+                    avgPerQueryMs: Math.round(((embeddingMs + searchMs) / texts.length) * 100) / 100,
+                },
+                embeddingDimension: embeddings[0]?.length,
+            };
+        },
+    },
 ];
 //# sourceMappingURL=embeddings-tools.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.49",
+  "version": "3.7.0-alpha.50",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",