DEV Community: Ancu Corp

How We Built a 99.9% Uptime Multi-Model AI Router (Claude -> GPT-4o -> DeepSeek) in n8n Without SaaS Middleware

Ancu Corp — Tue, 29 Sep 2026 00:51:03 +0000

When running mission-critical LLM pipelines in production, relying on a single AI provider's API endpoint is an operational liability. Between Anthropic's intermittent 529 overload errors, OpenAI's sporadic rate limits (429), and vendor-specific latency spikes, hardcoded single-model integrations inevitably cause dropped workflows and frustrated users.

Many teams default to commercial AI gateway services charging $20–$100+/month just for API routing and proxying.

In this architectural walkthrough, we explain how we designed and deployed AgentFlow OS—a completely self-hosted, multi-model failover engine built on n8n with zero external database dependencies.

1. The Core Architecture: Cascading Resilience

The primary design principle is graceful degradation with deterministic schema validation:

[ Incoming Webhook / Client Request ]
                 │
                 ▼
       [ Payload Sanitizer ]
                 │
                 ▼
   ┌──► [ Primary Model: Claude 3.5 Sonnet ]
   │             │
Success?         ├─► [OK: 200] ──► [ Schema Validator ] ──► [ Response / DB ]
   │             ▼
   │       [ Fail: 429/500/529 ]
   │             │
   ├──► [ Secondary Model: GPT-4o / Mini ]
   │             │
Success?         ├─► [OK: 200] ──► [ Schema Validator ] ──► [ Response / DB ]
   │             ▼
   │       [ Fail: 429/500/Timeout ]
   │             │
   └──► [ Tertiary Model: DeepSeek V3 ]
                 │
                 ├─► [OK: 200] ──► [ Schema Validator ] ──► [ Response / DB ]
                 ▼
          [ All Failed ] ──► [ Telegram / Ops Alert & Dead-Letter Queue ]

Why this specific cascade?

Primary (Claude 3.5 Sonnet): Unmatched reasoning, nuanced code generation, and complex instruction following.
Secondary (OpenAI GPT-4o): Extremely fast token throughput, high concurrent rate limits, reliable fallback.
Tertiary (DeepSeek V3): Cost-effective emergency compute layer when Western providers experience localized outages or heavy load.

2. Implementing the Failover Logic in n8n

In standard n8n workflows, an HTTP node error terminates workflow execution. To implement true resilience:

A. Disable "Stop on Error"

Under node settings for each HTTP Request / AI Model node:

Set OnError to Continue Regular Output or route to an alternate error branch.
Inspect {{ $json.error }} or HTTP status code in the subsequent Switch node.

B. Standardized Response Normalization

Different model APIs return different JSON envelope formats. We pass outputs through a lightweight JavaScript Code Node to normalize them into a uniform internal contract:

// Normalization Code Node in n8n
const item = $input.first().json;

let content = "";
let modelUsed = "";
let tokensUsed = { prompt: 0, completion: 0 };

if (item.content && Array.isArray(item.content)) {
  // Anthropic Claude format
  content = item.content.map(c => c.text).join("");
  modelUsed = item.model || "claude-3-5-sonnet";
  tokensUsed = { prompt: item.usage?.input_tokens || 0, completion: item.usage?.output_tokens || 0 };
} else if (item.choices && item.choices[0]?.message) {
  // OpenAI / DeepSeek format
  content = item.choices[0].message.content;
  modelUsed = item.model || "gpt-4o";
  tokensUsed = { prompt: item.usage?.prompt_tokens || 0, completion: item.usage?.completion_tokens || 0 };
} else {
  throw new Error("Unrecognized API payload response structure");
}

return {
  json: {
    success: true,
    content: content.trim(),
    model_provider: modelUsed,
    usage: tokensUsed,
    timestamp: new Date().toISOString()
  }
};

3. Strict Schema Validation: Enforcing Zero-Hallucination JSON

A common pitfall with fallback models is output drift: Model B might omit a required JSON field that Model A reliably populated.

To protect downstream services (CRMs, SQL databases, email automations), we place a JSON Schema Validator immediately after response normalization:

# Standalone validation logic (runnable in Python or Node.js sandbox)
import json
from jsonschema import validate, ValidationError

EXPECTED_SCHEMA = {
    "type": "object",
    "properties": {
        "lead_name": {"type": "string"},
        "company": {"type": "string"},
        "intent_score": {"type": "integer", "minimum": 0, "maximum": 100},
        "recommended_action": {"type": "string", "enum": ["IMMEDIATE_CALL", "NURTURE_SEQUENCE", "DISQUALIFIED"]}
    },
    "required": ["lead_name", "company", "intent_score", "recommended_action"]
}

def verify_ai_output(raw_json_str: str) -> dict:
    try:
        data = json.loads(raw_json_str)
        validate(instance=data, schema=EXPECTED_SCHEMA)
        return {"valid": True, "data": data}
    except (json.JSONDecodeError, ValidationError) as e:
        return {"valid": False, "error": str(e)}

If validation fails, the workflow does not silently pass malformed data; it triggers a 1-shot self-repair prompt or cascades to the next model.

4. Operational Telemetry & Alerting

When all providers in the cascade fail or rate-limits are completely exhausted, the system automatically dispatches an emergency notification to a dedicated Telegram Ops channel with the request payload context and stack trace, while archiving the payload into a local JSON dead-letter directory for offline replay.

5. Key Takeaways & Production Assets

Zero Middleware Tax: By orchestrating directly inside n8n, you eliminate third-party SaaS proxy fees and maintain full data privacy.
Resilience by Design: Multi-tier failover guarantees your client-facing applications never show blank screens or generic 500 errors.
Deterministic Contracts: Always validate AI JSON responses against formal schemas before touching operational databases.

Resources & Production Blueprints

For teams looking to deploy production-tested automation workflows without weeks of trial and error:

AgentFlow OS (Multi-Model AI Router & Failover Engine): Direct Download on Gumroad
OmniScraper AI (Headless Lead Intelligence CLI): Direct Download on Gumroad
Complete AI Developer Automation Suite: Direct Download on Gumroad

How to turn messy e-commerce reviews into a ranked defect table (no paid API)

Ancu Corp — Mon, 28 Sep 2026 19:58:45 +0000

I kept watching merchants burn hours copy-pasting reviews from Amazon and TikTok Shop into spreadsheets, trying to figure out why a competitor's product page converts better than theirs. The reviews are right there, in public. The bottleneck is never access — it's structure.

This is a walkthrough of the architecture I use to turn a messy review wall into a clean defect table you can actually act on. No paid API, no $99/mo scraping SaaS.

The three problems nobody mentions

Most "scrape reviews" tutorials stop at getting the HTML. That's the easy 20%. The real work:

Pagination that lies. Review widgets lazy-load, virtualize, and silently cap at N pages. If you just loop ?page=1..50, you'll get the same 20 reviews fifty times and think you're done.
Signal buried in noise. 4–5 star reviews are marketing. The actionable data is in the 1–3 star complaints — and those are the ones you need to cluster, not just count.
Export that survives Excel. UTF-8 BOM or your Indonesian/Portuguese/Thai review text turns into Ã©Ã§Ã£ the moment a merchant opens the CSV.

Step 1 — Defeat the virtualized list

The reliable pattern is to scroll the container until the count stops changing, not to page-hack the URL:

def exhaust(container, expected, cap=1200):
    seen = set()
    stable = 0
    while stable < 3 and len(seen) < cap:
        nodes = container.query_selector_all("[data-review-id]")
        before = len(seen)
        for n in nodes:
            rid = n.get_attribute("data-review-id")
            seen.add(rid)
        container.scroll_by(0, 900)
        stable = stable + 1 if len(seen) == before else 0
    return len(seen)

Three consecutive no-growth scrolls = you've hit the real bottom. The stable counter is what stops you both from quitting early and from looping forever on a widget that keeps re-rendering the same nodes.

Step 2 — Turn complaints into clusters, not counts

A star histogram tells you nothing. What you want is what people are angry about. A cheap, dependency-free approach: keyword buckets over the 1–3 star text.

CLUSTERS = {
    "packaging_damage": ["crushed", "dented", "arrived broken", "box damaged"],
    "dead_on_arrival":  ["doesn't work", "not working", "defective", "dead"],
    "wrong_sizing":     ["too small", "too big", "size chart", "doesn't fit"],
    "counterfeit":      ["fake", "not original", "knockoff", "replica"],
    "courier_delay":    ["late", "never arrived", "shipping took", "stuck in transit"],
    "poor_service":     ["no reply", "rude", "refund refused", "ignored"],
}

def classify(text):
    t = text.lower()
    hits = [k for k, kws in CLUSTERS.items() if any(kw in t for kw in kws)]
    return hits or ["other"]

You don't need a transformer for this. Six buckets catch ~80% of real e-commerce complaints, run offline, and — crucially — are explainable to the merchant who's paying for the insight.

Step 3 — Export that opens correctly everywhere

import csv

def safe_csv(rows, path):
    with open(path, "w", newline="", encoding="utf-8-sig") as f:
        w = csv.writer(f)
        w.writerows(rows)

utf-8-sig writes the BOM. That single change is the difference between a deliverable a merchant can open and one they'll email you back about.

The gotcha that wasted my afternoon

Amazon's review section injects the DOM after the network goes idle. page.wait_for_load_state("networkidle") fires before the reviews exist. You need to wait for the selector, not the network:

page.wait_for_selector("[data-review-id]", timeout=15000)

If I had a dollar for every "empty result" bug that was really a race condition...

Where this gets you

Run this on 3–5 competitor products and you get a defect table like:

Cluster	Competitor A	Competitor B	Your product
Packaging damage	41	12	?
Dead on arrival	28	5	?
Wrong sizing	9	33	?

Suddenly "improve quality" becomes "fix packaging for the A-segment." That's the whole game — turning unstructured complaints into a ranked, specific action list.

I packaged the full dual-engine version of this (a Manifest V3 Chrome extension and a headless Python CLI, with the 6-cluster classifier and multi-sheet XLSX export built in) if you'd rather not rebuild it: OmniScraper AI — headless lead & review intelligence CLI.

But honestly — the three steps above will get you 80% of the way for free. Start there.

What's the messiest review source you've had to deal with? I'm curious whether TikTok Shop or Shopee is worse for hidden pagination.