a3m-router 2.2.0__tar.gz

a3m_router-2.2.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: a3m-router
+Version: 2.2.0
+Summary: Intelligent LLM routing for Python — routes to cheapest capable model across 47+ providers
+License: MIT
+Project-URL: Homepage, https://github.com/Das-rebel/a3m-router
+Project-URL: Documentation, https://das-rebel.github.io/a3m-router
+Project-URL: Repository, https://github.com/Das-rebel/a3m-router
+Project-URL: Changelog, https://github.com/Das-rebel/a3m-router/releases
+Keywords: llm,routing,openai,proxy,ai-gateway,routellm,litellm,multi-llm,model-selection,cost-optimization,langchain,llamaindex,rag,vector-search,embeddings,parallel,ensemble,router
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llamaindex>=0.9.0; extra == "llamaindex"
+Provides-Extra: qdrant
+Requires-Dist: qdrant-client>=1.7.0; extra == "qdrant"
+Provides-Extra: weaviate
+Requires-Dist: weaviate-client>=4.0.0; extra == "weaviate"
+Provides-Extra: adapters
+Requires-Dist: langchain>=0.1.0; extra == "adapters"
+Requires-Dist: llamaindex>=0.9.0; extra == "adapters"
+Requires-Dist: qdrant-client>=1.7.0; extra == "adapters"
+Requires-Dist: weaviate-client>=4.0.0; extra == "adapters"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+
+# A3M Router Python SDK
+
+Intelligent LLM routing for Python — routes to cheapest capable model across 47+ providers.
+
+## Installation
+
+```bash
+pip install a3m-router
+```
+
+## Usage
+
+```python
+from a3m import A3MRouter
+
+router = A3MRouter()  # localhost:8787
+response = await router.chat("What is 2+2?")
+```
+
+## Framework Adapters
+
+| Adapter | Import | Use Case |
+|---------|--------|----------|
+| **LangChain** | `from a3m import LangChainAdapter` | Chain-based AI workflows |
+| **LlamaIndex** | `from a3m import LlamaIndexAdapter` | RAG and document QA |
+| **Qdrant** | `from a3m import QdrantAdapter` | Vector search + RAG |
+| **Weaviate** | `from a3m import WeaviateAdapter` | Vector search + RAG |
+
+Install adapters:
+```bash
+pip install a3m-router[langchain]   # LangChain
+pip install a3m-router[llamaindex] # LlamaIndex
+pip install a3m-router[qdrant]      # Qdrant
+pip install a3m-router[weaviate]    # Weaviate
+pip install a3m-router[all]         # All adapters
+```
+
+## API Reference
+
+| Method | Description |
+|--------|-------------|
+| `chat(message)` | Send chat message with auto-routing |
+| `route(query)` | Get routing decision (no execution) |
+| `stream_chat(message)` | Stream response tokens |
+| `models()` | List available models |
+| `health()` | Provider health status |
+
+## Links
+
+- [GitHub](https://github.com/Das-rebel/a3m-router)
+- [npm Package](https://www.npmjs.com/package/adaptive-memory-multi-model-router)
+
+## License
+
+MIT

a3m_router-2.2.0/README.md

@@ -0,0 +1,55 @@
+# A3M Router Python SDK
+
+Intelligent LLM routing for Python — routes to cheapest capable model across 47+ providers.
+
+## Installation
+
+```bash
+pip install a3m-router
+```
+
+## Usage
+
+```python
+from a3m import A3MRouter
+
+router = A3MRouter()  # localhost:8787
+response = await router.chat("What is 2+2?")
+```
+
+## Framework Adapters
+
+| Adapter | Import | Use Case |
+|---------|--------|----------|
+| **LangChain** | `from a3m import LangChainAdapter` | Chain-based AI workflows |
+| **LlamaIndex** | `from a3m import LlamaIndexAdapter` | RAG and document QA |
+| **Qdrant** | `from a3m import QdrantAdapter` | Vector search + RAG |
+| **Weaviate** | `from a3m import WeaviateAdapter` | Vector search + RAG |
+
+Install adapters:
+```bash
+pip install a3m-router[langchain]   # LangChain
+pip install a3m-router[llamaindex] # LlamaIndex
+pip install a3m-router[qdrant]      # Qdrant
+pip install a3m-router[weaviate]    # Weaviate
+pip install a3m-router[all]         # All adapters
+```
+
+## API Reference
+
+| Method | Description |
+|--------|-------------|
+| `chat(message)` | Send chat message with auto-routing |
+| `route(query)` | Get routing decision (no execution) |
+| `stream_chat(message)` | Stream response tokens |
+| `models()` | List available models |
+| `health()` | Provider health status |
+
+## Links
+
+- [GitHub](https://github.com/Das-rebel/a3m-router)
+- [npm Package](https://www.npmjs.com/package/adaptive-memory-multi-model-router)
+
+## License
+
+MIT

a3m_router-2.2.0/a3m/__init__.py

@@ -0,0 +1,35 @@
+"""A3M Router Python SDK"""
+from .client import A3MRouter, A3MRouterError
+from .sync_client import A3MRouterSync
+from .models import RoutingDecision, CostReport
+
+__version__ = "2.2.0"
+
+__all__ = [
+    "A3MRouter",
+    "A3MRouterSync",
+    "A3MRouterError",
+    "RoutingDecision",
+    "CostReport",
+    # Framework adapters
+    "LangChainAdapter",
+    "LlamaIndexAdapter",
+    "QdrantAdapter",
+    "WeaviateAdapter",
+]
+
+# Lazy-load adapters
+def __getattr__(name: str):
+    if name == "LangChainAdapter":
+        from .adapters.langchain import LangChainAdapter
+        return LangChainAdapter
+    if name == "LlamaIndexAdapter":
+        from .adapters.llamaindex import LlamaIndexAdapter
+        return LlamaIndexAdapter
+    if name == "QdrantAdapter":
+        from .adapters.qdrant import QdrantAdapter
+        return QdrantAdapter
+    if name == "WeaviateAdapter":
+        from .adapters.weaviate import WeaviateAdapter
+        return WeaviateAdapter
+    raise AttributeError(f"module 'a3m' has no attribute '{name}'")

a3m_router-2.2.0/a3m/adapters/__init__.py

@@ -0,0 +1,21 @@
+"""
+A3M Router framework adapters.
+
+Lazy-loaded adapter classes for popular frameworks:
+- LangChain: from a3m.adapters import LangChainAdapter
+- LlamaIndex: from a3m.adapters import LlamaIndexAdapter
+- Qdrant: from a3m.adapters import QdrantAdapter
+- Weaviate: from a3m.adapters import WeaviateAdapter
+"""
+
+from .langchain import LangChainAdapter
+from .llamaindex import LlamaIndexAdapter
+from .qdrant import QdrantAdapter
+from .weaviate import WeaviateAdapter
+
+__all__ = [
+    "LangChainAdapter",
+    "LlamaIndexAdapter", 
+    "QdrantAdapter",
+    "WeaviateAdapter",
+]

a3m_router-2.2.0/a3m/adapters/langchain.py

@@ -0,0 +1,190 @@
+"""
+A3M Router LangChain adapter.
+
+Drop-in replacement for ChatOpenAI that routes through A3M Router.
+
+Usage:
+    from langchain.chat_models import ChatOpenAI
+    from a3m.adapters import LangChainAdapter
+    
+    # As replacement for ChatOpenAI
+    llm = LangChainAdapter(
+        base_url="http://localhost:8787",
+        model="auto",
+        temperature=0.7,
+    )
+    
+    from langchain.schema import HumanMessage
+    response = llm([HumanMessage(content="What is 2+2?")])
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+LANCHAIN_AVAILABLE = False
+try:
+    from langchain.chat_models import BaseChatModel
+    from langchain.schema import (
+        BaseMessage,
+        ChatResult,
+        AIMessage,
+        HumanMessage,
+        SystemMessage,
+    )
+    from langchain.callbacks.manager import CallbackManagerForLLMRun
+    LANCHAIN_AVAILABLE = True
+except ImportError:
+    logger.warning("LangChain not installed. pip install langchain")
+
+from a3m.client import A3MRouter, A3MRouterError
+
+if LANCHAIN_AVAILABLE:
+    class LangChainAdapter(BaseChatModel):
+        """
+        LangChain chat model that routes through A3M Router.
+        
+        Drop-in replacement for ChatOpenAI with automatic model selection.
+        
+        Args:
+            base_url: A3M Router server URL.
+            model: Model name or "auto" for intelligent routing.
+            temperature: Sampling temperature.
+            max_tokens: Max tokens to generate.
+            parallel_ensemble: Number of providers for ensemble calls.
+            **kwargs: Additional A3MRouter options.
+        """
+
+        base_url: str = Field(default="http://localhost:8787")
+        model: str = Field(default="auto")
+        temperature: float = Field(default=0.7)
+        max_tokens: Optional[int] = Field(default=None)
+        parallel_ensemble: int = Field(default=1)
+        api_key: Optional[str] = Field(default=None)
+
+        class Config:
+            arbitrary_types_allowed = True
+
+        def _get_router(self) -> A3MRouter:
+            """Get or create A3M Router client."""
+            if not hasattr(self, "_router"):
+                self._router = A3MRouter(
+                    base_url=self.base_url,
+                    api_key=self.api_key,
+                    default_model=self.model,
+                    default_temperature=self.temperature,
+                    default_max_tokens=self.max_tokens,
+                    parallel_ensemble=self.parallel_ensemble,
+                )
+            return self._router
+
+        def _convert_messages(
+            self,
+            messages: List[BaseMessage],
+        ) -> List[Dict[str, str]]:
+            """Convert LangChain messages to A3M format."""
+            result = []
+            for msg in messages:
+                if isinstance(msg, HumanMessage):
+                    result.append({"role": "user", "content": msg.content})
+                elif isinstance(msg, AIMessage):
+                    result.append({"role": "assistant", "content": msg.content})
+                elif isinstance(msg, SystemMessage):
+                    result.append({"role": "system", "content": msg.content})
+                else:
+                    result.append({"role": "user", "content": str(msg.content)})
+            return result
+
+        def _convert_response(
+            self,
+            response_content: str,
+        ) -> AIMessage:
+            """Convert A3M response to LangChain message."""
+            return AIMessage(content=response_content)
+
+        @property
+        def _llm_type(self) -> str:
+            return "a3m-router"
+
+        def _generate(
+            self,
+            messages: List[BaseMessage],
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+        ) -> ChatResult:
+            """Generate a chat response."""
+            router = self._get_router()
+            
+            a3m_messages = self._convert_messages(messages)
+            
+            try:
+                response = router.chat(
+                    messages=a3m_messages,
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    parallel_ensemble=self.parallel_ensemble,
+                    **kwargs,
+                )
+            except A3MRouterError as e:
+                logger.error(f"A3M Router error: {e}")
+                raise
+            
+            return ChatResult(
+                generations=[{"message": self._convert_response(response.content), "text": response.content}],
+                llm_output={
+                    "provider": response.provider,
+                    "model": response.route.model,
+                    "cost": response.cost,
+                    "route": str(response.route),
+                },
+            )
+
+        async def _agenerate(
+            self,
+            messages: List[BaseMessage],
+            stop: Optional[List[str]] = None,
+            run_manager: Optional[CallbackManagerForLLMRun] = None,
+            **kwargs: Any,
+        ) -> ChatResult:
+            """Async generate a chat response."""
+            router = self._get_router()
+            a3m_messages = self._convert_messages(messages)
+            
+            try:
+                response = await router.achat(
+                    messages=a3m_messages,
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    parallel_ensemble=self.parallel_ensemble,
+                    **kwargs,
+                )
+            except A3MRouterError as e:
+                logger.error(f"A3M Router error: {e}")
+                raise
+            
+            return ChatResult(
+                generations=[{"message": self._convert_response(response.content), "text": response.content}],
+                llm_output={
+                    "provider": response.provider,
+                    "model": response.route.model,
+                    "cost": response.cost,
+                    "route": str(response.route),
+                },
+            )
+
+else:
+    # Stub class when LangChain is not installed
+    class LangChainAdapter:
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            raise ImportError(
+                "LangChain is not installed. "
+                "Install with: pip install langchain"
+            )

a3m_router-2.2.0/a3m/adapters/llamaindex.py

@@ -0,0 +1,249 @@
+"""
+A3M Router LlamaIndex adapter.
+
+Drop-in LLM for LlamaIndex that routes through A3M Router.
+
+Usage:
+    from llama_index import VectorStoreIndex, SimpleWebPageReader
+    from a3m.adapters import LlamaIndexAdapter
+    
+    llm = LlamaIndexAdapter(
+        base_url="http://localhost:8787",
+        model="auto",
+        temperature=0.7,
+    )
+    
+    index = VectorStoreIndex.from_documents(
+        documents,
+        llm=llm,  # Use A3M Router as the LLM
+    )
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Awaitable, List, Optional
+
+logger = logging.getLogger(__name__)
+
+LLAMAINDEX_AVAILABLE = False
+try:
+    from llama_index.llms import BaseLLM
+    from llama_index.llms.custom import CustomLLM
+    from llama_index.types import ModelType
+    from llama_index.output_parsers.base import BaseOutputParser
+    LLAMAINDEX_AVAILABLE = True
+except ImportError:
+    logger.warning("LlamaIndex not installed. pip install llama-index")
+
+from a3m.client import A3MRouter, A3MRouterError
+
+if LLAMAINDEX_AVAILABLE:
+    class LlamaIndexAdapter(BaseLLM):
+        """
+        LlamaIndex LLM that routes through A3M Router.
+        
+        Drop-in replacement for OpenAI/GPT LLMs in LlamaIndex pipelines.
+        
+        Args:
+            base_url: A3M Router server URL.
+            model: Model name or "auto" for intelligent routing.
+            temperature: Sampling temperature.
+            max_tokens: Max tokens to generate.
+            parallel_ensemble: Number of providers for ensemble calls.
+        """
+
+        base_url: str = "http://localhost:8787"
+        model: str = "auto"
+        temperature: float = 0.7
+        max_tokens: Optional[int] = 4096
+        parallel_ensemble: int = 1
+        api_key: Optional[str] = None
+
+        def __init__(self, **kwargs: Any) -> None:
+            super().__init__(**kwargs)
+            self._router: Optional[A3MRouter] = None
+
+        def _get_router(self) -> A3MRouter:
+            """Get or create A3M Router client."""
+            if self._router is None:
+                self._router = A3MRouter(
+                    base_url=self.base_url,
+                    api_key=self.api_key,
+                    default_model=self.model,
+                    default_temperature=self.temperature,
+                    default_max_tokens=self.max_tokens,
+                    parallel_ensemble=self.parallel_ensemble,
+                )
+            return self._router
+
+        @property
+        def model_type(self) -> ModelType:
+            return ModelType.LLM
+
+        @property
+        def class_name(self) -> str:
+            return "A3MRouter"
+
+        def complete(
+            self,
+            prompt: str,
+            formatted: bool = False,
+            **kwargs: Any,
+        ) -> Any:
+            """
+            Synchronous completion.
+            
+            LlamaIndex calls this for text completion.
+            """
+            router = self._get_router()
+            
+            try:
+                response = router.chat(
+                    messages=[{"role": "user", "content": prompt}],
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    parallel_ensemble=self.parallel_ensemble,
+                    **kwargs,
+                )
+                return response.content
+            except A3MRouterError as e:
+                logger.error(f"A3M Router error: {e}")
+                raise
+
+        async def acomplete(
+            self,
+            prompt: str,
+            formatted: bool = False,
+            **kwargs: Any,
+        ) -> Any:
+            """Async completion."""
+            router = self._get_router()
+            
+            try:
+                response = await router.achat(
+                    messages=[{"role": "user", "content": prompt}],
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    parallel_ensemble=self.parallel_ensemble,
+                    **kwargs,
+                )
+                return response.content
+            except A3MRouterError as e:
+                logger.error(f"A3M Router error: {e}")
+                raise
+
+        def stream_complete(
+            self,
+            prompt: str,
+            **kwargs: Any,
+        ) -> Any:
+            """
+            Streaming completion.
+            
+            Returns a generator that yields response chunks.
+            """
+            router = self._get_router()
+            
+            try:
+                chunks = router.stream_chat(
+                    messages=[{"role": "user", "content": prompt}],
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    **kwargs,
+                )
+                for chunk in chunks:
+                    yield chunk.content
+            except A3MRouterError as e:
+                logger.error(f"A3M Router error: {e}")
+                raise
+
+        async def astream_complete(
+            self,
+            prompt: str,
+            **kwargs: Any,
+        ) -> Awaitable[Any]:
+            """Async streaming completion."""
+            router = self._get_router()
+            
+            async def gen():
+                async for chunk in router.astream_chat(
+                    messages=[{"role": "user", "content": prompt}],
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    **kwargs,
+                ):
+                    yield chunk.content
+            
+            return gen()
+
+        def chat(self, messages: List[Any], **kwargs: Any) -> Any:
+            """
+            Synchronous chat.
+            
+            Converts messages to a single prompt.
+            """
+            router = self._get_router()
+            
+            # Convert message objects to content strings
+            if hasattr(messages[0], "content"):
+                content = "\n".join([getattr(m, "content", str(m)) for m in messages])
+            else:
+                content = str(messages[0])
+            
+            try:
+                response = router.chat(
+                    messages=[{"role": "user", "content": content}],
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    **kwargs,
+                )
+                # Return a simple object that LlamaIndex expects
+                return ChatMessage(content=response.content)
+            except A3MRouterError as e:
+                logger.error(f"A3M Router error: {e}")
+                raise
+
+        async def achat(self, messages: List[Any], **kwargs: Any) -> Any:
+            """Async chat."""
+            router = self._get_router()
+            
+            if hasattr(messages[0], "content"):
+                content = "\n".join([getattr(m, "content", str(m)) for m in messages])
+            else:
+                content = str(messages[0])
+            
+            try:
+                response = await router.achat(
+                    messages=[{"role": "user", "content": content}],
+                    model=self.model,
+                    temperature=self.temperature,
+                    max_tokens=self.max_tokens,
+                    **kwargs,
+                )
+                return ChatMessage(content=response.content)
+            except A3MRouterError as e:
+                logger.error(f"A3M Router error: {e}")
+                raise
+
+else:
+    # Stub class when LlamaIndex is not installed
+    class LlamaIndexAdapter:
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            raise ImportError(
+                "LlamaIndex is not installed. "
+                "Install with: pip install llama-index"
+            )
+
+
+# Simple message class for LlamaIndex compatibility
+class ChatMessage:
+    """Simple chat message for LlamaIndex compatibility."""
+    def __init__(self, content: str) -> None:
+        self.content = content
+        self.raw = {}