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

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

@@ -1,183 +0,0 @@
-# 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

@@ -1,79 +0,0 @@
-{
-  "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.19.41",
-        "typescript": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18.0.0"
-      },
-      "funding": {
-        "type": "individual",
-        "url": "https://github.com/sponsors/Das-rebel"
-      }
-    },
-    "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

@@ -1,172 +0,0 @@
-{
-  "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": {
-    "@types/node": "^20.19.41",
-    "typescript": "^5.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

@@ -1,53 +0,0 @@
-#!/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()