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

package/tmlpd-pi-extension/examples/QUICKSTART.md

@@ -0,0 +1,183 @@
+# TMLPD PI Extension - Usage Examples
+
+## Quick Start
+
+```python
+from tmlpd import quick_process
+
+# One-liner
+result = quick_process("What is quantum entanglement?")
+print(result["content"])
+```
+
+## Task Classification
+
+```python
+from tmlpd import TMLPDLite, TaskType
+
+lite = TMLPDLite()
+
+# Automatic task classification
+prompt = "Write Python async HTTP client"
+task_type = lite.classify_task(prompt)  # TaskType.CODING
+
+# Get optimal models
+models = lite.get_optimal_models(task_type, 3)
+# ["codex", "claude-minimax", "claude"]
+```
+
+## Caching
+
+```python
+from tmlpd import TMLPDLite
+
+lite = TMLPDLite()
+
+# First call - not cached
+result1 = lite.process("What is 2+2?", use_cache=True)
+print(f"Cached: {result1['cached']}")  # False
+
+# Second call - from cache
+result2 = lite.process("What is 2+2?", use_cache=True)
+print(f"Cached: {result2['cached']}")  # True
+```
+
+## Async Client (Production)
+
+```python
+import asyncio
+from tmlpd import TMLPDClient, TMLPDConfig
+
+async def main():
+    config = TMLPDConfig(
+        cache_ttl_seconds=3600,
+        daily_budget=10.0,
+        max_concurrent=5
+    )
+    client = TMLPDClient(config)
+    
+    # Single execution
+    result = await client.execute("Explain quantum entanglement")
+    
+    # Parallel execution
+    parallel = await client.execute_parallel(
+        "Compare Python and JavaScript",
+        models=["gpt-4o", "claude", "gemini"]
+    )
+    
+    # Cost summary
+    summary = await client.get_cost_summary()
+    print(f"Total spent: ${summary.total_cost}")
+
+asyncio.run(main())
+```
+
+## Cost Optimization
+
+```python
+import asyncio
+from tmlpd import TMLPDClient
+
+async def cost_optimization():
+    client = TMLPDClient()
+    
+    # Cheap for simple tasks
+    simple = await client.execute("What is 2+2?", model="cerebras/llama-3.3-70b")
+    print(f"Simple task cost: ${simple.cost:.6f}")
+    
+    # Premium for complex tasks
+    complex = await client.execute("Design microservices", model="anthropic/claude-3.5-sonnet")
+    print(f"Complex task cost: ${complex.cost:.6f}")
+
+asyncio.run(cost_optimization())
+```
+
+## LangChain Integration
+
+```python
+from langchain.llms import BaseLLM
+from tmlpd import TMLPDLite
+
+class TMLPDLLM(BaseLLM):
+    def __init__(self, task_type="default"):
+        self.lite = TMLPDLite()
+        self.task_type = task_type
+    
+    def _call(self, prompt: str) -> str:
+        result = self.lite.process(prompt)
+        return result["content"]
+
+# Usage
+llm = TMLPDLLM(task_type="coding")
+response = llm("Write a Python function")
+```
+
+## API Server
+
+```python
+# Run: node node_modules/tmlpd-pi/dist/server.js --port 18791
+# Then use Python client:
+
+import httpx
+
+async def api_example():
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            "http://localhost:18791/execute",
+            json={"prompt": "Hello world", "models": ["gpt-4o"]}
+        )
+        print(response.json())
+```
+
+## Task Types
+
+| Task Type | Keywords | Best Models |
+|-----------|----------|-------------|
+| coding | python, javascript, code | codex, claude-minimax |
+| frontend | react, vue, component | codex, claude-minimax |
+| backend | api, server, database | codex, claude-glm |
+| chinese | 中文, 汉语 | claude-glm, claude-minimax |
+| fast | quick, simple | gemini, claude-haiku |
+| premium | advanced, complex | claude-opus, gemini-pro |
+
+## Environment Variables
+
+```bash
+# API Keys
+export OPENAI_API_KEY="sk-..."
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GROQ_API_KEY="gsk_..."
+
+# TMLPD Configuration
+export TMLPD_MAX_CONCURRENT=5
+export TMLPD_DAILY_BUDGET=10.0
+export TMLPD_CACHE_TTL=3600
+```
+
+## Full Example
+
+```python
+import asyncio
+from tmlpd import TMLPDClient, TMLPDLite
+
+async def full_example():
+    # Lite for quick tasks
+    lite = TMLPDLite()
+    result = lite.process("What is Python?", use_cache=True)
+    print(f"Lite: {result['task_type']}")
+    
+    # Full client for production
+    client = TMLPDClient()
+    
+    # Batch processing
+    prompts = ["What is AI?", "What is ML?", "What is DL?"]
+    for prompt in prompts:
+        result = await client.execute(prompt)
+        print(f"Cost: ${result.cost:.6f}")
+    
+    # Final stats
+    summary = await client.get_cost_summary()
+    print(f"Total: ${summary.total_cost:.6f}")
+
+asyncio.run(full_example())
+```

package/tmlpd-pi-extension/package-lock.json

@@ -0,0 +1,75 @@
+{
+  "name": "tmlpd-pi",
+  "version": "1.2.2",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "tmlpd-pi",
+      "version": "1.2.2",
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^5.0.0"
+      },
+      "bin": {
+        "tmlpd-pi": "dist/cli.js"
+      },
+      "devDependencies": {
+        "@types/node": "^20.0.0",
+        "typescript": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.41",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.41.tgz",
+      "integrity": "sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.11.tgz",
+      "integrity": "sha512-v+KEsUv2ps74PaSKv0gHTxTCgMXOIfBEbaqa6w6ISIGC7ZsvHN4N9oJ8d4cmf0n5oTzQz2SLmThbQWhjd/8eKg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.js"
+      },
+      "engines": {
+        "node": "^18 || >=20"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/tmlpd-pi-extension/package.json

@@ -0,0 +1,172 @@
+{
+  "name": "tmlpd-pi",
+  "version": "1.2.2",
+  "version_description": "v1.2.0 - Research-backed Multi-LLM Router based on arXiv: RouteLLM (2404.06035), RadixAttention (2312.07104), Medusa (2401.10774), FlashAttention (2407.07403). 120+ keywords for LLM/ML discoverability. 13 PI tools.",
+  "description": "Research-backed Multi-LLM Router with parallel execution, learned routing (RouteLLM), prefix caching (RadixAttention), speculative decoding (Medusa/EAGLE), token compression (ISON), local LLM support (Ollama/vLLM/LM Studio), batch processing. Python bindings for LangChain/LlamaIndex/AutoGen/CrewAI. 120+ keywords: routellm, prefix-caching, speculative-decoding, medusa, flashattention, pagedattention, kv-cache, arxiv, research-backed, icml, neurips, iclr.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "tmlpd-pi": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublish": "npm run build",
+    "test": "node test/verify.js",
+    "demo": "node demo/research-demo.js",
+    "python:examples": "python3 python/examples.py"
+  },
+  "keywords": [
+    "pi-extension",
+    "pi",
+    "pi-package",
+    "pi-coding-agent",
+    "pi-agent",
+    "tmlpd",
+    "treequest",
+    "multi-llm",
+    "parallel-ai",
+    "llm-orchestration",
+    "llm",
+    "agent-orchestration",
+    "multi-agent",
+    "agent",
+    "parallel",
+    "streaming",
+    "cost-tracking",
+    "cost-optimization",
+    "cache",
+    "caching",
+    "circuit-breaker",
+    "retry",
+    "exponential-backoff",
+    "mcts",
+    "monte-carlo-tree-search",
+    "workflow-optimization",
+    "hierarchical-planning",
+    "halo",
+    "episodic-memory",
+    "semantic-memory",
+    "agent-memory",
+    "python",
+    "python-bindings",
+    "pypi",
+    "langchain",
+    "llamaindex",
+    "llama-index",
+    "autogen",
+    "crewai",
+    "huggingface",
+    "transformers",
+    "agent-codegen",
+    "ai-coding",
+    "openai",
+    "anthropic",
+    "google",
+    "groq",
+    "cerebras",
+    "mistral",
+    "xai",
+    "zai",
+    "claude",
+    "gpt-4",
+    "gemini",
+    "llama",
+    "model-router",
+    "model-routing",
+    "llm-router",
+    "ai-agents",
+    "autonomous-agents",
+    "memory-based-router",
+    "memory-based-llm-router",
+    "multi-llm-router",
+    "llm-memory-router",
+    "adaptive-router",
+    "adaptive-llm-router",
+    "intelligent-router",
+    "intelligent-llm-router",
+    "learning-router",
+    "contextual-router",
+    "context-aware-router",
+    "task-aware-router",
+    "memory-augmented",
+    "memory-augmented-llm",
+    "episodic-memory-router",
+    "semantic-memory-router",
+    "task-memory",
+    "cross-context-memory",
+    "token-compression",
+    "context-compression",
+    "ison-format",
+    "message-truncation",
+    "context-management",
+    "local-llm",
+    "ollama",
+    "vllm",
+    "lmstudio",
+    "local-model",
+    "privacy-llm",
+    "batch-processing",
+    "batch-execution",
+    "priority-queue",
+    "rate-limiting",
+    "token-counting",
+    "cost-estimation",
+    "cost-prediction",
+    "parallel-execution",
+    "multi-provider",
+    "fallback-chain",
+    "intelligent-failover",
+    "kv-cache",
+    "routellm",
+    "prefix-caching",
+    "radix-attention",
+    "speculative-decoding",
+    "medusa",
+    "eagle",
+    "flashattention",
+    "pagedattention",
+    "kv-cache-quantization",
+    "llmlingua",
+    "streamingllm",
+    "multimodel-orchestration",
+    "multi-agent-debate",
+    "self-consistency",
+    "tensor-parallelism",
+    "continuous-batching",
+    "arxiv",
+    "research-backed",
+    "icml",
+    "neurips",
+    "iclr"
+  ],
+  "author": "Subho Das",
+  "license": "MIT",
+  "homepage": "https://github.com/Das-rebel/tmlpd-skill#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Das-rebel/tmlpd-skill.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Das-rebel/tmlpd-skill/issues"
+  },
+  "dependencies": {
+    "nanoid": "^5.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "categories": [
+    "AI",
+    "Machine Learning",
+    "Developer Tools",
+    "Programming"
+  ],
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/sponsors/Das-rebel"
+  }
+}

package/tmlpd-pi-extension/python/examples.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+TMLPD Python Usage Examples
+Run: python3 examples.py
+"""
+
+from tmlpd import TMLPDLite, quick_process, TaskType
+
+def main():
+    print("=" * 60)
+    print("TMLPD Python - Quick Examples")
+    print("=" * 60)
+    
+    # Example 1: One-liner
+    print("\n1. One-liner usage:")
+    result = quick_process("What is quantum entanglement?")
+    print(f"   Task type: {result['task_type']}")
+    
+    # Example 2: Task classification
+    print("\n2. Task classification:")
+    lite = TMLPDLite()
+    prompts = [
+        "Write Python async function",
+        "Explain neural network",
+        "Build React component",
+        "Create PostgreSQL schema"
+    ]
+    for p in prompts:
+        tt = lite.classify_task(p)
+        models = lite.get_optimal_models(tt, 2)
+        print(f"   '{p[:30]}...' -> {tt.value} -> {models}")
+    
+    # Example 3: Caching
+    print("\n3. Caching:")
+    prompt = "What is the capital of France?"
+    r1 = lite.process(prompt, use_cache=True)
+    r2 = lite.process(prompt, use_cache=True)
+    print(f"   First:  cached={r1['cached']}")
+    print(f"   Second: cached={r2['cached']}")
+    
+    # Example 4: Batch processing
+    print("\n4. Batch processing:")
+    batch = ["Python", "JavaScript", "TypeScript", "Rust", "Go"]
+    results = [lite.process(f"What is {lang}?") for lang in batch]
+    for lang, res in zip(batch, results):
+        print(f"   {lang}: {res['task_type']}")
+    
+    print("\n" + "=" * 60)
+    print("Examples completed!")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()