archgraph-argo 0.20.2 → 0.20.3

package/argo/scripts/graph-rag/defaultSemanticRetrieval.js

@@ -240,12 +240,12 @@ async function executeWpP2Retrieval({
   const lexicalTopK = hybridTopK();
   const fusionK = rrfK();
   const fusionWeights = hybridWeights();
-  const rerank = isRerankEnabled();
+  const rerank = isRerankEnabled() && request.rerank !== false;
   const rerankOptions = rerankConfig();
   const rerankProvider = rerank ? resolveRerankProvider(configurationEvidence.configuration) : null;
   // Rerank needs a larger candidate pool than the final top-K.
   const pool = rerank ? Math.max(topK, rerankOptions.poolSize) : topK;
-  const seedsByType = {};
+  const channelSeeds = [];
   for (const channel of CHANNELS) {
     const vectorSeeds = await exhaustChannel({
       channel,
@@ -266,17 +266,27 @@ async function executeWpP2Retrieval({
       });
       seeds = fuseChannelSeeds({ vectorSeeds, lexicalSeeds, k: fusionK, limit: Math.max(pool, lexicalTopK), weights: fusionWeights });
     }
-    if (rerank && seeds.length > 1) {
-      const ordered = await rerankCandidates({
-        query: request.intent,
-        candidates: seeds,
-        provider: rerankProvider,
-        transport: composition.transport,
-        maxReturn: rerankOptions.maxReturn,
-      });
-      // fail-open: a null/empty order keeps the original ordering
-      seeds = applyRerankOrder(seeds, ordered, topK);
-    }
+    channelSeeds.push({ channel, seeds });
+  }
+  if (rerank) {
+    // Rerank every channel CONCURRENTLY: the LLM calls dominate latency and are
+    // independent, so parallelizing turns the cost from sum(channels) into
+    // ~one call. fail-open: a null/empty order keeps the original ordering.
+    const rerankedSeeds = await Promise.all(channelSeeds.map(({ seeds }) => (
+      seeds.length > 1
+        ? rerankCandidates({
+          query: request.intent,
+          candidates: seeds,
+          provider: rerankProvider,
+          transport: composition.transport,
+          maxReturn: rerankOptions.maxReturn,
+        }).then(ordered => applyRerankOrder(seeds, ordered, topK))
+        : seeds
+    )));
+    channelSeeds.forEach((entry, index) => { entry.seeds = rerankedSeeds[index]; });
+  }
+  const seedsByType = {};
+  for (const { channel, seeds } of channelSeeds) {
     seedsByType[channel.key] = seeds;
   }
   return completeSemanticResult({

package/argo/scripts/graph-rag/rerankRetrieval.js

@@ -6,9 +6,18 @@
 // the caller keeps the original ordering. Pure helpers are exported for tests.
 
 const DEFAULT_RERANK_MODEL = 'qwen-turbo';
+// Candidate pool size. The pool is the recall CEILING: a target the seed stage
+// ranks outside the pool can never be recovered by rerank, so it must NOT be
+// shrunk for speed. Keep the original 20. With DeepSeek thinking disabled a
+// single rerank call is ~flat across candidate counts (8-40 all ~1s), so a
+// larger pool costs ~nothing -- never trade recall for latency here.
 const DEFAULT_RERANK_POOL = 20;
 const DEFAULT_RERANK_RETURN = 8;
-const DEFAULT_RERANK_TIMEOUT_MS = 8000;
+// Per-call timeout. Channel reranks run concurrently, so the end-to-end rerank
+// cost is ~one timeout, not N. 3.5s keeps the whole semantic query under ~5s
+// while still letting typical calls (1-4s) complete; slower calls fail open to
+// the pre-rerank (fused) order. Overridable via ARGO_SEMANTIC_RERANK_TIMEOUT_MS.
+const DEFAULT_RERANK_TIMEOUT_MS = 3500;
 
 function rerankTimeoutMs(env = process.env) {
   const value = Number(env && env.ARGO_SEMANTIC_RERANK_TIMEOUT_MS);
@@ -110,6 +119,11 @@ async function rerankCandidates({ query, candidates, provider, transport, maxRet
     model,
     temperature: 0,
     response_format: { type: 'json_object' },
+    // DeepSeek's default is a "thinking" model: for a listwise ranking it spends
+    // 5k-10k reasoning tokens per call (measured 6-12s, highly variable) with no
+    // accuracy gain. Disable thinking for a fast, deterministic rerank
+    // (deepseek-flash: ~6s -> ~0.7s, reasoning tokens -> 0).
+    ...(provider.provider === 'deepseek' ? { thinking: { type: 'disabled' } } : {}),
     messages: [
       { role: 'system', content: 'You rank architecture elements by relevance to a query. Return ONLY JSON {"order":[ids best-first]} using only the candidate ids.' },
       { role: 'user', content: `Query: ${query}\n\nCandidates (id\\ttext):\n${list.map(candidate => `${candidate.id}\t${candidateText(candidate)}`).join('\n')}\n\nReturn up to ${Math.min(maxReturn || DEFAULT_RERANK_RETURN, list.length)} ids best-first.` },

package/argo/scripts/systemarchitecture-mcp-server.js

@@ -2801,7 +2801,7 @@ async function buildSemanticDedupAdvisory(context, mutations, dependencies) {
       const intent = [element.type, element.name, element.description]
         .filter(part => typeof part === 'string' && part.trim() !== '')
         .join(' ');
-      const retrieved = await journey.query({ purpose: 'general', intent, topK: SEMANTIC_DEDUP_TOP_K });
+      const retrieved = await journey.query({ purpose: 'general', intent, topK: SEMANTIC_DEDUP_TOP_K, rerank: false });
       const source = retrieved && (retrieved.result || retrieved.document) || retrieved;
       const subset = buildCanonicalSemanticDocumentSubset(source, context.document);
       const elements = subset && subset.status === 'passed' && subset.document

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgraph-argo",
-  "version": "0.20.2",
+  "version": "0.20.3",
   "description": "Deploy the ArchGraph ARGO toolchain, skills, and rules (schema, scripts, argo-init skill, global rule) with one command.",
   "license": "MIT",
   "bin": {