rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/shared/providers/embedding/azure_openai_embedding_client.py

@@ -1,5 +1,6 @@
-from typing import Any, Dict, List, Optional
 import os
+from typing import Any, Dict, List, Optional
+
 import structlog
 
 from rasa.shared.constants import (
@@ -42,6 +43,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
             If not provided, it will be set via environment variable.
         kwargs (Optional[Dict[str, Any]]): Optional configuration parameters specific
             to the embedding model deployment.
+
     Raises:
         ProviderClientValidationError: If validation of the client setup fails.
         DeprecationWarning: If deprecated environment variables are used for
@@ -60,6 +62,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
         super().__init__()  # type: ignore
         self._deployment = deployment
         self._model = model
+        self._extra_parameters = kwargs or {}
 
         # Set api_base with the following priority:
         # parameter -> Azure Env Var -> (deprecated) OpenAI Env Var
@@ -81,17 +84,55 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
         # Litellm does not support use of OPENAI_API_KEY, so we need to map it
         # because of backward compatibility. However, we're first looking at
         # AZURE_API_KEY.
-        self._api_key = os.environ.get(AZURE_API_KEY_ENV_VAR) or os.environ.get(
-            OPENAI_API_KEY_ENV_VAR
-        )
+        self._api_key_env_var = self._resolve_api_key_env_var()
 
-        self._extra_parameters = kwargs or {}
         self.validate_client_setup()
 
+    def _resolve_api_key_env_var(self) -> str:
+        """Resolves the environment variable to use for the API key.
+
+        Returns:
+            str: The env variable in dollar syntax format to use for the API key.
+        """
+        if API_KEY in self._extra_parameters:
+            # API key is set to an env var in the config itself
+            # in case the model is defined in the endpoints.yml
+            return self._extra_parameters[API_KEY]
+
+        if os.getenv(AZURE_API_KEY_ENV_VAR) is not None:
+            return "${AZURE_API_KEY}"
+
+        if os.getenv(OPENAI_API_KEY_ENV_VAR) is not None:
+            # API key can be set through OPENAI_API_KEY too,
+            # because of the backward compatibility
+            raise_deprecation_warning(
+                message=(
+                    f"Usage of '{OPENAI_API_KEY_ENV_VAR}' environment variable "
+                    "for setting the API key of "
+                    "Azure OpenAI client is deprecated and will "
+                    "be removed in 4.0.0. Please "
+                    f"use '{AZURE_API_KEY_ENV_VAR}' instead."
+                )
+            )
+            return "${OPENAI_API_KEY}"
+
+        structlogger.error(
+            "azure_openai_embedding_client.api_key_not_set",
+            event_info=(
+                "API key not set, it is required for API calls. "
+                f"Set it either via the environment variable "
+                f"'{AZURE_API_KEY_ENV_VAR}' or directly"
+                f"via the config key '{API_KEY}'."
+            ),
+        )
+        raise ProviderClientValidationError(
+            f"Missing required environment variable/config key '{API_KEY}' for "
+            f"API calls."
+        )
+
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "AzureOpenAIEmbeddingClient":
-        """
-        Initializes the client from given configuration.
+        """Initializes the client from given configuration.
 
         Args:
             config (Dict[str, Any]): Configuration.
@@ -142,8 +183,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
 
     @property
     def model(self) -> Optional[str]:
-        """
-        Returns the name of the model deployed on Azure. If model name is not
+        """Returns the name of the model deployed on Azure. If model name is not
         provided, returns "N/A".
         """
         return self._model
@@ -170,8 +210,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
 
     @property
     def _litellm_extra_parameters(self) -> Dict[str, Any]:
-        """
-        Returns the model parameters for the azure openai embedding client.
+        """Returns the model parameters for the azure openai embedding client.
 
         Returns:
             Dictionary containing the model parameters.
@@ -186,7 +225,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
             "api_base": self.api_base,
             "api_type": self.api_type,
             "api_version": self.api_version,
-            "api_key": self._api_key,
+            "api_key": self._api_key_env_var,
         }
 
     @property
@@ -197,8 +236,9 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
         return self.deployment
 
     def validate_client_setup(self) -> None:
-        """Perform client validation. By default only environment variables
-        are validated.
+        """Perform client validation.
+
+        By default, only environment variables are validated.
 
         Raises:
             ProviderClientValidationError if validation fails.
@@ -214,13 +254,6 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
                 "current_value": self.api_base,
                 "new_env_key": AZURE_API_BASE_ENV_VAR,
             },
-            {
-                "param_name": "API key",
-                "config_key": API_KEY,
-                "deprecated_env_key": OPENAI_API_KEY_ENV_VAR,
-                "current_value": self._api_key,
-                "new_env_key": AZURE_API_KEY_ENV_VAR,
-            },
             {
                 "param_name": "API version",
                 "config_key": API_VERSION_CONFIG_KEY,

rasa/shared/providers/embedding/litellm_router_embedding_client.py

@@ -0,0 +1,135 @@
+from typing import Any, Dict, List
+import logging
+import structlog
+
+from rasa.shared.exceptions import ProviderClientAPIException
+from rasa.shared.providers._configs.litellm_router_client_config import (
+    LiteLLMRouterClientConfig,
+)
+from rasa.shared.providers.embedding._base_litellm_embedding_client import (
+    _BaseLiteLLMEmbeddingClient,
+)
+from rasa.shared.providers.embedding.embedding_response import EmbeddingResponse
+from rasa.shared.providers.router._base_litellm_router_client import (
+    _BaseLiteLLMRouterClient,
+)
+from rasa.shared.utils.io import suppress_logs
+
+structlogger = structlog.get_logger()
+
+
+class LiteLLMRouterEmbeddingClient(
+    _BaseLiteLLMRouterClient, _BaseLiteLLMEmbeddingClient
+):
+    """A client for interfacing with LiteLLM Router Embedding endpoints.
+
+    Parameters:
+        model_group_id (str): The model group ID.
+        model_configurations (List[Dict[str, Any]]): The list of model configurations.
+        router_settings (Dict[str, Any]): The router settings.
+        kwargs (Optional[Dict[str, Any]]): Additional configuration parameters.
+
+    Raises:
+        ProviderClientValidationError: If validation of the client setup fails.
+    """
+
+    def __init__(
+        self,
+        model_group_id: str,
+        model_configurations: List[Dict[str, Any]],
+        router_settings: Dict[str, Any],
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model_group_id, model_configurations, router_settings, **kwargs
+        )
+
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> "LiteLLMRouterEmbeddingClient":
+        """Instantiates a LiteLLM Router Embedding client from a configuration dict.
+
+        Args:
+            config: (Dict[str, Any]) The configuration dictionary.
+
+        Returns:
+            LiteLLMRouterLLMClient: The instantiated LiteLLM Router LLM client.
+
+        Raises:
+            ValueError: If the configuration is invalid.
+        """
+        try:
+            client_config = LiteLLMRouterClientConfig.from_dict(config)
+        except (KeyError, ValueError) as e:
+            message = "Cannot instantiate a client from the passed configuration."
+            structlogger.error(
+                "litellm_router_llm_client.from_config.error",
+                message=message,
+                config=config,
+                original_error=e,
+            )
+            raise
+
+        return cls(
+            model_group_id=client_config.model_group_id,
+            model_configurations=client_config.litellm_model_list,
+            router_settings=client_config.router,
+            **client_config.extra_parameters,
+        )
+
+    @suppress_logs(log_level=logging.WARNING)
+    def embed(self, documents: List[str]) -> EmbeddingResponse:
+        """
+        Embeds a list of documents synchronously.
+
+        Args:
+            documents: List of documents to be embedded.
+
+        Returns:
+            List of embedding vectors.
+
+        Raises:
+            ProviderClientAPIException: If API calls raised an error.
+        """
+        self.validate_documents(documents)
+        try:
+            response = self.router_client.embedding(
+                input=documents, **self._embedding_fn_args
+            )
+            return self._format_response(response)
+        except Exception as e:
+            raise ProviderClientAPIException(
+                message="Failed to embed documents", original_exception=e
+            )
+
+    @suppress_logs(log_level=logging.WARNING)
+    async def aembed(self, documents: List[str]) -> EmbeddingResponse:
+        """
+        Embeds a list of documents asynchronously.
+
+        Args:
+            documents: List of documents to be embedded.
+
+        Returns:
+            List of embedding vectors.
+
+        Raises:
+            ProviderClientAPIException: If API calls raised an error.
+        """
+        self.validate_documents(documents)
+        try:
+            response = await self.router_client.aembedding(
+                input=documents, **self._embedding_fn_args
+            )
+            return self._format_response(response)
+        except Exception as e:
+            raise ProviderClientAPIException(
+                message="Failed to embed documents", original_exception=e
+            )
+
+    @property
+    def _embedding_fn_args(self) -> Dict[str, Any]:
+        """Returns the arguments to be passed to the embedding function."""
+        return {
+            **self._litellm_extra_parameters,
+            "model": self._model_group_id,
+        }

rasa/shared/providers/llm/_base_litellm_client.py

@@ -1,7 +1,7 @@
+import logging
 from abc import abstractmethod
 from typing import Dict, List, Any, Union
 
-import logging
 import structlog
 from litellm import (
     completion,
@@ -9,6 +9,7 @@ from litellm import (
     validate_environment,
 )
 
+from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -18,7 +19,7 @@ from rasa.shared.providers._ssl_verification_utils import (
     ensure_ssl_certificates_for_litellm_openai_based_clients,
 )
 from rasa.shared.providers.llm.llm_response import LLMResponse, LLMUsage
-from rasa.shared.utils.io import suppress_logs
+from rasa.shared.utils.io import suppress_logs, resolve_environment_variables
 
 structlogger = structlog.get_logger()
 
@@ -29,8 +30,7 @@ logging.getLogger("LiteLLM").setLevel(logging.WARNING)
 
 
 class _BaseLiteLLMClient:
-    """
-    An abstract base class for LiteLLM clients.
+    """An abstract base class for LiteLLM clients.
 
     This class defines the interface and common functionality for all clients
     based on LiteLLM.
@@ -99,11 +99,14 @@ class _BaseLiteLLMClient:
             ProviderClientValidationError if validation fails.
         """
         self._validate_environment_variables()
-        self._validate_api_key_not_in_config()
 
     def _validate_environment_variables(self) -> None:
         """Validate that the required environment variables are set."""
-        validation_info = validate_environment(self._litellm_model_name)
+        validation_info = validate_environment(
+            self._litellm_model_name,
+            api_key=self._litellm_extra_parameters.get(API_KEY),
+            api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
+        )
         if missing_environment_variables := validation_info.get(
             _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
         ):
@@ -118,61 +121,65 @@ class _BaseLiteLLMClient:
             )
             raise ProviderClientValidationError(event_info)
 
-    def _validate_api_key_not_in_config(self) -> None:
-        if "api_key" in self._litellm_extra_parameters:
-            event_info = (
-                "API Key is set through `api_key` extra parameter."
-                "Set API keys through environment variables."
-            )
-            structlogger.error(
-                "base_litellm_client.validate_api_key_not_in_config",
-                event_info=event_info,
-            )
-            raise ProviderClientValidationError(event_info)
-
     @suppress_logs(log_level=logging.WARNING)
     def completion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """
-        Synchronously generate completions for given list of messages.
+        """Synchronously generate completions for given list of messages.
 
         Args:
             messages: List of messages or a single message to generate the
                 completion for.
+
         Returns:
             List of message completions.
+
         Raises:
             ProviderClientAPIException: If the API request fails.
         """
         try:
             formatted_messages = self._format_messages(messages)
-            response = completion(
-                messages=formatted_messages, **self._completion_fn_args
-            )
+            arguments = resolve_environment_variables(self._completion_fn_args)
+            response = completion(messages=formatted_messages, **arguments)
             return self._format_response(response)
         except Exception as e:
             raise ProviderClientAPIException(e)
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """
-        Asynchronously generate completions for given list of messages.
+        """Asynchronously generate completions for given list of messages.
 
         Args:
             messages: List of messages or a single message to generate the
                 completion for.
+
         Returns:
             List of message completions.
+
         Raises:
             ProviderClientAPIException: If the API request fails.
         """
         try:
             formatted_messages = self._format_messages(messages)
-            response = await acompletion(
-                messages=formatted_messages, **self._completion_fn_args
-            )
+            arguments = resolve_environment_variables(self._completion_fn_args)
+            response = await acompletion(messages=formatted_messages, **arguments)
             return self._format_response(response)
         except Exception as e:
-            raise ProviderClientAPIException(e)
+            message = ""
+            from rasa.shared.providers.llm.self_hosted_llm_client import (
+                SelfHostedLLMClient,
+            )
+
+            if isinstance(self, SelfHostedLLMClient):
+                message = (
+                    "If you are using 'provider=self-hosted' to call a hosted vllm "
+                    "server make sure your config is correctly setup. You should have "
+                    "the following mandatory keys in your config: "
+                    "provider=self-hosted; "
+                    "model='<your-vllm-model-name>'; "
+                    "api_base='your-hosted-vllm-serv'."
+                    "In case you are getting OpenAI connection errors, such as missing "
+                    "API key, your configuration is incorrect."
+                )
+            raise ProviderClientAPIException(e, message)
 
     def _format_messages(self, messages: Union[List[str], str]) -> List[Dict[str, str]]:
         """Formats messages (or a single message) to OpenAI format."""
@@ -216,8 +223,7 @@ class _BaseLiteLLMClient:
 
     @staticmethod
     def _ensure_certificates() -> None:
-        """
-        Configures SSL certificates for LiteLLM. This method is invoked during
+        """Configures SSL certificates for LiteLLM. This method is invoked during
         client initialization.
 
         LiteLLM may utilize `openai` clients or other providers that require

rasa/shared/providers/llm/azure_openai_llm_client.py

@@ -17,6 +17,7 @@ from rasa.shared.constants import (
     OPENAI_API_KEY_ENV_VAR,
     AZURE_API_TYPE_ENV_VAR,
     AZURE_OPENAI_PROVIDER,
+    API_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
 from rasa.shared.providers._configs.azure_openai_client_config import (
@@ -29,8 +30,7 @@ structlogger = structlog.get_logger()
 
 
 class AzureOpenAILLMClient(_BaseLiteLLMClient):
-    """
-    A client for interfacing with Azure's OpenAI LLM deployments.
+    """A client for interfacing with Azure's OpenAI LLM deployments.
 
     Parameters:
         deployment (str): The deployment name.
@@ -80,11 +80,7 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
             or os.getenv(OPENAI_API_VERSION_ENV_VAR)
         )
 
-        # API key can be set through OPENAI_API_KEY too,
-        # because of the backward compatibility
-        self._api_key = os.getenv(AZURE_API_KEY_ENV_VAR) or os.getenv(
-            OPENAI_API_KEY_ENV_VAR
-        )
+        self._api_key_env_var = self._resolve_api_key_env_var()
 
         # Not used by LiteLLM, here for backward compatibility
         self._api_type = (
@@ -117,11 +113,6 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
                 "env_var": AZURE_API_VERSION_ENV_VAR,
                 "deprecated_var": OPENAI_API_VERSION_ENV_VAR,
             },
-            "API Key": {
-                "current_value": self._api_key,
-                "env_var": AZURE_API_KEY_ENV_VAR,
-                "deprecated_var": OPENAI_API_KEY_ENV_VAR,
-            },
         }
 
         deprecation_warning_message = (
@@ -154,10 +145,51 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
                     )
                 raise_deprecation_warning(message=message)
 
+    def _resolve_api_key_env_var(self) -> str:
+        """Resolves the environment variable to use for the API key.
+
+        Returns:
+            str: The env variable in dollar syntax format to use for the API key.
+        """
+        if API_KEY in self._extra_parameters:
+            # API key is set to an env var in the config itself
+            # in case the model is defined in the endpoints.yml
+            return self._extra_parameters[API_KEY]
+
+        if os.getenv(AZURE_API_KEY_ENV_VAR) is not None:
+            return "${AZURE_API_KEY}"
+
+        if os.getenv(OPENAI_API_KEY_ENV_VAR) is not None:
+            # API key can be set through OPENAI_API_KEY too,
+            # because of the backward compatibility
+            raise_deprecation_warning(
+                message=(
+                    f"Usage of '{OPENAI_API_KEY_ENV_VAR}' environment variable "
+                    "for setting the API key for Azure OpenAI "
+                    "client is deprecated and will be removed "
+                    f"in 4.0.0. Please use '{AZURE_API_KEY_ENV_VAR}' "
+                    "environment variable."
+                )
+            )
+            return "${OPENAI_API_KEY}"
+
+        structlogger.error(
+            "azure_openai_llm_client.api_key_not_set",
+            event_info=(
+                "API key not set, it is required for API calls. "
+                f"Set it either via the environment variable"
+                f"'{AZURE_API_KEY_ENV_VAR}' or directly"
+                f"via the config key '{API_KEY}'."
+            ),
+        )
+        raise ProviderClientValidationError(
+            f"Missing required environment variable/config key '{API_KEY}' for "
+            f"API calls."
+        )
+
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "AzureOpenAILLMClient":
-        """
-        Initializes the client from given configuration.
+        """Initializes the client from given configuration.
 
         Args:
             config (Dict[str, Any]): Configuration.
@@ -212,23 +244,17 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
 
     @property
     def model(self) -> Optional[str]:
-        """
-        Returns the name of the model deployed on Azure.
-        """
+        """Returns the name of the model deployed on Azure."""
         return self._model
 
     @property
     def api_base(self) -> Optional[str]:
-        """
-        Returns the API base URL for the Azure OpenAI llm client.
-        """
+        """Returns the API base URL for the Azure OpenAI llm client."""
         return self._api_base
 
     @property
     def api_version(self) -> Optional[str]:
-        """
-        Returns the API version for the Azure OpenAI llm client.
-        """
+        """Returns the API version for the Azure OpenAI llm client."""
         return self._api_version
 
     @property
@@ -261,7 +287,7 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
             {
                 "api_base": self.api_base,
                 "api_version": self.api_version,
-                "api_key": self._api_key,
+                "api_key": self._api_key_env_var,
             }
         )
         return fn_args
@@ -305,11 +331,6 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
                 "env_var": None,
                 "config_key": DEPLOYMENT_CONFIG_KEY,
             },
-            "API Key": {
-                "current_value": self._api_key,
-                "env_var": AZURE_API_KEY_ENV_VAR,
-                "config_key": None,
-            },
         }
 
         missing_settings = [

rasa/shared/providers/llm/litellm_router_llm_client.py

@@ -0,0 +1,127 @@
+from typing import Any, Dict, List, Union
+import logging
+import structlog
+
+from rasa.shared.exceptions import ProviderClientAPIException
+from rasa.shared.providers._configs.litellm_router_client_config import (
+    LiteLLMRouterClientConfig,
+)
+from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
+from rasa.shared.providers.llm.llm_response import LLMResponse
+from rasa.shared.providers.router._base_litellm_router_client import (
+    _BaseLiteLLMRouterClient,
+)
+from rasa.shared.utils.io import suppress_logs
+
+structlogger = structlog.get_logger()
+
+
+class LiteLLMRouterLLMClient(_BaseLiteLLMRouterClient, _BaseLiteLLMClient):
+    """A client for interfacing with LiteLLM Router LLM endpoints.
+
+    Parameters:
+        model_group_id (str): The model group ID.
+        model_configurations (List[Dict[str, Any]]): The list of model configurations.
+        router_settings (Dict[str, Any]): The router settings.
+        kwargs (Optional[Dict[str, Any]]): Additional configuration parameters.
+
+    Raises:
+        ProviderClientValidationError: If validation of the client setup fails.
+    """
+
+    def __init__(
+        self,
+        model_group_id: str,
+        model_configurations: List[Dict[str, Any]],
+        router_settings: Dict[str, Any],
+        **kwargs: Any,
+    ):
+        super().__init__(
+            model_group_id, model_configurations, router_settings, **kwargs
+        )
+
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> "LiteLLMRouterLLMClient":
+        """Instantiates a LiteLLM Router LLM client from a configuration dict.
+
+        Args:
+            config: (Dict[str, Any]) The configuration dictionary.
+
+        Returns:
+            LiteLLMRouterLLMClient: The instantiated LiteLLM Router LLM client.
+
+        Raises:
+            ValueError: If the configuration is invalid.
+        """
+        try:
+            client_config = LiteLLMRouterClientConfig.from_dict(config)
+        except (KeyError, ValueError) as e:
+            message = "Cannot instantiate a client from the passed configuration."
+            structlogger.error(
+                "litellm_router_llm_client.from_config.error",
+                message=message,
+                config=config,
+                original_error=e,
+            )
+            raise
+
+        return cls(
+            model_group_id=client_config.model_group_id,
+            model_configurations=client_config.litellm_model_list,
+            router_settings=client_config.router,
+            **client_config.extra_parameters,
+        )
+
+    @suppress_logs(log_level=logging.WARNING)
+    def completion(self, messages: Union[List[str], str]) -> LLMResponse:
+        """
+        Synchronously generate completions for given list of messages.
+
+        Args:
+            messages: List of messages or a single message to generate the
+                completion for.
+        Returns:
+            List of message completions.
+        Raises:
+            ProviderClientAPIException: If the API request fails.
+        """
+        try:
+            formatted_messages = self._format_messages(messages)
+            response = self.router_client.completion(
+                messages=formatted_messages, **self._completion_fn_args
+            )
+            return self._format_response(response)
+        except Exception as e:
+            raise ProviderClientAPIException(e)
+
+    @suppress_logs(log_level=logging.WARNING)
+    async def acompletion(self, messages: Union[List[str], str]) -> LLMResponse:
+        """
+        Asynchronously generate completions for given list of messages.
+
+        Args:
+            messages: List of messages or a single message to generate the
+                completion for.
+        Returns:
+            List of message completions.
+        Raises:
+            ProviderClientAPIException: If the API request fails.
+        """
+        try:
+            formatted_messages = self._format_messages(messages)
+            response = await self.router_client.acompletion(
+                messages=formatted_messages, **self._completion_fn_args
+            )
+            return self._format_response(response)
+        except Exception as e:
+            raise ProviderClientAPIException(e)
+
+    @property
+    def _completion_fn_args(self) -> Dict[str, Any]:
+        """Returns the completion arguments for invoking a call through
+        LiteLLM's completion functions.
+        """
+        return {
+            **self._litellm_extra_parameters,
+            "model": self.model_group_id,
+        }