adaptive-memory-multi-model-router 2.15.3 → 2.15.5

package/adapters/a3m_adapter/adapter/autogen.py

@@ -0,0 +1,169 @@
+"""
+A3M Router Adapter for AutoGen (Microsoft).
+
+Drop-in replacement for AutoGen's LLMAgent that routes through A3M Router
+for intelligent, cost-optimized multi-agent conversations.
+
+Usage:
+    from autogen import ConversableAgent
+    from a3m_adapter import A3MAutoGenAdapter
+
+    llm_config = {
+        "model": "auto",
+        "temperature": 0.7,
+        "parallel_ensemble": 2,
+    }
+    
+    assistant = ConversableAgent(
+        name="assistant",
+        llm_config=llm_config,
+    )
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+A3M_AVAILABLE = False
+try:
+    from a3m.router import A3MRouter, RouteResponse
+    A3M_AVAILABLE = True
+except ImportError:
+    logger.warning(
+        "A3M Router not installed. Install with: pip install adaptive-memory-multi-model-router"
+    )
+
+
+class A3MAutoGenAdapter:
+    """
+    A3M Router adapter for AutoGen's ConversableAgent.
+
+    Enables AutoGen agents to use A3M Router for automatic model selection
+    across 47+ providers with cost optimization.
+    """
+
+    def __init__(
+        self,
+        model: str = "auto",
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = 4096,
+        parallel_ensemble: int = 1,
+        api_key: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize A3M Router adapter for AutoGen.
+        """
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.parallel_ensemble = parallel_ensemble
+        self.api_key = api_key
+        self._a3m_router = None
+        self._initialized = False
+
+    def _ensure_router(self) -> None:
+        """Lazily initialize the A3M router."""
+        if self._initialized:
+            return
+        
+        if not A3M_AVAILABLE:
+            raise ImportError(
+                "A3M Router is not installed. "
+                "Install with: pip install adaptive-memory-multi-model-router"
+            )
+        
+        self._a3m_router = A3MRouter(
+            model=self.model,
+            temperature=self.temperature,
+            parallel_ensemble=self.parallel_ensemble,
+        )
+        self._initialized = True
+        logger.info(
+            "A3M Router initialized for AutoGen: model=%s, ensemble=%d",
+            self.model,
+            self.parallel_ensemble,
+        )
+
+    def create_agent_config(self) -> Dict[str, Any]:
+        """
+        Create AutoGen-compatible agent config.
+        
+        Returns a config dict that can be passed to ConversableAgent.
+        """
+        return {
+            "model": self.model,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "parallel_ensemble": self.parallel_ensemble,
+            "a3m_router": self,  # Pass self as the router
+        }
+
+    def chat(
+        self,
+        messages: List[Dict[str, str]],
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """
+        Generate a response using A3M Router.
+        
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            
+        Returns:
+            Response dict with 'content', 'provider', 'cost'
+        """
+        self._ensure_router()
+        
+        import asyncio
+        loop = asyncio.get_event_loop()
+        route_result = loop.run_in_executor(
+            None,
+            lambda: self._a3m_router.route(
+                messages=messages,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens,
+                **kwargs,
+            ),
+        )
+        
+        return {
+            "content": route_result.content,
+            "provider": getattr(route_result, 'provider', 'unknown'),
+            "cost": getattr(route_result, 'cost', 0.0),
+            "finish_reason": getattr(route_result, 'finish_reason', 'stop'),
+        }
+
+    async def achat(
+        self,
+        messages: List[Dict[str, str]],
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """Async version of chat."""
+        self._ensure_router()
+        
+        route_result = await self._a3m_router.aroute(
+            messages=messages,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens,
+            **kwargs,
+        )
+        
+        return {
+            "content": route_result.content,
+            "provider": getattr(route_result, 'provider', 'unknown'),
+            "cost": getattr(route_result, 'cost', 0.0),
+            "finish_reason": getattr(route_result, 'finish_reason', 'stop'),
+        }
+
+    def __repr__(self) -> str:
+        return (
+            f"A3MAutoGenAdapter("
+            f"model={self.model!r}, "
+            f"temperature={self.temperature}, "
+            f"max_tokens={self.max_tokens}, "
+            f"ensemble={self.parallel_ensemble})"
+        )

package/adapters/a3m_adapter/adapter/config.py

@@ -0,0 +1,100 @@
+"""
+Configuration management for A3M Router adapters.
+
+Provides settings for:
+- Default model selection strategy
+- Cost optimization thresholds
+- Parallel ensemble settings
+- Provider priority lists
+
+Usage:
+    from a3m_adapter_config import A3MConfig
+    
+    config = A3MConfig.from_file("a3m_config.yaml")
+    llm = A3MChatModel(**config.to_dict())
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class A3MConfig:
+    """Configuration for A3M Router adapters."""
+
+    # Model selection
+    model: str = "auto"
+    
+    # Sampling parameters
+    temperature: float = 0.0
+    max_tokens: Optional[int] = 4096
+    top_p: float = 1.0
+    frequency_penalty: float = 0.0
+    presence_penalty: float = 0.0
+
+    # Routing strategy
+    parallel_ensemble: int = 1
+    fallback_enabled: bool = True
+    cost_threshold: float = 0.05  # Max $ per 1k tokens
+    
+    # Provider preferences (highest priority first)
+    preferred_providers: List[str] = field(default_factory=lambda: [
+        "openai", "anthropic", "google", "azure_openai", 
+        "azure_ais", "litellm", "groq", "together"
+    ])
+    
+    # Excluded providers (never use)
+    excluded_providers: List[str] = field(default_factory=lambda: [])
+    
+    # API configuration
+    api_endpoint: str = "http://localhost:8787/v1"
+    api_key: Optional[str] = None
+
+    # Budget controls
+    monthly_budget_usd: Optional[float] = None
+    daily_budget_usd: Optional[float] = None
+
+    @classmethod
+    def from_file(cls, path: str) -> "A3MConfig":
+        """Load configuration from YAML file."""
+        try:
+            import yaml
+            with open(path, 'r') as f:
+                data = yaml.safe_load(f)
+            return cls(**data)
+        except ImportError:
+            logger.warning("PyYAML not installed, using JSON")
+            return cls.from_json(path)
+
+    @classmethod
+    def from_json(cls, path: str) -> "A3MConfig":
+        """Load configuration from JSON file."""
+        with open(path, 'r') as f:
+            data = json.load(f)
+        return cls(**data)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return asdict(self)
+
+    def to_json(self, path: Optional[str] = None) -> Optional[str]:
+        """Convert to JSON string or save to file."""
+        data = json.dumps(self.to_dict(), indent=2)
+        if path:
+            with open(path, 'w') as f:
+                f.write(data)
+        return data
+
+    def update_budget_limits(self, remaining_usd: float) -> None:
+        """Update budget limits based on remaining funds."""
+        if self.daily_budget_usd is not None:
+            remaining_pct = remaining_usd / self.daily_budget_usd
+            if remaining_pct < 0.1:
+                logger.warning("Low daily budget: %s remaining", remaining_usd)
+                self.parallel_ensemble = 1  # Reduce to single-provider

package/adapters/a3m_adapter/adapter/haystack.py

@@ -0,0 +1,197 @@
+"""
+A3M Router Adapter for Haystack (Deepset's RAG framework).
+
+Drop-in replacement for Haystack's OpenAIGenerator that routes through A3M Router
+for intelligent, cost-optimized RAG pipelines.
+
+Usage:
+    from haystack import Pipeline
+    from haystack.nodes import Retriever, PromptNode
+    from a3m_adapter import A3MHaystackAdapter
+    
+    prompt_node = PromptNode(
+        "auto",
+        api_key=None,
+        generator_type='openai',
+        model_adapter=A3MHaystackAdapter(model='auto', parallel_ensemble=2),
+    )
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+HAYSTACK_AVAILABLE = False
+try:
+    from haystack.nodes.base import BaseGenerator
+    HAYSTACK_AVAILABLE = True
+except ImportError:
+    logger.warning("Haystack not installed. Install with: pip install farm-haystack")
+
+A3M_AVAILABLE = False
+try:
+    from a3m.router import A3MRouter, RouteResponse
+    A3M_AVAILABLE = True
+except ImportError:
+    logger.warning(
+        "A3M Router not installed. Install with: pip install adaptive-memory-multi-model-router"
+    )
+
+
+class A3MHaystackAdapter:
+    """
+    A3M Router adapter for Haystack's PromptNode.
+
+    Enables Haystack RAG pipelines to use A3M Router for automatic model selection
+    across 47+ providers with cost optimization.
+    """
+
+    def __init__(
+        self,
+        model: str = "auto",
+        temperature: float = 0.7,
+        max_tokens: int = 4096,
+        parallel_ensemble: int = 1,
+        api_key: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize A3M Router adapter for Haystack.
+        """
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.parallel_ensemble = parallel_ensemble
+        self.api_key = api_key
+        self._a3m_router = None
+        self._initialized = False
+        self._kwargs = kwargs
+
+    def _ensure_router(self) -> None:
+        """Lazily initialize the A3M router."""
+        if self._initialized:
+            return
+        
+        if not A3M_AVAILABLE:
+            raise ImportError(
+                "A3M Router is not installed. "
+                "Install with: pip install adaptive-memory-multi-model-router"
+            )
+        
+        self._a3m_router = A3MRouter(
+            model=self.model,
+            temperature=self.temperature,
+            parallel_ensemble=self.parallel_ensemble,
+        )
+        self._initialized = True
+        logger.info(
+            "A3M Router initialized for Haystack: model=%s",
+            self.model,
+        )
+
+    def predict(
+        self,
+        query: str,
+        documents: Optional[List[Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """
+        Generate answer from query and optional retrieved documents.
+        
+        Args:
+            query: The search query
+            documents: Optional list of retrieved documents for RAG
+            
+        Returns:
+            Dict with 'answers', 'provider', 'cost'
+        """
+        self._ensure_router()
+        
+        # Build context from documents if provided
+        if documents:
+            context = "\n\n".join([
+                f"Document {i+1}: {getattr(doc, 'content', str(doc))}"
+                for i, doc in enumerate(documents[:5])  # Limit to 5 docs
+            ])
+            prompt = f"Context:\n{context}\n\nQuestion: {query}\n\nAnswer:"
+        else:
+            prompt = query
+        
+        messages = [{"role": "user", "content": prompt}]
+        
+        import asyncio
+        loop = asyncio.get_event_loop()
+        route_result = loop.run_in_executor(
+            None,
+            lambda: self._a3m_router.route(
+                messages=messages,
+                temperature=kwargs.get("temperature", self.temperature),
+                max_tokens=kwargs.get("max_tokens", self.max_tokens),
+                **kwargs,
+            ),
+        )
+        
+        return {
+            "answers": [{"answer": route_result.content, "score": 1.0}],
+            "provider": getattr(route_result, 'provider', 'a3m'),
+            "cost": getattr(route_result, 'cost', 0.0),
+        }
+
+    async def apredict(
+        self,
+        query: str,
+        documents: Optional[List[Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """Async predict for Haystack."""
+        self._ensure_router()
+        
+        if documents:
+            context = "\n\n".join([
+                f"Document {i+1}: {getattr(doc, 'content', str(doc))}"
+                for i, doc in enumerate(documents[:5])
+            ])
+            prompt = f"Context:\n{context}\n\nQuestion: {query}\n\nAnswer:"
+        else:
+            prompt = query
+        
+        messages = [{"role": "user", "content": prompt}]
+        
+        route_result = await self._a3m_router.aroute(
+            messages=messages,
+            temperature=kwargs.get("temperature", self.temperature),
+            max_tokens=kwargs.get("max_tokens", self.max_tokens),
+            **kwargs,
+        )
+        
+        return {
+            "answers": [{"answer": route_result.content, "score": 1.0}],
+            "provider": getattr(route_result, 'provider', 'a3m'),
+            "cost": getattr(route_result, 'cost', 0.0),
+        }
+
+    def run(
+        self,
+        query: str,
+        documents: Optional[List[Any]] = None,
+        **kwargs: Any,
+    ) -> tuple[Dict[str, Any], str]:
+        """
+        Haystack-compatible run method.
+        
+        Returns:
+            Tuple of (results dict, pipeline run metadata)
+        """
+        result = self.predict(query, documents, **kwargs)
+        return (result, "a3m-haystack")
+
+    def __repr__(self) -> str:
+        return (
+            f"A3MHaystackAdapter("
+            f"model={self.model!r}, "
+            f"temperature={self.temperature}, "
+            f"max_tokens={self.max_tokens})"
+        )

package/adapters/a3m_adapter/adapter/langchain.py

@@ -0,0 +1,155 @@
+"""
+A3M Router Adapter for LangChain.
+
+Drop-in replacement for LangChain's ChatOpenAI that routes through A3M Router
+for intelligent, cost-optimized model selection across 47+ providers.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Check availability
+LANGCHAIN_AVAILABLE = False
+try:
+    from langchain_core.language_models import BaseChatModel
+    from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage
+    from langchain_core.outputs import ChatGeneration, ChatResult, LLMResult
+    LANGCHAIN_AVAILABLE = True
+except ImportError:
+    logger.warning("LangChain not installed. Install with: pip install langchain langchain-core")
+
+A3M_AVAILABLE = False
+try:
+    from a3m.router import A3MRouter, RouteResponse
+    A3M_AVAILABLE = True
+except ImportError:
+    logger.warning("A3M Router not installed. Install with: pip install adaptive-memory-multi-model-router")
+
+
+class A3MLangChainAdapter:
+    """
+    A3M Router adapter for LangChain's ChatOpenAI interface.
+
+    Routes prompts through A3M Router to automatically select the cheapest
+    capable model across 47+ LLM providers.
+    """
+
+    def __init__(
+        self,
+        model: str = "auto",
+        temperature: float = 0.0,
+        max_tokens: Optional[int] = 4096,
+        parallel_ensemble: int = 1,
+        api_key: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Initialize A3M Router adapter.
+
+        Args:
+            model: Model name or "auto" for automatic routing
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens to generate
+            parallel_ensemble: Number of providers to run in parallel
+            api_key: A3M API key (optional)
+        """
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.parallel_ensemble = parallel_ensemble
+        self.api_key = api_key
+        self._a3m_router = None
+        self._initialized = False
+
+    def _ensure_router(self) -> None:
+        """Lazily initialize the A3M router."""
+        if self._initialized:
+            return
+        
+        if not A3M_AVAILABLE:
+            raise ImportError(
+                "A3M Router is not installed. "
+                "Install with: pip install adaptive-memory-multi-model-router"
+            )
+        
+        self._a3m_router = A3MRouter(
+            model=self.model,
+            temperature=self.temperature,
+            parallel_ensemble=self.parallel_ensemble,
+        )
+        self._initialized = True
+        logger.info(
+            "A3M Router initialized: model=%s, ensemble=%d",
+            self.model,
+            self.parallel_ensemble,
+        )
+
+    @property
+    def _llm_type(self) -> str:
+        return "a3m_router"
+
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Any = None,
+        **kwargs: Any,
+    ) -> LLMResult:
+        """Generate a response using A3M Router."""
+        self._ensure_router()
+        
+        # Convert messages
+        a3m_messages = self._convert_messages(messages)
+
+        # Route through A3M
+        import asyncio
+        loop = asyncio.get_event_loop()
+        route_result = loop.run_in_executor(
+            None,
+            lambda: self._a3m_router.route(
+                messages=a3m_messages,
+                temperature=self.temperature,
+                max_tokens=self.max_tokens,
+                stop=stop,
+                **kwargs,
+            ),
+        )
+
+        ai_message = AIMessage(content=route_result.content)
+        generation = ChatGeneration(message=ai_message)
+        return LLMResult(generations=[[generation]])
+
+    def _convert_messages(self, messages: List[BaseMessage]) -> List[Dict[str, Any]]:
+        """Convert LangChain messages to A3M format."""
+        a3m_messages = []
+        for msg in messages:
+            if isinstance(msg, SystemMessage):
+                a3m_messages.append({"role": "system", "content": msg.content})
+            elif isinstance(msg, HumanMessage):
+                a3m_messages.append({"role": "user", "content": msg.content})
+            elif isinstance(msg, AIMessage):
+                a3m_messages.append({"role": "assistant", "content": msg.content})
+            elif isinstance(msg, ToolMessage):
+                a3m_messages.append(
+                    {"role": "tool", "content": msg.content, "tool_call_id": msg.tool_call_id}
+                )
+            else:
+                a3m_messages.append({"role": "user", "content": str(msg)})
+        return a3m_messages
+
+    def bind_tools(self, tools: List[Dict[str, Any]], **kwargs: Any) -> "A3MLangChainAdapter":
+        """Bind tools for function calling."""
+        return self
+
+    def __repr__(self) -> str:
+        return (
+            f"A3MLangChainAdapter("
+            f"model={self.model!r}, "
+            f"temperature={self.temperature}, "
+            f"max_tokens={self.max_tokens}, "
+            f"ensemble={self.parallel_ensemble})"
+        )