agentrun-mem0ai 0.0.11__py3-none-any.whl

agentrun_mem0/llms/azure_openai.py

@@ -0,0 +1,141 @@
+import json
+import os
+from typing import Dict, List, Optional, Union
+
+from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+from openai import AzureOpenAI
+
+from agentrun_mem0.configs.llms.azure import AzureOpenAIConfig
+from agentrun_mem0.configs.llms.base import BaseLlmConfig
+from agentrun_mem0.llms.base import LLMBase
+from agentrun_mem0.memory.utils import extract_json
+
+SCOPE = "https://cognitiveservices.azure.com/.default"
+
+
+class AzureOpenAILLM(LLMBase):
+    def __init__(self, config: Optional[Union[BaseLlmConfig, AzureOpenAIConfig, Dict]] = None):
+        # Convert to AzureOpenAIConfig if needed
+        if config is None:
+            config = AzureOpenAIConfig()
+        elif isinstance(config, dict):
+            config = AzureOpenAIConfig(**config)
+        elif isinstance(config, BaseLlmConfig) and not isinstance(config, AzureOpenAIConfig):
+            # Convert BaseLlmConfig to AzureOpenAIConfig
+            config = AzureOpenAIConfig(
+                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)
+
+        # Model name should match the custom deployment name chosen for it.
+        if not self.config.model:
+            self.config.model = "gpt-4.1-nano-2025-04-14"
+
+        api_key = self.config.azure_kwargs.api_key or os.getenv("LLM_AZURE_OPENAI_API_KEY")
+        azure_deployment = self.config.azure_kwargs.azure_deployment or os.getenv("LLM_AZURE_DEPLOYMENT")
+        azure_endpoint = self.config.azure_kwargs.azure_endpoint or os.getenv("LLM_AZURE_ENDPOINT")
+        api_version = self.config.azure_kwargs.api_version or os.getenv("LLM_AZURE_API_VERSION")
+        default_headers = self.config.azure_kwargs.default_headers
+
+        # If the API key is not provided or is a placeholder, use DefaultAzureCredential.
+        if api_key is None or api_key == "" or api_key == "your-api-key":
+            self.credential = DefaultAzureCredential()
+            azure_ad_token_provider = get_bearer_token_provider(
+                self.credential,
+                SCOPE,
+            )
+            api_key = None
+        else:
+            azure_ad_token_provider = None
+
+        self.client = AzureOpenAI(
+            azure_deployment=azure_deployment,
+            azure_endpoint=azure_endpoint,
+            azure_ad_token_provider=azure_ad_token_provider,
+            api_version=api_version,
+            api_key=api_key,
+            http_client=self.config.http_client,
+            default_headers=default_headers,
+        )
+
+    def _parse_response(self, response, tools):
+        """
+        Process the response based on whether tools are used or not.
+
+        Args:
+            response: The raw response from API.
+            tools: The list of tools provided in the request.
+
+        Returns:
+            str or dict: The processed response.
+        """
+        if tools:
+            processed_response = {
+                "content": response.choices[0].message.content,
+                "tool_calls": [],
+            }
+
+            if response.choices[0].message.tool_calls:
+                for tool_call in response.choices[0].message.tool_calls:
+                    processed_response["tool_calls"].append(
+                        {
+                            "name": tool_call.function.name,
+                            "arguments": json.loads(extract_json(tool_call.function.arguments)),
+                        }
+                    )
+
+            return processed_response
+        else:
+            return response.choices[0].message.content
+
+    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 Azure OpenAI.
+
+        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 Azure OpenAI-specific parameters.
+
+        Returns:
+            str: The generated response.
+        """
+
+        user_prompt = messages[-1]["content"]
+
+        user_prompt = user_prompt.replace("assistant", "ai")
+
+        messages[-1]["content"] = user_prompt
+
+        params = self._get_supported_params(messages=messages, **kwargs)
+        
+        # Add model and messages
+        params.update({
+            "model": self.config.model,
+            "messages": messages,
+        })
+
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
+
+        response = self.client.chat.completions.create(**params)
+        return self._parse_response(response, tools)

agentrun_mem0/llms/azure_openai_structured.py

@@ -0,0 +1,91 @@
+import os
+from typing import Dict, List, Optional
+
+from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+from openai import AzureOpenAI
+
+from agentrun_mem0.configs.llms.base import BaseLlmConfig
+from agentrun_mem0.llms.base import LLMBase
+
+SCOPE = "https://cognitiveservices.azure.com/.default"
+
+
+class AzureOpenAIStructuredLLM(LLMBase):
+    def __init__(self, config: Optional[BaseLlmConfig] = None):
+        super().__init__(config)
+
+        # Model name should match the custom deployment name chosen for it.
+        if not self.config.model:
+            self.config.model = "gpt-4.1-nano-2025-04-14"
+
+        api_key = self.config.azure_kwargs.api_key or os.getenv("LLM_AZURE_OPENAI_API_KEY")
+        azure_deployment = self.config.azure_kwargs.azure_deployment or os.getenv("LLM_AZURE_DEPLOYMENT")
+        azure_endpoint = self.config.azure_kwargs.azure_endpoint or os.getenv("LLM_AZURE_ENDPOINT")
+        api_version = self.config.azure_kwargs.api_version or os.getenv("LLM_AZURE_API_VERSION")
+        default_headers = self.config.azure_kwargs.default_headers
+
+        # If the API key is not provided or is a placeholder, use DefaultAzureCredential.
+        if api_key is None or api_key == "" or api_key == "your-api-key":
+            self.credential = DefaultAzureCredential()
+            azure_ad_token_provider = get_bearer_token_provider(
+                self.credential,
+                SCOPE,
+            )
+            api_key = None
+        else:
+            azure_ad_token_provider = None
+
+        # Can display a warning if API version is of model and api-version
+        self.client = AzureOpenAI(
+            azure_deployment=azure_deployment,
+            azure_endpoint=azure_endpoint,
+            azure_ad_token_provider=azure_ad_token_provider,
+            api_version=api_version,
+            api_key=api_key,
+            http_client=self.config.http_client,
+            default_headers=default_headers,
+        )
+
+    def generate_response(
+        self,
+        messages: List[Dict[str, str]],
+        response_format: Optional[str] = None,
+        tools: Optional[List[Dict]] = None,
+        tool_choice: str = "auto",
+    ) -> str:
+        """
+        Generate a response based on the given messages using Azure OpenAI.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of dictionaries, each containing a 'role' and 'content' key.
+            response_format (Optional[str]): The desired format of the response. Defaults to None.
+
+        Returns:
+            str: The generated response.
+        """
+
+        user_prompt = messages[-1]["content"]
+
+        user_prompt = user_prompt.replace("assistant", "ai")
+
+        messages[-1]["content"] = user_prompt
+
+        params = {
+            "model": self.config.model,
+            "messages": messages,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "top_p": self.config.top_p,
+        }
+        if response_format:
+            params["response_format"] = response_format
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
+
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
+
+        response = self.client.chat.completions.create(**params)
+        return self._parse_response(response, tools)

agentrun_mem0/llms/base.py

@@ -0,0 +1,131 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Union
+
+from agentrun_mem0.configs.llms.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

agentrun_mem0/llms/configs.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class LlmConfig(BaseModel):
+    provider: str = Field(description="Provider of the LLM (e.g., 'ollama', 'openai')", default="openai")
+    config: Optional[dict] = Field(description="Configuration for the specific LLM", default={})
+
+    @field_validator("config")
+    def validate_config(cls, v, values):
+        provider = values.data.get("provider")
+        if provider in (
+            "openai",
+            "ollama",
+            "anthropic",
+            "groq",
+            "together",
+            "aws_bedrock",
+            "litellm",
+            "azure_openai",
+            "openai_structured",
+            "azure_openai_structured",
+            "gemini",
+            "deepseek",
+            "xai",
+            "sarvam",
+            "lmstudio",
+            "vllm",
+            "langchain",
+        ):
+            return v
+        else:
+            raise ValueError(f"Unsupported LLM provider: {provider}")

agentrun_mem0/llms/deepseek.py

@@ -0,0 +1,107 @@
+import json
+import os
+from typing import Dict, List, Optional, Union
+
+from openai import OpenAI
+
+from agentrun_mem0.configs.llms.base import BaseLlmConfig
+from agentrun_mem0.configs.llms.deepseek import DeepSeekConfig
+from agentrun_mem0.llms.base import LLMBase
+from agentrun_mem0.memory.utils import extract_json
+
+
+class DeepSeekLLM(LLMBase):
+    def __init__(self, config: Optional[Union[BaseLlmConfig, DeepSeekConfig, Dict]] = None):
+        # Convert to DeepSeekConfig if needed
+        if config is None:
+            config = DeepSeekConfig()
+        elif isinstance(config, dict):
+            config = DeepSeekConfig(**config)
+        elif isinstance(config, BaseLlmConfig) and not isinstance(config, DeepSeekConfig):
+            # Convert BaseLlmConfig to DeepSeekConfig
+            config = DeepSeekConfig(
+                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 = "deepseek-chat"
+
+        api_key = self.config.api_key or os.getenv("DEEPSEEK_API_KEY")
+        base_url = self.config.deepseek_base_url or os.getenv("DEEPSEEK_API_BASE") or "https://api.deepseek.com"
+        self.client = OpenAI(api_key=api_key, base_url=base_url)
+
+    def _parse_response(self, response, tools):
+        """
+        Process the response based on whether tools are used or not.
+
+        Args:
+            response: The raw response from API.
+            tools: The list of tools provided in the request.
+
+        Returns:
+            str or dict: The processed response.
+        """
+        if tools:
+            processed_response = {
+                "content": response.choices[0].message.content,
+                "tool_calls": [],
+            }
+
+            if response.choices[0].message.tool_calls:
+                for tool_call in response.choices[0].message.tool_calls:
+                    processed_response["tool_calls"].append(
+                        {
+                            "name": tool_call.function.name,
+                            "arguments": json.loads(extract_json(tool_call.function.arguments)),
+                        }
+                    )
+
+            return processed_response
+        else:
+            return response.choices[0].message.content
+
+    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 DeepSeek.
+
+        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 DeepSeek-specific parameters.
+
+        Returns:
+            str: The generated response.
+        """
+        params = self._get_supported_params(messages=messages, **kwargs)
+        params.update(
+            {
+                "model": self.config.model,
+                "messages": messages,
+            }
+        )
+
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = tool_choice
+
+        response = self.client.chat.completions.create(**params)
+        return self._parse_response(response, tools)