adaptive-memory-multi-model-router 2.14.45 → 2.14.47

package/articles/hackernews-show-hn.md

@@ -1,54 +0,0 @@
-Show HN: A3M Router — 82.5% routing accuracy without ML. Matches RouteLLM's BERT within 2.5%
-
-RouteLLM trains a BERT classifier on GPU. Gets 85% routing accuracy.
-We use keyword matching in Node.js. Get 82.5%.
-
-97% of the accuracy. 3% of the compute. 30x more efficient.
-
-Two LLM routers have published benchmarks: RouteLLM and us.
-LiteLLM (47K stars) publishes zero routing accuracy data.
-
-The Numbers
------------
-|                    | RouteLLM (BERT) | A3M Router |
-|--------------------|------------------|------------|
-| Accuracy (±1 tier) | 85%             | 82.5%      |
-| ML dependencies    | PyTorch + GPU   | None       |
-| Model size         | ~500MB          | 0 bytes    |
-| Install size       | ~2GB+           | 3MB        |
-| Cold start         | ~3s             | ~50ms      |
-
-No neural network. No training loop. No GPU. 139 keywords, 12 complexity signals, 40 provider profiles.
-
-How it works:
-```javascript
-// Simple Q&A -> free provider ($0.00)
-router.route("What is 2+2?");
-
-// Code -> fast provider ($0.0004)
-router.route("Write Python to reverse a string");
-
-// Complex -> quality provider ($0.03)
-router.route("Analyze this legal contract");
-```
-
-Cost savings: 63.7% average reduction. Drop-in OpenAI proxy at localhost:8787.
-
-Growth:
-- Day 1: 552 downloads
-- Day 2: 320 downloads
-- Day 3: 1,903 downloads
-- 245% growth, zero marketing budget
-
-Install:
-```bash
-npm install adaptive-memory-multi-model-router
-npx a3m-router route "Your query"
-npx a3m-router benchmark
-```
-
-40 providers. Semantic cache. Circuit breakers. Real-time cost dashboard. 3MB.
-
-GitHub: https://github.com/Das-rebel/a3m-router
-
-The question I keep coming back to: if keyword matching gets you 97% of GPU-trained BERT accuracy, is the GPU worth it?

package/articles/hashnode-llm-cost-optimization.md

@@ -1,125 +0,0 @@
----
-title: "How I Reduced LLM API Costs by 70% with Smart Routing"
-domain: hashnode.com
-tags: llm, ai, cost-optimization, javascript, openai, groq
----
-
-# How I Reduced LLM API Costs by 70% with Smart Routing
-
-After our startup's OpenAI bill hit $2,400 in one month, I knew we needed a better solution. Here's how we built an intelligent routing system that cut costs by 70% while maintaining quality.
-
-## The Problem
-
-We were using GPT-4 for everything:
-- Simple Q&A → GPT-4 ($0.03 per query)
-- Code generation → GPT-4 ($0.05 per query)
-- Text summarization → GPT-4 ($0.02 per query)
-
-**Monthly cost: $2,400+**
-
-## The Insight
-
-Not every query needs GPT-4. Simple questions work fine with cheaper models. Code generation works great with Groq's Llama. Summarization can use Mistral's small model.
-
-## The Solution: A3M Router
-
-We built (and open-sourced) `adaptive-memory-multi-model-router` - a learned routing system that automatically selects the optimal provider.
-
-### How It Works
-
-```javascript
-const { routeQuery } = require('adaptive-memory-multi-model-router');
-
-// Simple query → cheapest provider (free)
-routeQuery("What is 2+2?");
-// → commandcode/taste-1 ($0.00)
-
-// Code query → fast, code-capable provider
-routeQuery("Write Python to reverse a string");
-// → groq/llama-3.3-70b ($0.0004)
-
-// Complex reasoning → high-quality provider
-routeQuery("Explain quantum entanglement");
-// → mistral/mistral-large ($0.002)
-```
-
-### The Algorithm
-
-1. **Feature Extraction**: Analyze the query
-   - Code patterns? (function, class, import)
-   - Math notation? (∫, ∑, √)
-   - Language? (multilingual detection)
-   - Complexity? (length + patterns)
-
-2. **Model Scoring**: Each provider has a profile
-   ```javascript
-   {
-     cost_per_1k_input: 0.59,
-     cost_per_1k_output: 0.79,
-     latency_ms: 400,
-     quality_score: 0.82,
-     strengths: ["fast", "coding"]
-   }
-   ```
-
-3. **Smart Selection**: Weight quality vs cost based on complexity
-   - Simple queries (< 0.5 complexity) → 70% cost weight
-   - Complex queries (> 0.6 complexity) → 70% quality weight
-
-## Results
-
-| Metric | Before | After | Savings |
-|--------|--------|-------|---------|
-| Monthly Cost | $2,400 | $720 | **70%** |
-| Avg Cost/Query | $0.03 | $0.009 | **70%** |
-| Response Time | 2.1s | 0.8s | **62%** |
-| Quality Score | 100% | 94% | **6%** |
-
-## Implementation
-
-```bash
-npm install adaptive-memory-multi-model-router
-```
-
-```javascript
-const { createA3MRouter } = require('adaptive-memory-multi-model-router');
-
-const router = createA3MRouter();
-
-// Automatic routing
-const result = await router.route(userQuery);
-const response = await callProvider(result.primary_model, userQuery);
-```
-
-## Supported Providers
-
-- **Free**: CommandCode, OpenCode
-- **Fast/Cheap**: Groq ($0.59/1M tokens), Cerebras ($0.60/1M)
-- **Quality**: Mistral, OpenAI, Anthropic
-- **Local**: Ollama, vLLM (free!)
-
-## Key Features
-
-✅ **Learned Routing** - RouteLLM-style optimization
-✅ **Cost Tracking** - Real-time spend monitoring
-✅ **Fallback** - Automatic retry with backup providers
-✅ **Batch Processing** - Parallel execution
-✅ **Caching** - RadixAttention-style prefix caching
-✅ **CLI Tools** - 15 commands for operations
-
-## Try It
-
-```bash
-npx a3m-router route "Your query here"
-npx a3m-router benchmark
-```
-
-## Links
-
-- NPM: https://www.npmjs.com/package/adaptive-memory-multi-model-router
-- GitHub: https://github.com/Das-rebel/a3m-router
-- Weekly Downloads: 872+ and growing
-
----
-
-*What's your LLM cost optimization strategy? Share in the comments!*

package/articles/hn_show_2026_05.md

@@ -1,11 +0,0 @@
-Three LLM infrastructure problems nobody's fixing properly:
-
-**1. Your bill is unnecessarily high.** Devs are already switching — one cancelled both Claude Code Pro and ChatGPT Pro because Kimi K2.6 is "just as good for side projects at a crazy low price." We automated that decision query-by-query. 62% savings.
-
-**2. Sequential fallback gives you the first answer, not the best.** Every gateway does try-A-fail-try-B. Someone already built `ai-retry` as a library because this is such a common hack. We run providers in parallel, score results, return the best with reasoning.
-
-**3. "Negligible overhead" with zero data.** Every gateway says this. We published third-party benchmarks via llm-gateway-bench: 138ms → 374ms. Real numbers you can reproduce.
-
-19.5 KB. 47 providers. Zero ML dependencies. 10K downloads in 14 days, zero marketing.
-
-https://github.com/Das-rebel/a3m-router

package/articles/medium-building-llm-router.md

@@ -1,205 +0,0 @@
----
-title: Building a Production-Ready LLM Router: Lessons from 872 Weekly Downloads
-subtitle: How we created an intelligent routing system that optimizes cost vs quality for multi-provider LLM applications
----
-
-# Building a Production-Ready LLM Router: Lessons from 872 Weekly Downloads
-
-After 18 versions and 872 weekly downloads on npm, here's what we learned building `adaptive-memory-multi-model-router` - a learned LLM routing system for production applications.
-
-## Why LLM Routing Matters
-
-Most applications use a single LLM provider (usually OpenAI). This is expensive and suboptimal:
-
-- **Cost**: GPT-4 costs $0.03/1K tokens. Groq costs $0.59/1M tokens (50x cheaper).
-- **Latency**: Some providers are 10x faster for specific tasks.
-- **Reliability**: Single provider = single point of failure.
-- **Quality**: Different models excel at different tasks.
-
-## The Architecture
-
-```
-Query → Feature Extraction → Router → Provider Selection → Execution
-         ↓                      ↓              ↓
-    Code? Math?          Cost/Quality    Fallback Chain
-    Translation?         Tradeoff        Health Checks
-```
-
-### 1. Feature Extraction
-
-We analyze queries for:
-- **Code patterns**: function, class, import, def
-- **Math notation**: ∫, ∑, √, equations
-- **Language**: Multilingual detection (Chinese, Japanese, etc.)
-- **Task type**: translation, creative writing, reasoning
-- **Complexity**: Length + pattern density
-
-### 2. Model Profiles
-
-Each provider model has a profile:
-
-```javascript
-{
-  name: "groq/llama-3.3-70b",
-  provider: "groq",
-  cost_per_1k_input: 0.59,
-  cost_per_1k_output: 0.79,
-  latency_ms: 400,
-  quality_score: 0.82,
-  strengths: ["fast", "coding"],
-  context_window: 128000
-}
-```
-
-### 3. Routing Algorithm
-
-Inspired by RouteLLM (arXiv:2404.06035):
-
-```javascript
-// Complexity-weighted scoring
-if (complexity < 0.5) {
-  // Simple query → prioritize cost
-  score = quality * 0.3 + cost_efficiency * 0.7;
-} else {
-  // Complex query → prioritize quality
-  score = quality * 0.7 + cost_efficiency * 0.3;
-}
-```
-
-## Key Design Decisions
-
-### 1. Generic Provider System
-
-Users can add any provider without code changes:
-
-```json
-// ~/.config/a3m-router/providers.json
-{
-  "providers": {
-    "my-provider": {
-      "baseUrl": "https://api.myprovider.com",
-      "apiKeyEnv": "MY_API_KEY",
-      "models": ["my-model"],
-      "type": "api"
-    }
-  }
-}
-```
-
-### 2. Learned vs. Rule-Based
-
-We started with rule-based routing (if code → use provider X). It didn't scale.
-
-Now we use learned routing:
-- Online learning from actual performance
-- Quality ratings from user feedback
-- Latency updates from real measurements
-
-### 3. Cost Tracking
-
-Real-time spend monitoring:
-
-```javascript
-const router = createA3MRouter();
-const summary = router.costTracker.getSummary();
-
-console.log(`Total: $${summary.totalSpent}`);
-console.log(`By provider:`, summary.byProvider);
-console.log(`Daily:`, summary.daily);
-```
-
-## Production Features
-
-### Circuit Breakers
-
-```javascript
-const router = createA3MRouter({
-  circuitBreaker: {
-    failureThreshold: 5,
-    resetTimeout: 60000
-  }
-});
-```
-
-### Response Caching
-
-RadixAttention-style prefix caching:
-
-```javascript
-const router = createA3MRouter({
-  cache: {
-    ttl_seconds: 3600,
-    maxSize: 1000
-  }
-});
-```
-
-### Batch Processing
-
-```javascript
-const queries = ["Q1", "Q2", "Q3"];
-const results = routeBatch(queries, {
-  concurrency: 5,
-  same_model: true
-});
-```
-
-## Results
-
-| Metric | Value |
-|--------|-------|
-| Weekly Downloads | 872 |
-| Daily Average | 320 |
-| Test Coverage | 33 tests |
-| Providers Supported | 12 |
-| Keywords | 139 |
-| Integrations | 116 |
-
-## Usage
-
-```bash
-npm install adaptive-memory-multi-model-router
-```
-
-```javascript
-const { createA3MRouter } = require('adaptive-memory-multi-model-router');
-
-const router = createA3MRouter();
-
-// Route to optimal provider
-const result = await router.route("Write Python to sort an array");
-console.log(result.primary_model);  // "groq/llama-3.3-70b"
-console.log(result.estimated_cost);   // $0.0004
-
-// Batch processing
-const results = router.routeBatch(queries);
-
-// Cost tracking
-const summary = router.costTracker.getSummary();
-```
-
-## CLI
-
-```bash
-npx a3m-router providers      # List providers
-npx a3m-router route "query"  # Route query
-npx a3m-router benchmark      # Compare providers
-npx a3m-router status         # System status
-```
-
-## What's Next
-
-1. **More providers**: Adding Together AI, AI21, Cohere
-2. **Fine-tuned routing**: Per-user routing preferences
-3. **Streaming optimization**: Latency-optimized streaming
-4. **Multi-modal**: Image, audio routing
-
-## Links
-
-- NPM: https://www.npmjs.com/package/adaptive-memory-multi-model-router
-- GitHub: https://github.com/Das-rebel/a3m-router
-- Weekly Downloads: 872+
-
----
-
-*Have you built LLM routing systems? What approaches worked for you?*

package/articles/reddit-ml.md

@@ -1,76 +0,0 @@
-[P] A3M Router achieves 82.5% routing accuracy with keyword matching — matches RouteLLM's BERT classifier (85%) without GPU
-
-Hi r/MachineLearning,
-
-We benchmarked our keyword-matching LLM router against RouteLLM's GPU-trained BERT classifier. The results surprised us.
-
-**Benchmark comparison:**
-
-| Metric | RouteLLM (BERT) | A3M Router (Keywords) |
-|--------|------------------|------------------------|
-| Accuracy (±1 tier) | 85% | 82.5% |
-| ML required | Yes (PyTorch + CUDA) | No |
-| Model size | ~500MB BERT | 0 bytes |
-| GPU required | Yes | No |
-| Cold start | ~3s (model load) | ~50ms |
-| Install size | ~2GB+ | 3MB |
-| Runtime | Python | Node.js |
-
-2.5% accuracy gap. Zero ML infrastructure.
-
-**Context:**
-RouteLLM (from UC Berkeley, arXiv:2404.06035) trains a BERT classifier to route LLM queries between tiers. It's the gold standard for published LLM routing benchmarks.
-
-We implemented routing via keyword-based feature extraction: 139 keywords, 12 complexity signals, heuristic scoring. No training loop, no gradient updates, no neural network.
-
-**Routing algorithm:**
-```javascript
-// Feature extraction
-const features = extractQueryFeatures(query);
-// { has_code: true, complexity: 0.6, task_type: "code_gen" }
-
-// Complexity-weighted scoring
-if (features.complexity < 0.5) {
-  score = cost_efficiency * 0.7 + quality * 0.3;
-} else if (features.has_code) {
-  score = speed * 0.4 + quality * 0.4 + cost * 0.2;
-} else {
-  score = quality * 0.7 + cost_efficiency * 0.3;
-}
-```
-
-**Why this matters for the ML community:**
-
-1. **Benchmark transparency**: There are exactly two LLM routers with published routing accuracy: RouteLLM and us. LiteLLM (47K GitHub stars) publishes zero accuracy data. If the most popular tool won't tell you how often it's right, something is wrong.
-
-2. **Efficiency question**: Is a 2.5% accuracy improvement worth requiring PyTorch, CUDA, a GPU, 500MB model download, and 3-second cold starts? For many production deployments, the answer is no.
-
-3. **The 30x story**: 97% of the accuracy at 3% of the compute. That's a 30x efficiency multiplier.
-
-**Cost results:**
-- 63.7% average cost reduction vs single-provider routing
-- 40 provider integrations
-- Drop-in OpenAI-compatible proxy (localhost:8787)
-
-**Growth (organically, zero marketing):**
-- Day 1: 552 downloads
-- Day 2: 320 downloads
-- Day 3: 1,903 downloads
-- 245% growth, zero budget
-
-**Questions for the community:**
-
-1. What benchmark methodology should we use for a more rigorous comparison? We used the same ±1 tier accuracy metric as RouteLLM's paper.
-2. Has anyone else compared simple heuristic routing vs learned routing for LLM query classification? The gap seems smaller than expected.
-3. What accuracy threshold would you need to see to trust keyword-based routing in production?
-
-**Try it:**
-```bash
-npm install adaptive-memory-multi-model-router
-npx a3m-router route "Write Python to sort an array"
-npx a3m-router benchmark
-```
-
-GitHub: https://github.com/Das-rebel/a3m-router
-
-The honest caveat: this is a young project (3 days since launch). The 82.5% number is from our benchmark suite, not an independent evaluation. We welcome scrutiny and would love to see third-party replication.

package/articles/twitter-thread-cost-savings.md

@@ -1,50 +0,0 @@
-1/7 Three LLM infrastructure problems that keep coming up:
-
-• Your bill is 3x higher than it needs to be  
-• Sequential fallback gives you one answer, never the best  
-• Every gateway says "negligible overhead" — zero data  
-
-We built the thing that fixes all three.
-
-2/7 A dev on X: "Cancelled both my Claude Code Pro and ChatGPT Pro. Kimi K2.6 is just as good for side projects. Price is crazy low."
-
-Another: "Vectorized 27K notes for $0.07. That's pretty amazing."
-
-Everyone's looking for cheaper options. The hard part is doing it per-query without wasting time.
-
-We route every query to the cheapest capable model. 62% savings. Measured.
-
-3/7 Every LLM "router" does: try A → fail → try B → fail → try C.
-
-You always get whatever A gave you. Nobody runs them all and picks the best.
-
-Someone already built `ai-retry` just for the fallback part — that's how common this pain is.
-
-We run all providers in parallel. Score results. Return the best answer. With reasoning why it won.
-
-4/7 "Negligible overhead" — every gateway claims this. Zero publish numbers.
-
-We ran ours through llm-gateway-bench (third-party, not our tool) and published everything.
-
-Direct: 138ms  
-Through A3M: 374ms
-
-236ms overhead. Real. Documented. Runs 62% cheaper.
-
-5/7 The numbers since we shipped:  
-10,024 downloads in 14 days.  
-72 versions.  
-Zero marketing.  
-47 providers.  
-19.5 KB.  
-Zero ML dependencies.
-
-6/7 npm install adaptive-memory-multi-model-router  
-npx a3m-router serve
-
-Point any OpenAI SDK at localhost:8787. Works.
-
-7/7 GitHub: github.com/Das-rebel/a3m-router  
-Benchmarks: third-party via llm-gateway-bench 
-
-Built because the existing stuff didn't fix the actual problems.