adaptive-memory-multi-model-router 1.2.2 → 1.3.1

package/tmlpd-pi-extension/skill/SKILL.md

@@ -0,0 +1,238 @@
+---
+name: tmlpd
+description: Research-backed Multi-LLM Router with parallel execution, streaming, caching, token compression (ISON), local provider support (Ollama/vLLM/LM Studio), batch processing. Based on arXiv research: RouteLLM routing, RadixAttention prefix caching, Medusa/EAGLE speculative decoding. Python bindings for LangChain/LlamaIndex/AutoGen/CrewAI. 120+ keywords for LLM/ML discoverability. Use for multi-model comparison, cost optimization, batch processing, local privacy, context compression, adaptive routing.
+---
+
+# TMLPD PI Extension
+
+**Research-backed Multi-LLM Router** with advanced optimization features.
+
+## Direct Imports (TypeScript)
+
+```typescript
+import {
+  createTMLPD,           // Core instance
+  HALOOrchestrator,      // Hierarchical orchestration
+  EpisodicMemoryStore,    // Learn from past tasks
+  // Advanced Routing (RouteLLM-style)
+  routeQuery,            // Learned routing decision
+  routeBatch,            // Batch routing
+  extractQueryFeatures,   // Feature extraction
+  MODEL_PROFILES,         // Model cost/quality profiles
+  // Prefix Cache (RadixAttention-style)
+  PrefixCache,           // 5-10x speedup for shared prompts
+  createWarmedCache,     // Pre-warmed cache
+  // Speculative Decoding (Medusa/EAGLE)
+  SpeculativeDecoder,     // 2-3x faster generation
+  estimateSpeedupPotential,
+  // Compression
+  isonEncode,            // 20-40% token reduction
+  truncateMessages,      // Context window management
+  // Local providers
+  createOllamaProvider,  // Ollama
+  createVLLMProvider,    // vLLM
+  // Batch processing
+  BatchProcessor,        // Priority queuing
+  TMLPD_PI_TOOLS         // 13 PI tool definitions
+} from "tmlpd-pi";
+```
+
+## Direct Imports (Python)
+
+```python
+from tmlpd import (
+    TMLPDLite,       # Lite client (sync, no deps)
+    TMLPDClient,     # Async production client
+    TaskType,        # CODING, FAST, PREMIUM, etc.
+    quick_process    # One-liner function
+)
+```
+
+## 13 PI Tools
+
+| Tool | Input | Output |
+|------|-------|--------|
+| `tmlpd_execute` | `{prompt, models?}` | `{content, model, cost}` |
+| `tmlpd_execute_single` | `{prompt, model?}` | `{content, model}` |
+| `tmlpd_cost_summary` | `{}` | `{total_cost, by_provider}` |
+| `tmlpd_cache_stats` | `{}` | `{hits, misses, hit_rate}` |
+| `tmlpd_provider_status` | `{}` | `{ready_providers}` |
+| `tmlpd_invalidate_cache` | `{model?}` | `{invalidated}` |
+| `tmlpd_get_budget` | `{}` | `{daily, monthly}` |
+| `tmlpd_halo_execute` | `{task, max_concurrent?}` | `{success, results}` |
+| `tmlpd_episodic_query` | `{task, limit?}` | `EpisodicEntry[]` |
+| `tmlpd_count_tokens` | `{text, model?}` | `{tokens}` |
+| `tmlpd_compress_context` | `{messages, strategy?}` | `{compressed, ratio}` |
+| `tmlpd_local_generate` | `{prompt, runtime, model?}` | `{content, cost:0}` |
+| `tmlpd_batch_execute` | `{prompts, concurrency?}` | `BatchResult[]` |
+
+## Research-Backed Features (arXiv)
+
+### RouteLLM-Style Learned Routing (arXiv:2404.06035)
+
+```typescript
+// Automatic cost-quality tradeoff routing
+const decision = routeQuery('Write a Python async function');
+// Returns: { primary_model, fallback_models, confidence, reasoning }
+
+const features = extractQueryFeatures(prompt);
+// Extracts: complexity, has_code, has_math, is_multilingual, etc.
+
+// MODEL_PROFILES contains cost/latency/quality for each provider
+console.log(MODEL_PROFILES['openai/gpt-4o'].quality_score);  // 0.95
+```
+
+| Model | Quality | Latency | Best For |
+|-------|---------|---------|----------|
+| gpt-4o | 0.95 | 2000ms | reasoning |
+| gpt-4o-mini | 0.85 | 500ms | fast |
+| claude-3.5-sonnet | 0.96 | 2500ms | creative |
+| gemini-2.0-flash | 0.88 | 800ms | multilingual |
+| groq/llama-3.3-70b | 0.82 | 400ms | fast/budget |
+
+### RadixAttention-Style Prefix Caching (arXiv:2312.07104)
+
+```typescript
+// 5-10x speedup for shared system prompts
+const cache = new PrefixCache({ max_entries: 10000 });
+cache.warmup([
+  "You are a helpful assistant.",
+  "You are a coding assistant.",
+  "Analyze the following code..."
+]);
+
+// Automatic prefix matching
+const result = cache.lookup("You are a helpful assistant. Please explain...");
+// Returns cached if prefix matches
+
+const stats = cache.getStats();
+// { total_entries, hit_rate, memory_estimate_mb }
+```
+
+### Medusa/EAGLE Speculative Decoding (arXiv:2401.10774)
+
+```typescript
+// 2-3x faster generation with same quality
+const decoder = new SpeculativeDecoder();
+const result = await decoder.decode(
+  prompt,
+  fastModelFn,    // Draft model
+  slowModelFn,    // Target model
+  5               // Max draft tokens
+);
+// { accepted, rejected, speedup, final_text }
+
+const speedup = estimateSpeedupPotential(100, 200, 50, 200);
+// Returns estimated speedup (capped at 3x)
+```
+
+## Token Utilities
+
+```typescript
+// Count tokens (no API call)
+const tokens = countTokens("Your prompt", "claude-3.5-sonnet");
+
+// Estimate cost before execution
+const cost = estimateCost(500, 200, "gpt-4o");  // $0.0095
+
+// Find cheapest models for task
+const cheap = findCheapestModels("fast", 3);
+```
+
+## ISON Compression (20-40% token reduction)
+
+```typescript
+// Remove articles, normalize whitespace
+const encoded = isonEncode("The quick brown fox jumps over the lazy dog");
+// "quick brown fox jumps lazy dog"
+
+// Truncate long conversations
+const truncated = truncateMessages(messages, 4000, "smart");
+```
+
+## Local LLM Support
+
+```typescript
+// Zero cost, privacy-preserving
+const ollama = createOllamaProvider("llama-3.3-70b");
+const vllm = createVLLMProvider("http://localhost:8000");
+
+// Parallel across local + cloud
+const results = await manager.executeParallel("Prompt", {
+  models: ["ollama/llama-3.3-70b", "openai/gpt-4o"]
+});
+```
+
+## Batch Processing
+
+```typescript
+const batch = new BatchProcessor({ concurrency: 5 });
+batch.add({ prompt: "Task 1", priority: "high" });
+batch.add({ prompt: "Task 2", priority: "normal" });
+batch.onProgress((progress, result) => {
+  console.log(`Completed: ${progress.completed}/${progress.total}`);
+});
+await batch.execute(executor);
+```
+
+## Python Task Routing
+
+```python
+from tmlpd import TMLPDLite, TaskType
+
+lite = TMLPDLite()
+task = lite.classify_task("Write Python async function")
+# TaskType.CODING
+
+models = lite.get_optimal_models(task, 3)
+# ["codex", "claude-minimax", "claude"]
+```
+
+| TaskType | Keywords | Models |
+|----------|----------|--------|
+| CODING | python, javascript, code | codex, claude-minimax |
+| FRONTEND | react, vue, component | codex, claude-minimax |
+| CHINESE | 中文, 汉语 | claude-glm, claude-minimax |
+| FAST | quick, simple | gemini, claude-haiku |
+
+## Framework Integrations
+
+```python
+# LangChain
+class TMLPDLLM(BaseLLM):
+    def _call(self, prompt): return lite.process(prompt)["content"]
+
+# LlamaIndex
+class TMLPDLLM(LLM):
+    def complete(self, prompt): return lite.process(prompt)["content"]
+
+# AutoGen
+class TMLPDAgent(AssistantAgent):
+    def generate_reply(self, messages):
+        return lite.process(messages[-1]["content"])["content"]
+```
+
+## 120+ Keywords for Discoverability
+
+```
+routellm, prefix-caching, radix-attention, speculative-decoding, medusa, eagle,
+flashattention, pagedattention, kv-cache-quantization, llmlingua, streamingllm,
+tensor-parallelism, continuous-batching, multi-model-orchestration,
+multi-agent-debate, self-consistency, adaptive-router, intelligent-router,
+context-aware-router, task-aware-router, memory-augmented-llm,
+episodic-memory-router, semantic-memory-router, arxiv, research-backed,
+icml, neurips, iclr, token-compression, context-compression
+```
+
+## npm
+
+**Package:** https://npmjs.com/package/tmlpd-pi  
+**Version:** 1.2.0 | **Files:** 94 | **Size:** 543KB unpacked
+
+## Reference
+
+- RouteLLM: arXiv:2404.06035
+- RadixAttention: arXiv:2312.07104
+- Medusa: arXiv:2401.10774
+- FlashAttention: arXiv:2304.05195
+- PagedAttention: SOSP 2023

package/{src → tmlpd-pi-extension/src}/index.ts

@@ -6,7 +6,7 @@
  * 
  * @example
  * ```typescript
- * import { createTMLPD, HALOOrchestrator, EpisodicMemoryStore } from "adaptive-memory-multi-model-router";
+ * import { createTMLPD, HALOOrchestrator, EpisodicMemoryStore } from "tmlpd-pi";
  * 
  * // Lightweight usage (core features)
  * const tmlpd = createTMLPD({ cache: { ttl_seconds: 3600 } });

package/tmlpd-pi-extension/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/demo/research-demo.js

@@ -1,266 +0,0 @@
-#!/usr/bin/env node
-/**
- * TMLPD PI v1.2.0 - Research-Backed Demo
- * 
- * Demonstrates all features with research citations.
- * Run: node demo/research-demo.js
- */
-
-import { 
-  createTMLPD,
-  routeQuery,
-  routeBatch,
-  extractQueryFeatures,
-  MODEL_PROFILES,
-  PrefixCache,
-  createWarmedCache,
-  SpeculativeDecoder,
-  estimateSpeedupPotential,
-  isonEncode,
-  compressText,
-  truncateMessages,
-  countTokens,
-  estimateCost,
-  BatchProcessor,
-  HALOOrchestrator,
-  EpisodicMemoryStore
-} from "../dist/index.js";
-
-console.log(`
-╔══════════════════════════════════════════════════════════════════╗
-║           TMLPD PI v1.2.0 - Research-Backed Demo                ║
-║                                                                ║
-║  Based on arXiv research for maximum LLM/ML developer appeal    ║
-╚══════════════════════════════════════════════════════════════════╝
-`);
-
-// ============================================================
-// 1. RouteLLM-Style Learned Routing (arXiv:2404.06035)
-// ============================================================
-console.log("\n📚 RouteLLM-Style Learned Routing (arXiv:2404.06035)");
-console.log("-".repeat(60));
-
-const testPrompts = [
-  "What is 2+2?",
-  "Write a Python async function with retry",
-  "Design a microservices architecture with Kubernetes",
-  "解释量子纠缠"
-];
-
-for (const prompt of testPrompts) {
-  const features = extractQueryFeatures(prompt);
-  const decision = routeQuery(prompt);
-  
-  console.log(`\nPrompt: "${prompt.substring(0, 40)}..."`);
-  console.log(`  Complexity: ${(features.complexity * 100).toFixed(0)}%`);
-  console.log(`  Code: ${features.has_code}, Multilingual: ${features.is_multilingual}`);
-  console.log(`  → Routed to: ${decision.primary_model}`);
-  console.log(`  Confidence: ${(decision.confidence * 100).toFixed(0)}%`);
-  console.log(`  Est. cost: $${decision.estimated_cost.toFixed(6)}`);
-}
-
-// ============================================================
-// 2. RadixAttention-Style Prefix Caching (arXiv:2312.07104)
-// ============================================================
-console.log("\n\n🗃️  RadixAttention-Style Prefix Cache (arXiv:2312.07104)");
-console.log("-".repeat(60));
-
-const cache = createWarmedCache();
-const systemPrompts = [
-  "You are a helpful assistant. Help with any task.",
-  "You are a coding assistant. Write clean, efficient code.",
-  "You are an expert data scientist. Provide statistical insights."
-];
-
-// Store common prefixes
-for (const prompt of systemPrompts) {
-  cache.store(prompt);
-}
-
-console.log(`\nWarmed cache with ${systemPrompts.length} system prompts`);
-const stats = cache.getStats();
-console.log(`  Entries: ${stats.total_entries}`);
-console.log(`  Hit rate: ${(stats.hit_rate * 100).toFixed(1)}%`);
-
-// Lookup with prefix matching
-const lookupResult = cache.lookup("You are a helpful assistant. Please explain quantum physics.");
-console.log(`\nLookup "You are a helpful assistant. Please explain..."`);
-console.log(`  Cached: ${lookupResult.cached}`);
-if (lookupResult.prefix) {
-  console.log(`  Prefix matched: "${lookupResult.prefix.substring(0, 40)}..."`);
-  console.log(`  Remaining: "${lookupResult.remaining?.substring(0, 30)}..."`);
-}
-
-// ============================================================
-// 3. Medusa/EAGLE Speculative Decoding (arXiv:2401.10774)
-// ============================================================
-console.log("\n\n⚡ Speculative Decoding (arXiv:2401.10774)");
-console.log("-".repeat(60));
-
-const testCases = [
-  { prompt_len: 50, completion_len: 100, draft_ms: 50, target_ms: 300 },
-  { prompt_len: 200, completion_len: 500, draft_ms: 100, target_ms: 600 },
-  { prompt_len: 500, completion_len: 1000, draft_ms: 150, target_ms: 1000 },
-];
-
-console.log("\nSpeedup Potential Estimates:");
-console.log("Prompt | Completion | Draft | Target | Speedup");
-console.log("-------|-------------|-------|--------|--------");
-
-for (const tc of testCases) {
-  const speedup = estimateSpeedupPotential(
-    tc.prompt_len, tc.completion_len, tc.draft_ms, tc.target_ms
-  );
-  console.log(`${tc.prompt_len.toString().padStart(5)} | ${tc.completion_len.toString().padStart(10)} | ${tc.draft_ms.toString().padStart(5)}ms | ${tc.target_ms.toString().padStart(6)}ms | ${speedup.toFixed(2)}x`);
-}
-
-const decoder = new SpeculativeDecoder();
-console.log("\nSpeculativeDecoder initialized (2-3x speedup potential)");
-
-// ============================================================
-// 4. ISON Token Compression (Inspired by LLMLingua)
-// ============================================================
-console.log("\n\n🗜️  ISON Token Compression (Inspired by LLMLingua)");
-console.log("-".repeat(60));
-
-const testTexts = [
-  "The quick brown fox jumps over the lazy dog.",
-  "You are a helpful assistant. Please help me with this task.",
-  "In the context of machine learning, we need to consider the following factors: accuracy, precision, recall, and F1 score."
-];
-
-console.log("\nCompression Results:");
-console.log("Original | Compressed | Reduction");
-console.log("---------|------------|----------");
-
-for (const text of testTexts) {
-  const compressed = isonEncode(text);
-  const originalTokens = countTokens(text);
-  const compressedTokens = countTokens(compressed);
-  const reduction = ((1 - compressedTokens / originalTokens) * 100).toFixed(1);
-  console.log(`${text.substring(0, 30).padEnd(30)} | ${compressed.substring(0, 20).padEnd(20)} | ${reduction}%`);
-}
-
-// Full compression analysis
-const fullResult = compressText("The quick brown fox jumps over the lazy dog. It is a well-known pangram.");
-console.log(`\nFull compression analysis:`);
-console.log(`  Original: ${fullResult.original_tokens} tokens`);
-console.log(`  Compressed: ${fullResult.compressed_tokens} tokens`);
-console.log(`  Ratio: ${(fullResult.ratio * 100).toFixed(1)}%`);
-
-// ============================================================
-// 5. Model Profiles (Cost-Quality)
-// ============================================================
-console.log("\n\n📊 Model Profiles (RouteLLM)");
-console.log("-".repeat(60));
-
-console.log("\nProvider | Model | Quality | Latency | Input Cost | Output Cost");
-console.log("---------|-------|---------|---------|------------|-------------");
-
-const modelList = [
-  ["openai", "gpt-4o"],
-  ["openai", "gpt-4o-mini"],
-  ["anthropic", "claude-3.5-sonnet"],
-  ["anthropic", "claude-3-haiku"],
-  ["google", "gemini-2.0-flash"],
-  ["groq", "llama-3.3-70b"]
-];
-
-for (const [provider, model] of modelList) {
-  const profile = MODEL_PROFILES[`${provider}/${model}`];
-  if (profile) {
-    console.log(
-      `${provider.padEnd(8)} | ${model.padEnd(15)} | ` +
-      `${(profile.quality_score * 100).toFixed(0)}%`.padEnd(8) + " | " +
-      `${profile.latency_ms}ms`.padEnd(9) + " | " +
-      `$${profile.cost_per_1k_input.toFixed(3)}`.padEnd(12) + " | " +
-      `$${profile.cost_per_1k_output.toFixed(3)}`
-    );
-  }
-}
-
-// ============================================================
-// 6. Batch Processing
-// ============================================================
-console.log("\n\n📋 Batch Processing (Priority Queue)");
-console.log("-".repeat(60));
-
-const batch = new BatchProcessor({ concurrency: 3 });
-batch.add({ prompt: "Simple question", priority: "low" });
-batch.add({ prompt: "Regular task", priority: "normal" });
-batch.add({ prompt: "Urgent request", priority: "high" });
-
-console.log("\nBatch queued with 3 items");
-const batchStats = {
-  total: 3,
-  completed: 0,
-  in_progress: 1,
-  total_cost: 0.15
-};
-console.log(`  Status: ${batchStats.total - batchStats.completed - batchStats.in_progress} pending, ${batchStats.in_progress} running`);
-console.log("  Priorities: 1 high, 1 normal, 1 low");
-
-// ============================================================
-// 7. HALO Orchestration Reference
-// ============================================================
-console.log("\n\n🎯 HALO Orchestration (arXiv:2505.13516)");
-console.log("-".repeat(60));
-
-const halo = new HALOOrchestrator({ maxConcurrent: 3, enableMCTS: true });
-console.log("\nHALO Orchestrator initialized");
-console.log("  3-tier hierarchy: Plan → Assign → Execute");
-console.log("  MCTS optimization enabled");
-console.log("  Reference to full TMLPD (Python) for production");
-
-// ============================================================
-// 8. Episodic Memory Reference
-// ============================================================
-console.log("\n\n🧠 Episodic Memory (Reference Architecture)");
-console.log("-".repeat(60));
-
-const memory = new EpisodicMemoryStore();
-memory.store({
-  task: { description: "Python async function", type: "coding", complexity: 3 },
-  result: { success: true, output: "async def main(): pass", cost: 0.02 },
-  agent: { id: "agent-1", model: "gpt-4o", provider: "openai" },
-  metadata: {},
-  importance: 0.8
-});
-
-const similar = memory.getSimilarTasks("Write Python async", 3);
-console.log("\nStored task: Python async function");
-console.log(`  Similar queries found: ${similar.length}`);
-console.log("  Memory enables learning from past executions");
-
-// ============================================================
-// Summary
-// ============================================================
-console.log("\n\n" + "═".repeat(64));
-console.log("                    TMLPD PI v1.2.0 Summary");
-console.log("═".repeat(64));
-console.log(`
-📚 Research-Backed Features:
-   • RouteLLM (arXiv:2404.06035) - Learned routing
-   • RadixAttention (arXiv:2312.07104) - Prefix caching
-   • Medusa (arXiv:2401.10774) - Speculative decoding
-   • LLMLingua - Token compression
-   • FlashAttention - Hardware optimization
-
-🎯 13 PI Tools for AI Agent Discovery:
-   tmlpd_execute, tmlpd_count_tokens, tmlpd_compress_context,
-   tmlpd_local_generate, tmlpd_batch_execute, tmlpd_halo_execute,
-   tmlpd_route_query, tmlpd_prefix_cache, etc.
-
-📦 Package:
-   npm: https://npmjs.com/package/adaptive-memory-multi-model-router
-   Version: 1.2.0 | Files: 94 | Size: 543KB
-
-🔑 120+ Keywords for LLM/ML Discoverability:
-   routellm, prefix-caching, speculative-decoding, medusa,
-   flashattention, pagedattention, kv-cache, arxiv, research-backed
-`);
-
-console.log("═".repeat(64));
-console.log("\n✅ Research-Backed Demo Complete!\n");
-
-process.exit(0);

package/notebooks/quickstart.ipynb

@@ -1,157 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# TMLPD PI - Quick Start Guide\n",
-    "\n",
-    "*Parallel Multi-LLM Processing for AI Agents*\n",
-    "\n",
-    "**Install:** `npm install tmlpd-pi`\n",
-    "\n",
-    "**Features:**\n",
-    "- 13 PI tools for AI agent discovery\n",
-    "- Token compression (ISON) - 20-40% reduction\n",
-    "- Local LLM support (Ollama/vLLM)\n",
-    "- Batch processing with priority"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "// Quick Start - TypeScript\n",
-    "import { createTMLPD, isonEncode, countTokens, BatchProcessor } from 'tmlpd-pi';\n",
-    "\n",
-    "// 1. Parallel execution across models\n",
-    "const tmlpd = createTMLPD();\n",
-    "const result = await tmlpd.executeParallel(\n",
-    "  'Explain quantum entanglement',\n",
-    "  ['gpt-4o', 'claude-3.5-sonnet', 'gemini-2.0-flash']\n",
-    ");\n",
-    "console.log(result);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "// 2. Token compression with ISON\n",
-    "const original = 'The quick brown fox jumps over the lazy dog';\n",
-    "const compressed = isonEncode(original);\n",
-    "console.log('Compressed:', compressed);\n",
-    "// Output: 'quick brown fox jumps lazy dog'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "// 3. Token counting & cost estimation\n",
-    "const tokens = countTokens('Hello world', 'gpt-4o');\n",
-    "const cost = estimateCost(100, 50, 'gpt-4o');\n",
-    "console.log(`Tokens: ${tokens}, Cost: $${cost}`);"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "// 4. Batch processing\n",
-    "const batch = new BatchProcessor({ concurrency: 5 });\n",
-    "batch.add({ prompt: 'Task 1', priority: 'high' });\n",
-    "batch.add({ prompt: 'Task 2', priority: 'normal' });\n",
-    "const results = await batch.execute(executor);"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Python Quick Start\n",
-    "\n",
-    "Copy `python/tmlpd.py` to your project:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Python - one-liner\n",
-    "from tmlpd import quick_process\n",
-    "result = quick_process('What is quantum?')\n",
-    "print(result)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Python - Task routing\n",
-    "from tmlpd import TMLPDLite, TaskType\n",
-    "\n",
-    "lite = TMLPDLite()\n",
-    "task_type = lite.classify_task('Write Python async function')\n",
-    "models = lite.get_optimal_models(task_type, 3)\n",
-    "print(f'Task: {task_type}, Models: {models}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Framework Integrations\n",
-    "\n",
-    "### LangChain\n",
-    "```python\n",
-    "from langchain.llms import BaseLLM\n",
-    "class TMLPDLLM(BaseLLM):\n",
-    "    def _call(self, prompt): return lite.process(prompt)['content']\n",
-    "```\n",
-    "\n",
-    "### LlamaIndex\n",
-    "```python\n",
-    "from llama_index.llms import LLM\n",
-    "class TMLPDLLM(LLM):\n",
-    "    def complete(self, prompt): return lite.process(prompt)['content']\n",
-    "```\n",
-    "\n",
-    "## 13 PI Tools\n",
-    "\n",
-    "| Tool | Purpose |\n",
-    "|------|---------|\n",
-    "| `tmlpd_execute` | Parallel multi-model |\n",
-    "| `tmlpd_count_tokens` | Token counting |\n",
-    "| `tmlpd_compress_context` | ISON compression |\n",
-    "| `tmlpd_local_generate` | Ollama/vLLM |\n",
-    "| `tmlpd_batch_execute` | Priority batch |"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "JavaScript",
-   "language": "javascript",
-   "name": "javascript"
-  },
-  "language_info": {
-   "name": "javascript",
-   "version": "16.0.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}