adaptive-memory-multi-model-router 2.14.46 → 2.14.48

package/articles/FRESH_reddit_node.md

@@ -1,198 +0,0 @@
-# 19.5 KB Node.js package that routes LLM queries with 70.32 accuracy using 5-signal keyword classification. No GPU, no ML weights, no Python dependency.
-
-r/node — I want to show you the architecture behind a routing system that classifies LLM query complexity in 0.3ms, with zero ML runtime.
-
-**GitHub:** https://github.com/Das-rebel/a3m-router
-**npm:** https://www.npmjs.com/package/adaptive-memory-multi-model-router
-
-## The problem
-
-36 LLM providers, 5 complexity tiers. Every query needs to go to the right tier or you're either wasting money (GPT-4 for "what is 2+2") or getting bad results (free model for "design a distributed consensus algorithm").
-
-The ML approach is to train a BERT classifier. But that means Python, PyTorch, model weights, GPU inference latency, and a dependency chain that doesn't belong in a Node.js service.
-
-## The architecture
-
-The router uses 5 independent scoring signals, each returning a 0-1 score. The weighted sum maps to a tier.
-
-```typescript
-// The entire routing core is this simple
-interface RoutingSignals {
-  domain: number;       // Is this a specialized domain?
-  task: number;         // What type of task?
-  structure: number;    // How complex is the query?
-  verbIntensity: number; // How demanding is the action?
-  specificity: number;  // How precise is the request?
-}
-
-function classifyQuery(query: string): RoutingSignals {
-  return {
-    domain: scoreDomain(query),       // regex patterns for code, math, legal, medical
-    task: scoreTask(query),           // keyword matching for task types
-    structure: scoreStructure(query), // parse query length, clauses, conjunctions
-    verbIntensity: scoreVerb(query),  // weighted action verb dictionary
-    specificity: scoreSpecificity(query) // n-gram analysis, technical term density
-  };
-}
-
-function route(query: string): Tier {
-  const signals = classifyQuery(query);
-  const score = weightedSum(signals, WEIGHTS);
-  return scoreToTier(score);
-}
-```
-
-### Signal 1: Domain detection
-
-```typescript
-const DOMAIN_PATTERNS: Record<string, RegExp[]> = {
-  code: [/\b(function|class|import|export|async|await|def|return)\b/gi],
-  math: [/\b(equation|integral|derivative|theorem|proof|calculate)\b/gi],
-  legal: [/\b(contract|liability|clause|statute|regulation|compliance)\b/gi],
-  medical: [/\b(diagnosis|symptom|treatment|patient|clinical|dosage)\b/gi],
-};
-
-function scoreDomain(query: string): number {
-  let maxScore = 0;
-  for (const [domain, patterns] of Object.entries(DOMAIN_PATTERNS)) {
-    const matches = patterns.reduce((sum, p) => sum + (query.match(p)?.length ?? 0), 0);
-    maxScore = Math.max(maxScore, Math.min(matches * 0.15, 1.0));
-  }
-  return maxScore;
-}
-```
-
-### Signal 2: Task indicators
-
-```typescript
-const TASK_KEYWORDS: Record<string, string[]> = {
-  summarize: ['summarize', 'tldr', 'brief', 'overview', 'recap'],
-  translate: ['translate', 'in french', 'in spanish', 'in german'],
-  debug:     ['debug', 'fix this', 'error', 'stack trace', 'not working'],
-  create:    ['write', 'create', 'generate', 'build', 'implement', 'design'],
-  analyze:   ['analyze', 'compare', 'evaluate', 'assess', 'investigate'],
-};
-
-function scoreTask(query: string): number {
-  const lower = query.toLowerCase();
-  let score = 0;
-  for (const [task, keywords] of Object.entries(TASK_KEYWORDS)) {
-    if (keywords.some(kw => lower.includes(kw))) {
-      score += taskComplexityWeight(task); // create/analyze > summarize/translate
-    }
-  }
-  return Math.min(score, 1.0);
-}
-```
-
-### Signal 3: Query structure
-
-```typescript
-function scoreStructure(query: string): number {
-  let score = 0;
-  // Multi-step queries ("first do X, then do Y")
-  score += (query.split(/\b(first|then|after|before|finally)\b/i).length - 1) * 0.2;
-  // Conditional queries ("if X then Y otherwise Z")
-  score += (query.match(/\b(if|unless|otherwise|whether)\b/gi)?.length ?? 0) * 0.15;
-  // Conjunction chains
-  score += (query.match(/\band\b/gi)?.length ?? 0) * 0.05;
-  // Query length (longer = more complex, with diminishing returns)
-  score += Math.min(query.length / 500, 0.3);
-  return Math.min(score, 1.0);
-}
-```
-
-### Signal 4: Action verb intensity
-
-```typescript
-const VERB_WEIGHTS: Record<string, number> = {
-  'reverse-engineer': 0.9, 'architect': 0.85, 'design': 0.8, 'optimize': 0.75,
-  'implement': 0.7, 'debug': 0.65, 'analyze': 0.6, 'explain': 0.3,
-  'describe': 0.25, 'list': 0.2, 'define': 0.15, 'what is': 0.1,
-};
-
-function scoreVerb(query: string): number {
-  const lower = query.toLowerCase();
-  let maxVerb = 0;
-  for (const [verb, weight] of Object.entries(VERB_WEIGHTS)) {
-    if (lower.includes(verb)) maxVerb = Math.max(maxVerb, weight);
-  }
-  return maxVerb;
-}
-```
-
-### Signal 5: Specificity
-
-```typescript
-function scoreSpecificity(query: string): number {
-  // Technical term density
-  const technicalTerms = query.match(/\b[A-Z][a-z]+[A-Z][a-z]+\b/g)?.length ?? 0; // camelCase
-  const quotedTerms = query.match(/["'][^"']+["']/g)?.length ?? 0;
-  const numbers = query.match(/\d+/g)?.length ?? 0;
-
-  // Specificity inverse: vague queries score low
-  const vagueTerms = query.match(/\b(something|anything|stuff|things|etc)\b/gi)?.length ?? 0;
-
-  return Math.min(
-    (technicalTerms * 0.15 + quotedTerms * 0.1 + numbers * 0.05) - vagueTerms * 0.2,
-    1.0
-  );
-}
-```
-
-### Weighted combination
-
-```typescript
-const WEIGHTS = { domain: 0.25, task: 0.25, structure: 0.20, verb: 0.15, specificity: 0.15 };
-
-function weightedSum(signals: RoutingSignals, w: typeof WEIGHTS): number {
-  return signals.domain * w.domain
-    + signals.task * w.task
-    + signals.structure * w.structure
-    + signals.verbIntensity * w.verb
-    + signals.specificity * w.specificity;
-}
-
-function scoreToTier(score: number): Tier {
-  if (score < 0.2) return 'free';
-  if (score < 0.4) return 'cheap';
-  if (score < 0.6) return 'mid';
-  if (score < 0.8) return 'premium';
-  return 'enterprise';
-}
-```
-
-## Results
-
-| Metric | Value |
-|--------|-------|
-|  accuracy | 70.32 |
-| Exact tier match | 64.5% |
-| Routing latency | 0.3ms |
-| Package size (gzipped) | 19.5 KB |
-| Runtime dependencies | 0 (pure TypeScript) |
-| Node.js compatibility | 18+ |
-
-## Why this works in Node.js specifically
-
-1. **No native deps.** No sharp, no node-gyp, no cmake. Installs in under a second.
-2. **No Python bridge.** No child_process spawning, no pytorch, no model downloads.
-3. **Tiny bundle.** 19.5 KB gzipped. Works in serverless, edge, Docker alpine — anywhere Node runs.
-4. **Deterministic.** Same query always routes the same way. No randomness from model inference.
-5. **Composable.** Use as SDK, CLI, REST server, OpenAI proxy, or LangChain adapter.
-
-## Other features
-
-- **Semantic cache** — trigram Jaccard similarity. "Explain React hooks" ≈ "what are React hooks". TTL configurable.
-- **Guardrails** — 17 prompt injection patterns. PII redaction (email, phone, SSN). Hallucination heuristics.
-- **Cost analytics** — per-provider, per-tier spend tracking.
-- **36 providers** — OpenAI, Anthropic, Google, Groq, Cerebras, Mistral, DeepSeek, etc.
-
-## Links
-
-- **Source:** https://github.com/Das-rebel/a3m-router
-- **npm:** https://www.npmjs.com/package/adaptive-memory-multi-model-router
-
-MIT license. Self-hosted. No account. `npm install adaptive-memory-multi-model-router` and you're routing.
-
-Would love feedback on the scoring approach — particularly from anyone who's compared keyword vs ML routing in production.

package/articles/FRESH_reddit_sideproject.md

@@ -1,72 +0,0 @@
-# [Project] Built an LLM router over a weekend. 2,775 npm downloads in 3 days from pure keyword search. Here's what I learned about npm as a growth channel.
-
-Hey r/SideProject — wanted to share something unexpected that happened with my side project and what I learned from it.
-
-## The project
-
-I built **A3M Router** — a TypeScript package that routes LLM queries to the cheapest provider that can handle them. 36 providers, 5 complexity tiers, semantic caching, injection guardrails. The whole package is 19.5 KB gzipped. MIT license, no account needed, self-hosted.
-
-Repo: https://github.com/Das-rebel/a3m-router
-npm: https://www.npmjs.com/package/adaptive-memory-multi-model-router
-
-## The surprising part: the downloads
-
-I published it on a Friday. By Monday, it had 2,775 downloads. No Product Hunt launch. No Twitter thread. No newsletter. No blog post. No "show HN" (yet). No influencers.
-
-It was **entirely from npm keyword search discovery**.
-
-People were literally searching npm for things like "llm router", "openai proxy", "llm cost", "model router", "ai gateway" — and finding the package. The npm search algorithm surfaced it, people clicked through, and the download numbers grew organically.
-
-## What I learned about npm SEO
-
-This was accidental, but here's what I think happened:
-
-**1. Package name matters more than you think.**
-
-The package name is `adaptive-memory-multi-model-router`. It's long, but it contains the actual keywords people search for: "multi model", "router". The name IS the SEO.
-
-**2. npm keyword fields are underrated.**
-
-I filled out the `keywords` array in `package.json` with every relevant search term I could think of: `llm`, `router`, `openai`, `anthropic`, `proxy`, `gateway`, `cost-optimization`, `semantic-cache`, etc. This is basically the meta tags of the npm ecosystem and most developers leave it empty or generic.
-
-**3. The README is the landing page.**
-
-npm renders your README as the package homepage. I treated it like a landing page: clear value prop at the top, quick start code, comparison table, feature list. No walls of text. Code first.
-
-**4. "Zero config" and "no account required" are conversion drivers.**
-
-Every competing LLM router I found (Helicone, Portkey, LiteLLM) requires creating an account, getting an API key from THEIR service, or running a Docker container. My package is `npm install` + set your provider keys + done. No middleman account. That friction difference matters a lot for developers evaluating options.
-
-**5. npm's search algorithm seems to weight freshness + keyword match.**
-
-The package was new and matched high-intent keywords. I think that's why it surfaced. As it ages, I expect download velocity to normalize unless people keep starring/using it.
-
-## What actually works in the package (the tech)
-
-- **70.32  accuracy** on routing (5-signal keyword classifier, no ML)
-- **61.6% cost savings** vs. using premium models for everything
-- **36 providers** (6 free, 15 cheap, 9 mid, 3 premium, 3 enterprise)
-- **Semantic cache** using trigram Jaccard similarity — catches repeat/near-duplicate queries
-- **Guardrails**: 17-pattern prompt injection detection, PII redaction, hallucination checks
-- **19.5 KB gzipped** — no ML weights, no Python dependency, pure TypeScript
-- SDKs for TypeScript and Python, plus CLI, REST API, OpenAI-compatible proxy, and LangChain adapter
-
-## What didn't work
-
-- **GitHub stars:** Still very early on stars. Downloads != stars. People install, evaluate, and move on.
-- **Documentation:** I underestimated how much people want copy-paste examples for every provider. Working on that.
-- **The name is too long.** For CLI usage, people want something shorter. Considering an alias.
-
-## Next steps
-
-- OpenAI-compatible proxy server (done, but needs docs)
-- Python SDK (done, needs PyPI publish)
-- Benchmark against RouteLLM on the same dataset
-- Proper benchmarking with independent evaluators
-
-If you're building a dev tool, **take npm keyword search seriously**. It's an organic discovery channel that most people ignore. Fill out your keywords. Write a scannable README. Make install + first-run take under 2 minutes.
-
-Happy to answer questions about the routing algorithm, the npm discovery, or the architecture.
-
-GitHub: https://github.com/Das-rebel/a3m-router
-npm: https://www.npmjs.com/package/adaptive-memory-multi-model-router

package/articles/FRESH_reddit_webdev.md

@@ -1,130 +0,0 @@
-# I built a drop-in OpenAI proxy that routes queries to the cheapest provider. 36 providers, semantic cache, 61.6% cost savings.
-
-If you're calling OpenAI for everything, you're overpaying. Most queries don't need GPT-4. A simple "explain this concept" query works fine on a free or cheap model. But manually routing each query is tedious.
-
-So I built **A3M Router** — a zero-config OpenAI-compatible proxy that automatically routes each query to the cheapest provider that can handle it.
-
-**GitHub:** https://github.com/Das-rebel/a3m-router
-**npm:** https://www.npmjs.com/package/adaptive-memory-multi-model-router
-
-## What it does
-
-You replace your OpenAI base URL with the proxy URL. That's it. The proxy analyzes each query, scores its complexity across 5 signals (domain, task type, query structure, verb intensity, specificity), and routes it to the right tier.
-
-```
-User query → Proxy → Complexity score → Provider selection → Response
-```
-
-No account needed. No API key from us. Self-hosted. MIT license.
-
-## Cost savings table (based on our benchmark)
-
-| Query type | % of traffic | Without routing | With routing | Savings |
-|-----------|-------------|----------------|-------------|---------|
-| Simple Q&A ("what is X?") | 35% | GPT-4 ($0.03/1K) | Free tier ($0) | 100% |
-| Code explanation | 20% | GPT-4 ($0.03/1K) | Cheap tier ($0.0005/1K) | 98% |
-| Summarization | 15% | GPT-4 ($0.03/1K) | Mid tier ($0.005/1K) | 83% |
-| Code generation | 15% | GPT-4 ($0.03/1K) | Mid tier ($0.005/1K) | 83% |
-| Complex reasoning | 15% | GPT-4 ($0.03/1K) | Premium ($0.03/1K) | 0% |
-
-**Overall: 61.6% cost savings** on a typical workload.
-
-## 36 providers
-
-6 free, 15 cheap, 9 mid-tier, 3 premium, 3 enterprise. Including OpenAI, Anthropic, Google Gemini, Groq, Cerebras, Mistral, DeepSeek, and more. The router maps query complexity to the appropriate tier automatically.
-
-## Quick start
-
-### As an OpenAI-compatible proxy:
-
-```bash
-npm install -g adaptive-memory-multi-model-router
-
-# Set your provider keys
-export OPENAI_API_KEY=sk-...
-export ANTHROPIC_API_KEY=sk-ant-...
-export GOOGLE_API_KEY=...
-
-# Start the proxy
-a3m-router proxy --port 8080
-```
-
-Then in your existing app, just change the base URL:
-
-```typescript
-// Before
-const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-
-// After — point to the proxy
-const openai = new OpenAI({
-  apiKey: 'any',  // proxy handles routing
-  baseURL: 'http://localhost:8080/v1'
-});
-
-// Everything else stays the same
-const response = await openai.chat.completions.create({
-  model: 'auto',  // proxy routes this
-  messages: [{ role: 'user', content: 'Explain quantum computing' }]
-});
-```
-
-### As a TypeScript SDK:
-
-```typescript
-import { A3MRouter } from 'adaptive-memory-multi-model-router';
-
-const router = new A3MRouter({
-  providers: {
-    openai: { apiKey: process.env.OPENAI_API_KEY },
-    anthropic: { apiKey: process.env.ANTHROPIC_API_KEY },
-    google: { apiKey: process.env.GOOGLE_API_KEY },
-  }
-});
-
-// Route automatically
-const result = await router.route({
-  messages: [{ role: 'user', content: 'Explain quantum computing' }]
-});
-
-console.log(result.provider);   // "google/gemini-flash" (cheap tier)
-console.log(result.content);    // the actual response
-console.log(result.cost);       // $0.00003
-```
-
-### As a Python SDK:
-
-```python
-from a3m_router import A3MRouter
-
-router = A3MRouter(providers={
-    "openai": {"api_key": os.environ["OPENAI_API_KEY"]},
-    "anthropic": {"api_key": os.environ["ANTHROPIC_API_KEY"]},
-})
-
-result = router.route(
-    messages=[{"role": "user", "content": "Explain quantum computing"}]
-)
-```
-
-## Built-in features you'd otherwise build separately
-
-- **Semantic cache** — trigram Jaccard similarity catches near-duplicate queries. "Explain React hooks" and "what are React hooks?" hit the cache. Configurable TTL.
-- **Prompt injection detection** — 17 patterns. Catches "ignore previous instructions", "you are now DAN", jailbreaks, etc.
-- **PII redaction** — Strips emails, phone numbers, SSNs before sending to providers.
-- **Cost analytics** — Track spend per provider, per tier, per day.
-
-## The routing accuracy
-
-70.32  accuracy. Meaning: it never sends a trivial query to a premium provider, and it never sends a complex reasoning task to a free model. 64.5% exact tier match.
-
-The whole routing classifier is ~200 lines of TypeScript, no ML weights, no GPU, runs in 0.3ms per query.
-
-## Links
-
-- GitHub: https://github.com/Das-rebel/a3m-router
-- npm: https://www.npmjs.com/package/adaptive-memory-multi-model-router
-- Available as: TypeScript SDK, Python SDK, CLI, REST API, OpenAI proxy, LangChain adapter
-
-MIT license. Self-hosted. No account required. 19.5 KB gzipped.
-
-Happy to answer setup questions or help with provider configuration.

package/articles/FROM_ZERO_TO_10K.md

@@ -1,107 +0,0 @@
----
-title: "From Zero to 10K Downloads: Building an Open-Source LLM Router in 2 Weeks"
-description: "The real story behind building an open-source LLM gateway that hit 10,000 npm downloads in 14 days. Spoiler: it wasn't the code."
-tags: ["opensource", "llm", "npm", "indiehackers", "sideproject"]
-date: 2026-05-28
-canonical_url: https://github.com/Das-rebel/a3m-router
----
-
-> **Ready to publish** — This article targets HackerNoon and IndieHackers audiences. Tone: personal, honest, builder-story. Length: ~1,000 words.
-
----
-
-# From Zero to 10K Downloads: Building an Open-Source LLM Router in 2 Weeks
-
-I launched an npm package on May 14th. Two weeks later, 10,024 people had downloaded it.
-
-This isn't a "growth hack" post. I didn't post on Product Hunt. I didn't run ads. I didn't have a Twitter following.
-
-What I had was a single insight that nobody else in the LLM gateway space had figured out — and a weekend of furious coding to prove it.
-
-## The Lie of Sequential Fallback
-
-Every LLM gateway on the market works the same way. You send a query, it tries Provider A. If A fails, it tries Provider B. If B fails, it tries Provider C.
-
-Tidy. Simple. Wrong.
-
-Here's what happens in production: Provider A doesn't fail cleanly. It times out after 5 seconds. Then B times out too, because it's the same class of model hitting the same bottleneck. By the time C gets your query, the user has already refreshed the page three times and opened a support ticket.
-
-I watched this cascade destroy the user experience on a production system I was running. 15-second delays for what should have been a 2-second response. Debugging was a nightmare because we couldn't tell which provider was slow and which was actually down.
-
-## The Weekend That Changed Everything
-
-I had a hypothesis: instead of trying providers one at a time, what if we ran them all at once?
-
-Not sequentially. Not with fallback chains. **Parallel execution** — fire the same query at 3 providers simultaneously, collect all responses, and pick the best one.
-
-Friday night, I started coding. Saturday morning, I had a working prototype. Sunday, I ran the first real test.
-
-The results were immediate:
-- **138ms** baseline latency (direct to provider)
-- **234ms** with the proxy (guardrails, cache, routing)
-- **62% cost savings** because I could route simple queries to free/cheap models automatically
-
-The parallel ensemble wasn't just faster. It was **more accurate**. When three models answer the same question, you can score them against each other. The ensemble consistently picked better answers than any single provider alone.
-
-By Sunday night, I had the core insight that would define the project: *nobody does parallel multi-LLM execution with result merging. Everyone does sequential fallback.*
-
-## The 10K Milestone
-
-I published to npm on May 14th. Version 0.1. No documentation. No README. The code was a mess of hardcoded provider keys and console.log debugging statements.
-
-Day 1: 12 downloads. All of them were probably me testing the install.
-
-Day 3: Someone opened an issue. A real issue, from a real person who had found the package and was trying to use it.
-
-I panicked. Then I fixed the bug. Then I wrote a proper README.
-
-Days 5-7: 200 downloads. Someone on Reddit mentioned it in a comment. I have no idea who. I tried to find the thread later and couldn't. An anonymous internet ghost sent 200 developers to my repo.
-
-Day 10: 2,500 downloads. I shipped daily updates. Small things: fixing error messages, adding provider configurations, writing better examples.
-
-Day 14: 10,024 downloads. A week later, the weekly run rate hit 5,369 — top 0.2% of all npm packages.
-
-## What Actually Worked
-
-I learned a few things that aren't in the growth playbooks:
-
-**Open source IS distribution.** I didn't need to "market" anything. I needed to make something that solved a real pain point and put it where developers look for solutions — GitHub, npm, and Google. The README was my landing page. The install command was my CTA.
-
-**Benchmarks matter more than features.** The first week, I spent more time running benchmarks than writing code. The question every developer asks is "how fast is it?" and "how much will it save me?" I published real numbers from real API calls: 138ms baseline, 70.32 routing accuracy, 62% cost savings. Those numbers drove more downloads than any feature.
-
-**Ship every day.** A new version every 24 hours isn't noise — it's proof of life. It tells users "this project is active, bugs get fixed, new things get added." I published 14 versions in 14 days.
-
-## The Numbers That Matter
-
-| Metric | Value |
-|--------|-------|
-| Weekly downloads | 5,369 (top 0.2% of npm) |
-| 14-day run rate | 10,024 |
-| Daily average | 716 |
-| Cost savings | 62% vs all-premium |
-| Providers supported | 47+ |
-| Routing accuracy | 70.32 |
-| Package size | 19.5 KB |
-
-## What's Next
-
-The project is called **A3M Router** (adaptive-memory-multi-model-router). It's open source under MIT.
-
-I'm building three things next:
-
-1. **MCP server** — so AI agents (Claude Code, Cursor) can ask A3M "which provider should I use for this query?" and get a routing decision in <1ms
-2. **LangChain integration** — drop-in replacement for LangChain's model routing
-3. **Confidence voting** — weighted ensemble merging where each provider's past accuracy influences its vote weight
-
-The MCP server is the one I'm most excited about. AI agents burn through API calls. Every decision loop spawns 5-10 LLM queries. A smart router can cut that cost in half and make agents resilient to provider outages.
-
-## Try It
-
-```bash
-npm install -g adaptive-memory-multi-model-router
-npx a3m-router serve
-```
-
-Or check the repo: [github.com/Das-rebel/a3m-router](https://github.com/Das-rebel/a3m-router)
-
-Star it if it saves you money. That's how open source grows.