crawlforge-mcp-server 5.3.0 → 5.3.1

package/README.md

@@ -238,6 +238,8 @@ export CRAWLFORGE_API_URL="https://api.crawlforge.dev"
 # and deep_research all use Ollama when no cloud key is set
 export OLLAMA_BASE_URL="http://localhost:11434"   # default; set https://ollama.com for Ollama Cloud
 export OLLAMA_DEFAULT_MODEL="gemma3:4b"            # optional; unset = pick the best installed model automatically
+                                                   # deep_research judges claims with gemma3:12b when it is installed (ollama pull gemma3:12b);
+                                                   # conflict detection is on only with that model, or a cloud provider
 export OLLAMA_EMBEDDING_MODEL="nomic-embed-text"   # default: OLLAMA_DEFAULT_MODEL; used for semantic ranking in deep_research
 export OLLAMA_API_KEY="..."                        # only for authenticated endpoints (required by Ollama Cloud; a local instance needs none)
 export DISABLE_OLLAMA="true"                       # skip Ollama entirely and use CSS/keyword fallbacks

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crawlforge-mcp-server",
-  "version": "5.3.0",
+  "version": "5.3.1",
   "mcpName": "io.github.mysleekdesigns/crawlforge-mcp-server",
   "description": "CrawlForge MCP Server - Professional Model Context Protocol server with 28 web scraping, crawling, deep-research, and autonomous-extraction tools. Returns clean Markdown and structured JSON for Claude, Cursor, and any MCP client. Defaults to local Ollama for LLM extraction (no API key needed); OpenAI/Anthropic available as opt-in. Includes a unified multi-format scrape tool, an autonomous agent, pre-built site templates, and Camoufox stealth browsing.",
   "main": "server.js",
@@ -23,6 +23,7 @@
     "test:real-world": "node test-real-world.js",
     "test:all": "bash run-all-tests.sh",
     "skills:gen": "node scripts/generate-skill-md.mjs",
+    "sweep": "node scripts/tool-sweep.mjs",
     "postinstall": "echo '\nCrawlForge MCP Server installed!\n\nQuick start: run \"npx crawlforge init\" to configure your API key, install skills, and register the MCP server with your AI clients.\nOr run \"npx crawlforge-setup\" to configure your API key only.\n'",
     "docker:build": "docker build -t crawlforge .",
     "docker:dev": "docker-compose up crawlforge-dev",

package/server.js

@@ -104,7 +104,7 @@ const taskStore = createTaskStore({ logger });
 // Create the server
 const server = new McpServer({
   name: "crawlforge",
-  version: "5.3.0",
+  version: "5.3.1",
   description: "Production-ready MCP server with 28 web scraping, crawling, and content processing tools. Features MCP Resources (crawlforge://), Prompts, Sampling fallback, Elicitation, stealth browsing, deep research, structured extraction, real Google SERP rank tracking, Reddit search via community archives, change tracking, local-LLM extraction via Ollama, unified multi-format scrape, and autonomous agent tool.",
   homepage: "https://www.crawlforge.dev",
   icon: "https://www.crawlforge.dev/icon.png",

package/src/core/ResearchOrchestrator.js

@@ -49,26 +49,17 @@ const MAX_FINDING_SHARE_PER_SOURCE = 0.4;
 // many findings have to be diverse before depth matters.
 const SUMMARY_SLICE = 5;
 
-// Pairwise contradiction judgement is OFF, and the reason is measured rather
-// than assumed. Against a live run's own claims (2026-08-28) the default local
-// model returned 29, 13 and 28 false contradictions at batch sizes 30, 8 and 1
-// — one pair per call being the worst, because with nothing to compare against
-// it affirms whatever it is shown. That is acquiescence bias, a documented and
-// general LLM failure mode. Adding the standard control for it (asking which
-// pairs are CONSISTENT and vetoing anything named by both passes) cut false
-// positives to 7 but then missed a direct negation pair outright — "X does not
-// use Y" against "X uses Y" was called consistent. At that point the signal is
-// anti-correlated with the truth.
-//
-// Zero conflicts is the honest answer: a research tool that invents
-// contradictions between sources that agree is worse than one that reports
-// none. Semantic grouping (which this replaced the lexical key with) DID make
-// detection structurally reachable — that half of the question is answered —
-// and consensus, which needed the same grouping, now works. The judgement
-// itself lives in LLMManager.findContradictions, is unit-tested, and becomes
-// useful the moment a model that can do natural-language inference is wired
-// in; a purpose-built NLI cross-encoder is the documented next step.
-const ENABLE_LLM_CONFLICT_DETECTION = false;
+// Conflict detection runs only when the judging model is one measured not to
+// invent disagreement. The default 4B local model, measured 2026-08-28 against
+// a live run's own claims, named 29, 13 and 28 non-contradictions at batch
+// sizes 30, 8 and 1; the consistency-veto control cut that to 7 but then
+// missed "X does not use Y" against "X uses Y" outright. Replaying the same
+// claims through gemma3:12b (three runs): 0 false contradictions on 27 real
+// pairs and every planted one caught. So the gate is the model, not a flag:
+// LLMManager.canJudgeContradictions() answers from JUDGEMENT_MODELS, and a
+// machine without such a model reports zero conflicts — the honest answer,
+// since a research tool that invents contradictions between sources that
+// agree is worse than one that reports none.
 
 // Contradiction checking is quadratic in a group's size, and every candidate
 // pair costs prompt tokens in the one batched call. Compare a group's most
@@ -1441,8 +1432,8 @@ export class ResearchOrchestrator extends EventEmitter {
    * sentence-shape repair for that, so there is no fallback path here.
    */
   async detectInformationConflicts(claimGroups, topic) {
-    if (!ENABLE_LLM_CONFLICT_DETECTION) return [];
     if (!this.enableLLMFeatures) return [];
+    if (!(await this.llmManager.canJudgeContradictions())) return [];
 
     const pairs = [];
     for (const group of claimGroups) {
@@ -1469,7 +1460,10 @@ export class ResearchOrchestrator extends EventEmitter {
     try {
       contradicting = await this.llmManager.findContradictions(
         candidates.map(({ a, b }) => ({ a: a.claim, b: b.claim })),
-        topic
+        topic,
+        // The judge's own default examined 30; every candidate formed here is
+        // meant to be judged, so the caps agree.
+        { maxPairs: MAX_CONFLICT_PAIRS }
       );
       this.metrics.llmAnalysisCalls++;
     } catch (error) {

package/src/core/llm/LLMManager.js

@@ -2,6 +2,7 @@ import { OpenAIProvider } from './OpenAIProvider.js';
 import { AnthropicProvider } from './AnthropicProvider.js';
 import { OllamaProvider } from './OllamaProvider.js';
 import { Logger } from '../../utils/Logger.js';
+import { isJudgementModel } from '../../utils/ollamaConfig.js';
 
 /**
  * LLM Manager
@@ -136,6 +137,25 @@ export class LLMManager {
     }
   }
 
+  /**
+   * Whether conflict detection may run: only a model measured not to invent
+   * contradictions between sources that agree is asked (JUDGEMENT_MODELS in
+   * ollamaConfig.js). A cloud provider is assumed capable — the measurement
+   * that gated this off was of a 4B local model, and cloud models were not
+   * measured; that assumption is deliberate. A pinned OLLAMA_DEFAULT_MODEL is
+   * judged by the same list, so pinning the extraction winner keeps the gate
+   * closed rather than routing around the measurement.
+   */
+  async canJudgeContradictions() {
+    if (!this.defaultProvider) return false;
+    if (this.defaultProvider !== 'ollama') return true;
+    try {
+      return isJudgementModel(await this.getProvider('ollama').resolveModel('judgement'));
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Generate embeddings with fallback support
    */
@@ -503,7 +523,8 @@ Rate these ${batch.length} sentences:`;
             systemPrompt,
             maxTokens: 100 + batch.length * 20,
             temperature: 0.1,
-            format: scoreSchema
+            format: scoreSchema,
+            role: 'judgement'
           });
 
           const cleaned = response.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
@@ -633,7 +654,8 @@ Group these ${batch.length} sentences:`;
             systemPrompt,
             maxTokens: 200 + batch.length * 10,
             temperature: 0.1,
-            format: groupSchema
+            format: groupSchema,
+            role: 'judgement'
           });
 
           const cleaned = response.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
@@ -805,7 +827,8 @@ ${question.replace('${n}', String(batch.length))}`;
                 systemPrompt,
                 maxTokens: 100 + batch.length * 6,
                 temperature: 0.1,
-                format: schema
+                format: schema,
+                role: 'judgement'
               });
 
               const cleaned = response.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();

package/src/core/llm/OllamaProvider.js

@@ -14,28 +14,37 @@ export class OllamaProvider extends LLMProvider {
     super(options);
 
     // Resolved lazily: choosing the best installed model needs an HTTP call.
+    // An explicit model applies to every role; otherwise each role resolves
+    // (and caches) its own choice.
     this.model = options.model || null;
+    this.modelByRole = new Map();
     this.embeddingModel = options.embeddingModel || process.env.OLLAMA_EMBEDDING_MODEL || null;
     this.timeout = options.timeout || 120000;
   }
 
-  /** The model to use, selecting the best installed one on first use. */
-  async resolveModel() {
-    if (!this.model) this.model = await selectOllamaModel();
-    return this.model;
+  /**
+   * The model to use, selecting the best installed one for the role on first
+   * use. Extraction and judgement have different winners — see JUDGEMENT_MODELS.
+   * @param {'default'|'judgement'} [role]
+   */
+  async resolveModel(role = 'default') {
+    if (this.model) return this.model;
+    if (!this.modelByRole.has(role)) this.modelByRole.set(role, await selectOllamaModel(role));
+    return this.modelByRole.get(role);
   }
 
   async generateCompletion(prompt, options = {}) {
-    const model = await this.resolveModel();
     const {
       maxTokens = 1000,
       temperature = 0.7,
       systemPrompt = null,
+      role = 'default',
       // 'json' constrains the model to emit a parseable object, or pass a JSON
       // Schema to constrain the shape as well. Small local models otherwise
       // wrap JSON in prose and the caller's JSON.parse fails.
       format = null
     } = options;
+    const model = await this.resolveModel(role);
 
     const messages = [];
     if (systemPrompt) {

package/src/skills/agent-skills/crawlforge-deep-research/SKILL.md

@@ -127,5 +127,10 @@ With no LLM configured, `deep_research` returns structured **raw evidence** for
 the calling assistant (e.g. Claude Code) to synthesize — this is expected, do
 not suggest adding API keys.
 
+On local Ollama, claim judgement (relevance, grouping, contradiction) uses
+`gemma3:12b` when it is installed and the extraction model otherwise; conflicts
+are reported only with that model or a cloud provider, so `conflictsFound: 0`
+on a machine without it is expected, not a failure.
+
 See [research workflows](references/workflows.md) for pipelines, depth tiers,
 and parameter detail.

package/src/utils/ollamaConfig.js

@@ -55,6 +55,32 @@ const PREFERRED_MODELS = [
   'qwen2.5:3b'
 ];
 
+/**
+ * Models measured fit to JUDGE claims — relevance to a topic, same-meaning
+ * grouping, and contradiction — as opposed to extracting fields. Measured
+ * 2026-08-28 by replaying a live deep_research run's own 136 claims through
+ * each installed model, three runs each:
+ *
+ *   gemma3:12b   0 false contradictions on 27 real pairs, 3/3 planted caught,
+ *                7-9 cross-source groups (the 4B model: 1-2 false, 0-1/3
+ *                caught, 1 group)
+ *   gemma3:4b    the extraction winner, but it scored "Playwright vs Selenium"
+ *                marketing 0.9 relevant to an anti-bot topic and put it in the
+ *                research summary
+ *   gemma4:31b   judged as cleanly as gemma3:12b but only with thinking turned
+ *                off — under the default it spends the whole token budget on
+ *                hidden reasoning and returns empty content — and it grouped so
+ *                strictly that consensus vanished. Not ranked.
+ *   gpt-oss:20b  empty content at these token budgets for the same reason,
+ *                and `think: false` makes it emit nothing at all. Not ranked.
+ *
+ * Membership here is what turns conflict detection on: a model that invents
+ * disagreement between sources that agree is worse than one that reports none,
+ * so a model absent from this list is never asked. When none is installed the
+ * judgement role falls through to the extraction ranking above.
+ */
+export const JUDGEMENT_MODELS = ['gemma3:12b'];
+
 /** Used only when Ollama cannot be reached, so the error names a real model. */
 export const FALLBACK_OLLAMA_MODEL = 'llama3.2';
 
@@ -102,9 +128,11 @@ export async function installedOllamaModels() {
  * instead would break anyone who has not pulled it, so the best *installed*
  * model is chosen, and an explicit OLLAMA_DEFAULT_MODEL always wins.
  *
+ * @param {'default'|'judgement'} [role] 'judgement' tries JUDGEMENT_MODELS
+ *   first and falls through to the extraction ranking when none is installed.
  * @returns {Promise<string>}
  */
-export async function selectOllamaModel() {
+export async function selectOllamaModel(role = 'default') {
   const explicit = process.env.OLLAMA_DEFAULT_MODEL;
   if (explicit) return explicit;
 
@@ -112,10 +140,16 @@ export async function selectOllamaModel() {
   if (installed.length === 0) return FALLBACK_OLLAMA_MODEL;
 
   const byBase = new Map(installed.map((name) => [baseName(name), name]));
-  for (const preferred of PREFERRED_MODELS) {
+  const ranking = role === 'judgement' ? [...JUDGEMENT_MODELS, ...PREFERRED_MODELS] : PREFERRED_MODELS;
+  for (const preferred of ranking) {
     const match = byBase.get(baseName(preferred));
     if (match) return match;
   }
   // Nothing recognised — use whatever is there rather than failing.
   return installed[0];
 }
+
+/** Whether a model name is one measured fit to judge contradictions. */
+export function isJudgementModel(name) {
+  return typeof name === 'string' && JUDGEMENT_MODELS.some((m) => baseName(m) === baseName(name));
+}