powermem 0.1.0__py3-none-any.whl

powermem/integrations/llm/__init__.py

@@ -0,0 +1,18 @@
+"""
+LLM integration module
+
+This module provides LLM integrations and factory.
+"""
+from .base import LLMBase
+from .configs import LLMConfig
+from .factory import LLMFactory
+
+# provider alias name 
+LlmFactory = LLMFactory
+LlmConfig = LLMConfig
+
+__all__ = [
+    "LLMBase",
+    "LlmFactory",
+    "LlmConfig"
+]

powermem/integrations/llm/anthropic.py

@@ -0,0 +1,87 @@
+import os
+from typing import Dict, List, Optional, Union
+
+from powermem.integrations.llm import LLMBase
+from powermem.integrations.llm.config.anthropic import AnthropicConfig
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+try:
+    import anthropic
+except ImportError:
+    raise ImportError("The 'anthropic' library is required. Please install it using 'pip install anthropic'.")
+
+
+class AnthropicLLM(LLMBase):
+    def __init__(self, config: Optional[Union[BaseLLMConfig, AnthropicConfig, Dict]] = None):
+        # Convert to AnthropicConfig if needed
+        if config is None:
+            config = AnthropicConfig()
+        elif isinstance(config, dict):
+            config = AnthropicConfig(**config)
+        elif isinstance(config, BaseLLMConfig) and not isinstance(config, AnthropicConfig):
+            # Convert BaseLLMConfig to AnthropicConfig
+            config = AnthropicConfig(
+                model=config.model,
+                temperature=config.temperature,
+                api_key=config.api_key,
+                max_tokens=config.max_tokens,
+                top_p=config.top_p,
+                top_k=config.top_k,
+                enable_vision=config.enable_vision,
+                vision_details=config.vision_details,
+                http_client_proxies=config.http_client,
+            )
+
+        super().__init__(config)
+
+        if not self.config.model:
+            self.config.model = "claude-3-5-sonnet-20240620"
+
+        api_key = self.config.api_key or os.getenv("ANTHROPIC_API_KEY")
+        self.client = anthropic.Anthropic(api_key=api_key)
+
+    def generate_response(
+            self,
+            messages: List[Dict[str, str]],
+            response_format=None,
+            tools: Optional[List[Dict]] = None,
+            tool_choice: str = "auto",
+            **kwargs,
+    ):
+        """
+        Generate a response based on the given messages using Anthropic.
+
+        Args:
+            messages (list): List of message dicts containing 'role' and 'content'.
+            response_format (str or object, optional): Format of the response. Defaults to "text".
+            tools (list, optional): List of tools that the model can call. Defaults to None.
+            tool_choice (str, optional): Tool choice method. Defaults to "auto".
+            **kwargs: Additional Anthropic-specific parameters.
+
+        Returns:
+            str: The generated response.
+        """
+        # Separate system message from other messages
+        system_message = ""
+        filtered_messages = []
+        for message in messages:
+            if message["role"] == "system":
+                system_message = message["content"]
+            else:
+                filtered_messages.append(message)
+
+        params = self._get_supported_params(messages=messages, **kwargs)
+        params.update(
+            {
+                "model": self.config.model,
+                "messages": filtered_messages,
+                "system": system_message,
+            }
+        )
+
+        if tools:  # TODO: Remove tools if no issues found with new memory addition logic
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
+
+        response = self.client.messages.create(**params)
+        return response.content[0].text

powermem/integrations/llm/base.py

@@ -0,0 +1,132 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Union
+
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+
+class LLMBase(ABC):
+    """
+    Base class for all LLM providers.
+    Handles common functionality and delegates provider-specific logic to subclasses.
+    """
+
+    def __init__(self, config: Optional[Union[BaseLLMConfig, Dict]] = None):
+        """Initialize a base LLM class
+
+        :param config: LLM configuration option class or dict, defaults to None
+        :type config: Optional[Union[BaseLLMConfig, Dict]], optional
+        """
+        if config is None:
+            self.config = BaseLLMConfig()
+        elif isinstance(config, dict):
+            # Handle dict-based configuration (backward compatibility)
+            self.config = BaseLLMConfig(**config)
+        else:
+            self.config = config
+
+        # Validate configuration
+        self._validate_config()
+
+    def _validate_config(self):
+        """
+        Validate the configuration.
+        Override in subclasses to add provider-specific validation.
+        """
+        if not hasattr(self.config, "model"):
+            raise ValueError("Configuration must have a 'model' attribute")
+
+        if not hasattr(self.config, "api_key") and not hasattr(self.config, "api_key"):
+            # Check if API key is available via environment variable
+            # This will be handled by individual providers
+            pass
+
+    def _is_reasoning_model(self, model: str) -> bool:
+        """
+        Check if the model is a reasoning model or GPT-5 series that doesn't support certain parameters.
+
+        Args:
+            model: The model name to check
+
+        Returns:
+            bool: True if the model is a reasoning model or GPT-5 series
+        """
+        reasoning_models = {
+            "o1", "o1-preview", "o3-mini", "o3",
+            "gpt-5", "gpt-5o", "gpt-5o-mini", "gpt-5o-micro",
+        }
+
+        if model.lower() in reasoning_models:
+            return True
+
+        model_lower = model.lower()
+        if any(reasoning_model in model_lower for reasoning_model in ["gpt-5", "o1", "o3"]):
+            return True
+
+        return False
+
+    def _get_supported_params(self, **kwargs) -> Dict:
+        """
+        Get parameters that are supported by the current model.
+        Filters out unsupported parameters for reasoning models and GPT-5 series.
+
+        Args:
+            **kwargs: Additional parameters to include
+
+        Returns:
+            Dict: Filtered parameters dictionary
+        """
+        model = getattr(self.config, 'model', '')
+
+        if self._is_reasoning_model(model):
+            supported_params = {}
+
+            if "messages" in kwargs:
+                supported_params["messages"] = kwargs["messages"]
+            if "response_format" in kwargs:
+                supported_params["response_format"] = kwargs["response_format"]
+            if "tools" in kwargs:
+                supported_params["tools"] = kwargs["tools"]
+            if "tool_choice" in kwargs:
+                supported_params["tool_choice"] = kwargs["tool_choice"]
+
+            return supported_params
+        else:
+            # For regular models, include all common parameters
+            return self._get_common_params(**kwargs)
+
+    @abstractmethod
+    def generate_response(
+            self, messages: List[Dict[str, str]], tools: Optional[List[Dict]] = None, tool_choice: str = "auto",
+            **kwargs
+    ):
+        """
+        Generate a response based on the given messages.
+
+        Args:
+            messages (list): List of message dicts containing 'role' and 'content'.
+            tools (list, optional): List of tools that the model can call. Defaults to None.
+            tool_choice (str, optional): Tool choice method. Defaults to "auto".
+            **kwargs: Additional provider-specific parameters.
+
+        Returns:
+            str or dict: The generated response.
+        """
+        pass
+
+    def _get_common_params(self, **kwargs) -> Dict:
+        """
+        Get common parameters that most providers use.
+
+        Returns:
+            Dict: Common parameters dictionary.
+        """
+        params = {
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "top_p": self.config.top_p,
+        }
+
+        # Add provider-specific parameters from kwargs
+        params.update(kwargs)
+
+        return params

powermem/integrations/llm/config/anthropic.py

@@ -0,0 +1,56 @@
+from typing import Optional
+
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+
+class AnthropicConfig(BaseLLMConfig):
+    """
+    Configuration class for Anthropic-specific parameters.
+    Inherits from BaseLLMConfig and adds Anthropic-specific settings.
+    """
+
+    def __init__(
+            self,
+            # Base parameters
+            model: Optional[str] = None,
+            temperature: float = 0.1,
+            api_key: Optional[str] = None,
+            max_tokens: int = 2000,
+            top_p: float = 0.1,
+            top_k: int = 1,
+            enable_vision: bool = False,
+            vision_details: Optional[str] = "auto",
+            http_client_proxies: Optional[dict] = None,
+            # Anthropic-specific parameters
+            anthropic_base_url: Optional[str] = None,
+    ):
+        """
+        Initialize Anthropic configuration.
+
+        Args:
+            model: Anthropic model to use, defaults to None
+            temperature: Controls randomness, defaults to 0.1
+            api_key: Anthropic API key, defaults to None
+            max_tokens: Maximum tokens to generate, defaults to 2000
+            top_p: Nucleus sampling parameter, defaults to 0.1
+            top_k: Top-k sampling parameter, defaults to 1
+            enable_vision: Enable vision capabilities, defaults to False
+            vision_details: Vision detail level, defaults to "auto"
+            http_client_proxies: HTTP client proxy settings, defaults to None
+            anthropic_base_url: Anthropic API base URL, defaults to None
+        """
+        # Initialize base parameters
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            enable_vision=enable_vision,
+            vision_details=vision_details,
+            http_client_proxies=http_client_proxies,
+        )
+
+        # Anthropic-specific parameters
+        self.anthropic_base_url = anthropic_base_url

powermem/integrations/llm/config/azure.py

@@ -0,0 +1,56 @@
+from typing import Any, Dict, Optional
+
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+
+class AzureOpenAIConfig(BaseLLMConfig):
+    """
+    Configuration class for Azure OpenAI-specific parameters.
+    Inherits from BaseLLMConfig and adds Azure OpenAI-specific settings.
+    """
+
+    def __init__(
+            self,
+            # Base parameters
+            model: Optional[str] = None,
+            temperature: float = 0.1,
+            api_key: Optional[str] = None,
+            max_tokens: int = 2000,
+            top_p: float = 0.1,
+            top_k: int = 1,
+            enable_vision: bool = False,
+            vision_details: Optional[str] = "auto",
+            http_client_proxies: Optional[dict] = None,
+            # Azure OpenAI-specific parameters
+            azure_kwargs: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize Azure OpenAI configuration.
+
+        Args:
+            model: Azure OpenAI model to use, defaults to None
+            temperature: Controls randomness, defaults to 0.1
+            api_key: Azure OpenAI API key, defaults to None
+            max_tokens: Maximum tokens to generate, defaults to 2000
+            top_p: Nucleus sampling parameter, defaults to 0.1
+            top_k: Top-k sampling parameter, defaults to 1
+            enable_vision: Enable vision capabilities, defaults to False
+            vision_details: Vision detail level, defaults to "auto"
+            http_client_proxies: HTTP client proxy settings, defaults to None
+            azure_kwargs: Azure-specific configuration, defaults to None
+        """
+        # Initialize base parameters
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            enable_vision=enable_vision,
+            vision_details=vision_details,
+            http_client_proxies=http_client_proxies,
+        )
+
+        # Azure OpenAI-specific parameters
+        self.azure_kwargs = AzureConfig(**(azure_kwargs or {}))

powermem/integrations/llm/config/base.py

@@ -0,0 +1,62 @@
+from abc import ABC
+from typing import Dict, Optional, Union
+
+import httpx
+
+
+class BaseLLMConfig(ABC):
+    """
+    Base configuration for LLMs with only common parameters.
+    Provider-specific configurations should be handled by separate config classes.
+
+    This class contains only the parameters that are common across all LLM providers.
+    For provider-specific parameters, use the appropriate provider config class.
+    """
+
+    def __init__(
+        self,
+        model: Optional[Union[str, Dict]] = None,
+        temperature: float = 0.1,
+        api_key: Optional[str] = None,
+        max_tokens: int = 2000,
+        top_p: float = 0.1,
+        top_k: int = 1,
+        enable_vision: bool = False,
+        vision_details: Optional[str] = "auto",
+        http_client_proxies: Optional[Union[Dict, str]] = None,
+    ):
+        """
+        Initialize a base configuration class instance for the LLM.
+
+        Args:
+            model: The model identifier to use (e.g., "gpt-4o-mini", "claude-3-5-sonnet-20240620")
+                Defaults to None (will be set by provider-specific configs)
+            temperature: Controls the randomness of the model's output.
+                Higher values (closer to 1) make output more random, lower values make it more deterministic.
+                Range: 0.0 to 2.0. Defaults to 0.1
+            api_key: API key for the LLM provider. If None, will try to get from environment variables.
+                Defaults to None
+            max_tokens: Maximum number of tokens to generate in the response.
+                Range: 1 to 4096 (varies by model). Defaults to 2000
+            top_p: Nucleus sampling parameter. Controls diversity via nucleus sampling.
+                Higher values (closer to 1) make word selection more diverse.
+                Range: 0.0 to 1.0. Defaults to 0.1
+            top_k: Top-k sampling parameter. Limits the number of tokens considered for each step.
+                Higher values make word selection more diverse.
+                Range: 1 to 40. Defaults to 1
+            enable_vision: Whether to enable vision capabilities for the model.
+                Only applicable to vision-enabled models. Defaults to False
+            vision_details: Level of detail for vision processing.
+                Options: "low", "high", "auto". Defaults to "auto"
+            http_client_proxies: Proxy settings for HTTP client.
+                Can be a dict or string. Defaults to None
+        """
+        self.model = model
+        self.temperature = temperature
+        self.api_key = api_key
+        self.max_tokens = max_tokens
+        self.top_p = top_p
+        self.top_k = top_k
+        self.enable_vision = enable_vision
+        self.vision_details = vision_details
+        self.http_client = httpx.Client(proxies=http_client_proxies) if http_client_proxies else None

powermem/integrations/llm/config/deepseek.py

@@ -0,0 +1,56 @@
+from typing import Optional
+
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+
+class DeepSeekConfig(BaseLLMConfig):
+    """
+    Configuration class for DeepSeek-specific parameters.
+    Inherits from BaseLLMConfig and adds DeepSeek-specific settings.
+    """
+
+    def __init__(
+            self,
+            # Base parameters
+            model: Optional[str] = None,
+            temperature: float = 0.1,
+            api_key: Optional[str] = None,
+            max_tokens: int = 2000,
+            top_p: float = 0.1,
+            top_k: int = 1,
+            enable_vision: bool = False,
+            vision_details: Optional[str] = "auto",
+            http_client_proxies: Optional[dict] = None,
+            # DeepSeek-specific parameters
+            deepseek_base_url: Optional[str] = None,
+    ):
+        """
+        Initialize DeepSeek configuration.
+
+        Args:
+            model: DeepSeek model to use, defaults to None
+            temperature: Controls randomness, defaults to 0.1
+            api_key: DeepSeek API key, defaults to None
+            max_tokens: Maximum tokens to generate, defaults to 2000
+            top_p: Nucleus sampling parameter, defaults to 0.1
+            top_k: Top-k sampling parameter, defaults to 1
+            enable_vision: Enable vision capabilities, defaults to False
+            vision_details: Vision detail level, defaults to "auto"
+            http_client_proxies: HTTP client proxy settings, defaults to None
+            deepseek_base_url: DeepSeek API base URL, defaults to None
+        """
+        # Initialize base parameters
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            enable_vision=enable_vision,
+            vision_details=vision_details,
+            http_client_proxies=http_client_proxies,
+        )
+
+        # DeepSeek-specific parameters
+        self.deepseek_base_url = deepseek_base_url

powermem/integrations/llm/config/ollama.py

@@ -0,0 +1,56 @@
+from typing import Optional
+
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+
+class OllamaConfig(BaseLLMConfig):
+    """
+    Configuration class for Ollama-specific parameters.
+    Inherits from BaseLLMConfig and adds Ollama-specific settings.
+    """
+
+    def __init__(
+            self,
+            # Base parameters
+            model: Optional[str] = None,
+            temperature: float = 0.1,
+            api_key: Optional[str] = None,
+            max_tokens: int = 2000,
+            top_p: float = 0.1,
+            top_k: int = 1,
+            enable_vision: bool = False,
+            vision_details: Optional[str] = "auto",
+            http_client_proxies: Optional[dict] = None,
+            # Ollama-specific parameters
+            ollama_base_url: Optional[str] = None,
+    ):
+        """
+        Initialize Ollama configuration.
+
+        Args:
+            model: Ollama model to use, defaults to None
+            temperature: Controls randomness, defaults to 0.1
+            api_key: Ollama API key, defaults to None
+            max_tokens: Maximum tokens to generate, defaults to 2000
+            top_p: Nucleus sampling parameter, defaults to 0.1
+            top_k: Top-k sampling parameter, defaults to 1
+            enable_vision: Enable vision capabilities, defaults to False
+            vision_details: Vision detail level, defaults to "auto"
+            http_client_proxies: HTTP client proxy settings, defaults to None
+            ollama_base_url: Ollama base URL, defaults to None
+        """
+        # Initialize base parameters
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            enable_vision=enable_vision,
+            vision_details=vision_details,
+            http_client_proxies=http_client_proxies,
+        )
+
+        # Ollama-specific parameters
+        self.ollama_base_url = ollama_base_url

powermem/integrations/llm/config/openai.py

@@ -0,0 +1,79 @@
+from typing import Any, Callable, List, Optional
+
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+
+class OpenAIConfig(BaseLLMConfig):
+    """
+    Configuration class for OpenAI and OpenRouter-specific parameters.
+    Inherits from BaseLLMConfig and adds OpenAI-specific settings.
+    """
+
+    def __init__(
+            self,
+            # Base parameters
+            model: Optional[str] = None,
+            temperature: float = 0.1,
+            api_key: Optional[str] = None,
+            max_tokens: int = 2000,
+            top_p: float = 0.1,
+            top_k: int = 1,
+            enable_vision: bool = False,
+            vision_details: Optional[str] = "auto",
+            http_client_proxies: Optional[dict] = None,
+            # OpenAI-specific parameters
+            openai_base_url: Optional[str] = None,
+            models: Optional[List[str]] = None,
+            route: Optional[str] = "fallback",
+            openrouter_base_url: Optional[str] = None,
+            site_url: Optional[str] = None,
+            app_name: Optional[str] = None,
+            store: bool = False,
+            # Response monitoring callback
+            response_callback: Optional[Callable[[Any, dict, dict], None]] = None,
+    ):
+        """
+        Initialize OpenAI configuration.
+
+        Args:
+            model: OpenAI model to use, defaults to None
+            temperature: Controls randomness, defaults to 0.1
+            api_key: OpenAI API key, defaults to None
+            max_tokens: Maximum tokens to generate, defaults to 2000
+            top_p: Nucleus sampling parameter, defaults to 0.1
+            top_k: Top-k sampling parameter, defaults to 1
+            enable_vision: Enable vision capabilities, defaults to False
+            vision_details: Vision detail level, defaults to "auto"
+            http_client_proxies: HTTP client proxy settings, defaults to None
+            openai_base_url: OpenAI API base URL, defaults to None
+            models: List of models for OpenRouter, defaults to None
+            route: OpenRouter route strategy, defaults to "fallback"
+            openrouter_base_url: OpenRouter base URL, defaults to None
+            site_url: Site URL for OpenRouter, defaults to None
+            app_name: Application name for OpenRouter, defaults to None
+            response_callback: Optional callback for monitoring LLM responses.
+        """
+        # Initialize base parameters
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            enable_vision=enable_vision,
+            vision_details=vision_details,
+            http_client_proxies=http_client_proxies,
+        )
+
+        # OpenAI-specific parameters
+        self.openai_base_url = openai_base_url
+        self.models = models
+        self.route = route
+        self.openrouter_base_url = openrouter_base_url
+        self.site_url = site_url
+        self.app_name = app_name
+        self.store = store
+
+        # Response monitoring
+        self.response_callback = response_callback

powermem/integrations/llm/config/qwen.py

@@ -0,0 +1,68 @@
+from typing import Any, Callable, Optional
+
+from powermem.integrations.llm.config.base import BaseLLMConfig
+
+
+class QwenConfig(BaseLLMConfig):
+    """
+    Configuration class for Qwen-specific parameters.
+    Inherits from BaseLLMConfig and adds Qwen-specific settings.
+    """
+
+    def __init__(
+            self,
+            # Base parameters
+            model: Optional[str] = None,
+            temperature: float = 0.1,
+            api_key: Optional[str] = None,
+            max_tokens: int = 2000,
+            top_p: float = 0.1,
+            top_k: int = 1,
+            enable_vision: bool = False,
+            vision_details: Optional[str] = "auto",
+            http_client_proxies: Optional[dict] = None,
+            # Qwen-specific parameters
+            dashscope_base_url: Optional[str] = None,
+            enable_search: bool = False,
+            search_params: Optional[dict] = None,
+            # Response monitoring callback
+            response_callback: Optional[Callable[[Any, dict, dict], None]] = None,
+    ):
+        """
+        Initialize Qwen configuration.
+
+        Args:
+            model: Qwen model to use, defaults to None
+            temperature: Controls randomness, defaults to 0.1
+            api_key: DashScope API key, defaults to None
+            max_tokens: Maximum tokens to generate, defaults to 2000
+            top_p: Nucleus sampling parameter, defaults to 0.1
+            top_k: Top-k sampling parameter, defaults to 1
+            enable_vision: Enable vision capabilities, defaults to False
+            vision_details: Vision detail level, defaults to "auto"
+            http_client_proxies: HTTP client proxy settings, defaults to None
+            dashscope_base_url: DashScope API base URL, defaults to None
+            enable_search: Enable web search capability, defaults to False
+            search_params: Parameters for web search, defaults to None
+            response_callback: Optional callback for monitoring LLM responses.
+        """
+        # Initialize base parameters
+        super().__init__(
+            model=model,
+            temperature=temperature,
+            api_key=api_key,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            top_k=top_k,
+            enable_vision=enable_vision,
+            vision_details=vision_details,
+            http_client_proxies=http_client_proxies,
+        )
+
+        # Qwen-specific parameters
+        self.dashscope_base_url = dashscope_base_url
+        self.enable_search = enable_search
+        self.search_params = search_params or {}
+
+        # Response monitoring
+        self.response_callback = response_callback