rasa-pro 3.10.15__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/shared/providers/llm/rasa_llm_client.py

@@ -0,0 +1,112 @@
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    RASA_PROVIDER,
+    OPENAI_PROVIDER,
+)
+from rasa.shared.providers._configs.rasa_llm_client_config import (
+    RasaLLMClientConfig,
+)
+from rasa.utils.licensing import retrieve_license_from_env
+from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
+
+
+structlogger = structlog.get_logger()
+
+
+class RasaLLMClient(_BaseLiteLLMClient):
+    """A client for interfacing with a Rasa-Hosted LLM endpoint that uses
+
+    Parameters:
+        model (str): The model or deployment name.
+        api_base (str): The base URL of the API endpoint.
+        kwargs: Any: Additional configuration parameters that can include, but
+            are not limited to model parameters and lite-llm specific
+            parameters. These parameters will be passed to the
+            completion/acompletion calls. To see what it can include, visit:
+
+    Raises:
+        ProviderClientValidationError: If validation of the client setup fails.
+        ProviderClientAPIException: If the API request fails.
+    """
+
+    def __init__(
+        self,
+        model: str,
+        api_base: str,
+        **kwargs: Any,
+    ):
+        super().__init__()  # type: ignore
+        self._model = model
+        self._api_base = api_base
+        self._use_chat_completions_endpoint = True
+        self._extra_parameters = kwargs or {}
+
+    @property
+    def model(self) -> str:
+        return self._model
+
+    @property
+    def api_base(self) -> Optional[str]:
+        """
+        Returns the base API URL for the openai llm client.
+        """
+        return self._api_base
+
+    @property
+    def provider(self) -> str:
+        """
+        Returns the provider name for the self hosted llm client.
+
+        Returns:
+            String representing the provider name.
+        """
+        return RASA_PROVIDER
+
+    @property
+    def _litellm_model_name(self) -> str:
+        return f"{OPENAI_PROVIDER}/{self._model}"
+
+    @property
+    def _litellm_extra_parameters(self) -> Dict[str, Any]:
+        return self._extra_parameters
+
+    @property
+    def config(self) -> dict:
+        return RasaLLMClientConfig(
+            model=self._model,
+            api_base=self._api_base,
+            extra_parameters=self._extra_parameters,
+        ).to_dict()
+
+    @property
+    def _completion_fn_args(self) -> Dict[str, Any]:
+        """Returns the completion arguments for invoking a call through
+        LiteLLM's completion functions.
+        """
+        fn_args = super()._completion_fn_args
+        fn_args.update(
+            {"api_base": self.api_base, "api_key": retrieve_license_from_env()}
+        )
+        return fn_args
+
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> "RasaLLMClient":
+        try:
+            client_config = RasaLLMClientConfig.from_dict(config)
+        except ValueError as e:
+            message = "Cannot instantiate a client from the passed configuration."
+            structlogger.error(
+                "rasa_llm_client.from_config.error",
+                message=message,
+                config=config,
+                original_error=e,
+            )
+            raise
+        return cls(
+            model=client_config.model,
+            api_base=client_config.api_base,
+            **client_config.extra_parameters,
+        )

rasa/shared/providers/llm/self_hosted_llm_client.py

@@ -10,13 +10,14 @@ import structlog
 from rasa.shared.constants import (
     SELF_HOSTED_VLLM_PREFIX,
     SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
+    API_KEY,
 )
 from rasa.shared.providers._configs.self_hosted_llm_client_config import (
     SelfHostedLLMClientConfig,
 )
 from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
-from rasa.shared.providers.llm.llm_response import LLMResponse, LLMUsage
+from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.shared.utils.io import suppress_logs
 
 structlogger = structlog.get_logger()
@@ -61,7 +62,8 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         self._api_version = api_version
         self._use_chat_completions_endpoint = use_chat_completions_endpoint
         self._extra_parameters = kwargs or {}
-        self._apply_dummy_api_key_if_missing()
+        if self._extra_parameters.get(API_KEY) is None:
+            self._apply_dummy_api_key_if_missing()
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "SelfHostedLLMClient":
@@ -160,7 +162,7 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         """Returns the value of LiteLLM's model parameter to be used in
         completion/acompletion in LiteLLM format:
 
-        <openai>/<model or deployment name>
+        <hosted_vllm>/<model or deployment name>
         """
         if self.model and f"{SELF_HOSTED_VLLM_PREFIX}/" not in self.model:
             return f"{SELF_HOSTED_VLLM_PREFIX}/{self.model}"
@@ -259,32 +261,6 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
             return super().completion(messages)
         return self._text_completion(messages)
 
-    def _format_text_completion_response(self, response: Any) -> LLMResponse:
-        """Parses the LiteLLM text completion response to Rasa format."""
-        formatted_response = LLMResponse(
-            id=response.id,
-            created=response.created,
-            choices=[choice.text for choice in response.choices],
-            model=response.model,
-        )
-        if (usage := response.usage) is not None:
-            prompt_tokens = (
-                num_tokens
-                if isinstance(num_tokens := usage.prompt_tokens, (int, float))
-                else 0
-            )
-            completion_tokens = (
-                num_tokens
-                if isinstance(num_tokens := usage.completion_tokens, (int, float))
-                else 0
-            )
-            formatted_response.usage = LLMUsage(prompt_tokens, completion_tokens)
-        structlogger.debug(
-            "base_litellm_client.formatted_response",
-            formatted_response=formatted_response.to_dict(),
-        )
-        return formatted_response
-
     @staticmethod
     def _apply_dummy_api_key_if_missing() -> None:
         if not os.getenv(SELF_HOSTED_VLLM_API_KEY_ENV_VAR):

rasa/shared/providers/mappings.py

@@ -5,6 +5,8 @@ from rasa.shared.constants import (
     HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
     OPENAI_PROVIDER,
     SELF_HOSTED_PROVIDER,
+    RASA_PROVIDER,
+    SELF_HOSTED_VLLM_PREFIX,
 )
 from rasa.shared.providers.embedding.azure_openai_embedding_client import (
     AzureOpenAIEmbeddingClient,
@@ -24,6 +26,7 @@ from rasa.shared.providers.llm.default_litellm_llm_client import DefaultLiteLLMC
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.providers.llm.openai_llm_client import OpenAILLMClient
 from rasa.shared.providers.llm.self_hosted_llm_client import SelfHostedLLMClient
+from rasa.shared.providers.llm.rasa_llm_client import RasaLLMClient
 from rasa.shared.providers._configs.azure_openai_client_config import (
     AzureOpenAIClientConfig,
 )
@@ -37,12 +40,15 @@ from rasa.shared.providers._configs.openai_client_config import OpenAIClientConf
 from rasa.shared.providers._configs.self_hosted_llm_client_config import (
     SelfHostedLLMClientConfig,
 )
+from rasa.shared.providers._configs.rasa_llm_client_config import RasaLLMClientConfig
+
 from rasa.shared.providers._configs.client_config import ClientConfig
 
 _provider_to_llm_client_mapping: Dict[str, Type[LLMClient]] = {
     OPENAI_PROVIDER: OpenAILLMClient,
     AZURE_OPENAI_PROVIDER: AzureOpenAILLMClient,
     SELF_HOSTED_PROVIDER: SelfHostedLLMClient,
+    RASA_PROVIDER: RasaLLMClient,
 }
 
 _provider_to_embedding_client_mapping: Dict[str, Type[EmbeddingClient]] = {
@@ -56,6 +62,15 @@ _provider_to_client_config_class_mapping: Dict[str, Type] = {
     AZURE_OPENAI_PROVIDER: AzureOpenAIClientConfig,
     HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER: HuggingFaceLocalEmbeddingClientConfig,
     SELF_HOSTED_PROVIDER: SelfHostedLLMClientConfig,
+    RASA_PROVIDER: RasaLLMClientConfig,
+}
+
+
+_provider_to_prefix_mapping: Dict[str, str] = {
+    # Specify the provider name as the key and its corresponding prefix as the value
+    # for providers where the prefix differs from the provider name.
+    SELF_HOSTED_PROVIDER: SELF_HOSTED_VLLM_PREFIX,
+    RASA_PROVIDER: OPENAI_PROVIDER,
 }
 
 
@@ -73,3 +88,7 @@ def get_client_config_class_from_provider(provider: str) -> Type[ClientConfig]:
     return _provider_to_client_config_class_mapping.get(
         provider, DefaultLiteLLMClientConfig
     )
+
+
+def get_prefix_from_provider(provider: str) -> str:
+    return _provider_to_prefix_mapping.get(provider, provider)

rasa/shared/providers/router/_base_litellm_router_client.py

@@ -0,0 +1,183 @@
+from typing import Any, Dict, List
+import os
+import structlog
+
+from litellm import Router
+
+from rasa.shared.constants import (
+    MODEL_LIST_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    ROUTER_CONFIG_KEY,
+    SELF_HOSTED_VLLM_PREFIX,
+    SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
+    LITELLM_PARAMS_KEY,
+    API_KEY,
+    MODEL_CONFIG_KEY,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
+)
+from rasa.shared.exceptions import ProviderClientValidationError
+from rasa.shared.providers._configs.litellm_router_client_config import (
+    LiteLLMRouterClientConfig,
+)
+from rasa.shared.utils.io import resolve_environment_variables
+
+structlogger = structlog.get_logger()
+
+
+class _BaseLiteLLMRouterClient:
+    """An abstract base class for LiteLLM Router clients.
+
+    This class defines the interface and common functionality for all the router clients
+    based on LiteLLM.
+
+    The class is made private to prevent it from being part of the public-facing
+    interface, as it serves as an internal base class for specific implementations of
+    router clients that are based on LiteLLM router implementation.
+
+    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],
+        use_chat_completions_endpoint: bool = True,
+        **kwargs: Any,
+    ):
+        self._model_group_id = model_group_id
+        self._model_configurations = model_configurations
+        self._router_settings = router_settings
+        self._use_chat_completions_endpoint = use_chat_completions_endpoint
+        self._extra_parameters = kwargs or {}
+        self.additional_client_setup()
+        try:
+            resolved_model_configurations = (
+                self._resolve_env_vars_in_model_configurations()
+            )
+            self._router_client = Router(
+                model_list=resolved_model_configurations, **router_settings
+            )
+        except Exception as e:
+            event_info = "Cannot instantiate a router client."
+            structlogger.error(
+                "_base_litellm_router_client.init.error",
+                event_info=event_info,
+                model_group_id=model_group_id,
+                models=model_configurations,
+                router=router_settings,
+                original_error=e,
+            )
+            raise ProviderClientValidationError(f"{event_info} Original error: {e}")
+
+    def additional_client_setup(self) -> None:
+        """Additional setup for the LiteLLM Router client."""
+        # If the model configuration is self-hosted VLLM, set a dummy API key if not
+        # provided. A bug in the LiteLLM library requires an API key to be set even if
+        # it is not required.
+        for model_configuration in self.model_configurations:
+            if (
+                f"{SELF_HOSTED_VLLM_PREFIX}/"
+                in model_configuration[LITELLM_PARAMS_KEY][MODEL_CONFIG_KEY]
+                and API_KEY not in model_configuration[LITELLM_PARAMS_KEY]
+                and not os.getenv(SELF_HOSTED_VLLM_API_KEY_ENV_VAR)
+            ):
+                os.environ[SELF_HOSTED_VLLM_API_KEY_ENV_VAR] = "dummy api key"
+                return
+
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> "_BaseLiteLLMRouterClient":
+        """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.litellm_router_settings,
+            use_chat_completions_endpoint=client_config.use_chat_completions_endpoint,
+            **client_config.extra_parameters,
+        )
+
+    @property
+    def model_group_id(self) -> str:
+        """Returns the model group ID for the LiteLLM Router client."""
+        return self._model_group_id
+
+    @property
+    def model_configurations(self) -> List[Dict[str, Any]]:
+        """Returns the model configurations for the LiteLLM Router client."""
+        return self._model_configurations
+
+    @property
+    def router_settings(self) -> Dict[str, Any]:
+        """Returns the router settings for the LiteLLM Router client."""
+        return self._router_settings
+
+    @property
+    def router_client(self) -> Router:
+        """Returns the instantiated LiteLLM Router client."""
+        return self._router_client
+
+    @property
+    def use_chat_completions_endpoint(self) -> bool:
+        """Returns whether to use the chat completions endpoint."""
+        return self._use_chat_completions_endpoint
+
+    @property
+    def _litellm_extra_parameters(self) -> Dict[str, Any]:
+        """
+        Returns the extra parameters for the LiteLLM Router client.
+
+        Returns:
+            Dictionary containing the model parameters.
+        """
+        return self._extra_parameters
+
+    @property
+    def config(self) -> Dict:
+        """Returns the configuration for the LiteLLM Router client in LiteLLM format."""
+        return {
+            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
+            MODEL_LIST_KEY: self.model_configurations,
+            ROUTER_CONFIG_KEY: self.router_settings,
+            USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY: (
+                self.use_chat_completions_endpoint
+            ),
+            **self._litellm_extra_parameters,
+        }
+
+    def _resolve_env_vars_in_model_configurations(self) -> List:
+        model_configuration_with_resolved_keys = []
+        for model_configuration in self.model_configurations:
+            resolved_model_configuration = resolve_environment_variables(
+                model_configuration
+            )
+            model_configuration_with_resolved_keys.append(resolved_model_configuration)
+        return model_configuration_with_resolved_keys

rasa/shared/providers/router/router_client.py

@@ -0,0 +1,73 @@
+from typing import Any, Dict, List, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class RouterClient(Protocol):
+    """
+    Protocol for a Router client that specifies the interface for interacting
+    with the API.
+    """
+
+    @classmethod
+    def from_config(cls, config: dict) -> "RouterClient":
+        """
+        Initializes the router client with the given configuration.
+
+        This class method should be implemented to parse the given
+        configuration and create an instance of an router client.
+        """
+        ...
+
+    @property
+    def config(self) -> Dict:
+        """
+        Returns the configuration for that the router client is initialized with.
+
+        This property should be implemented to return a dictionary containing
+        the client configuration settings for the router client.
+        """
+        ...
+
+    @property
+    def router_settings(self) -> Dict[str, Any]:
+        """
+        Returns the router settings for the Router client.
+
+        This property should be implemented to return a dictionary containing
+        the router settings for the router client.
+        """
+        ...
+
+    @property
+    def model_group_id(self) -> str:
+        """
+        Returns the model group ID for the Router client.
+
+        This property should be implemented to return the model group ID
+        for the router client.
+        """
+        ...
+
+    @property
+    def model_configurations(self) -> List[Dict[str, Any]]:
+        """
+        Returns the list of model configurations for the Router client.
+
+        This property should be implemented to return the list of model configurations
+        for the router client as a list of dictionaries.
+
+        Each dictionary should contain the model configuration.
+        Ideally, the `ModelGroupConfig` should parse the model configurations
+        and generate this list of dictionaries.
+        """
+        ...
+
+    @property
+    def router_client(self) -> object:
+        """
+        Returns the instantiated Router client.
+
+        This property should be implemented to return the instantiated
+        Router client.
+        """
+        ...

rasa/shared/utils/common.py

@@ -3,14 +3,16 @@ import functools
 import importlib
 import inspect
 import logging
+import os
 import pkgutil
 import sys
 from types import ModuleType
-from typing import Text, Dict, Optional, Any, List, Callable, Collection, Type
+from typing import Sequence, Text, Dict, Optional, Any, List, Callable, Collection, Type
 
 import rasa.shared.utils.io
+from rasa.exceptions import MissingDependencyException
 from rasa.shared.constants import DOCS_URL_MIGRATION_GUIDE
-from rasa.shared.exceptions import RasaException
+from rasa.shared.exceptions import ProviderClientValidationError, RasaException
 
 logger = logging.getLogger(__name__)
 
@@ -86,31 +88,11 @@ def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
     return sorted(dicts, key=lambda d: next(iter(d.keys())))
 
 
-def lazy_property(function: Callable) -> Any:
-    """Allows to avoid recomputing a property over and over.
-
-    The result gets stored in a local var. Computation of the property
-    will happen once, on the first call of the property. All
-    succeeding calls will use the value stored in the private property.
-    """
-    attr_name = "_lazy_" + function.__name__
-
-    def _lazyprop(self: Any) -> Any:
-        if not hasattr(self, attr_name):
-            setattr(self, attr_name, function(self))
-        return getattr(self, attr_name)
-
-    return property(_lazyprop)
-
-
 def cached_method(f: Callable[..., Any]) -> Callable[..., Any]:
     """Caches method calls based on the call's `args` and `kwargs`.
-
     Works for `async` and `sync` methods. Don't apply this to functions.
-
     Args:
         f: The decorated method whose return value should be cached.
-
     Returns:
         The return value which the method gives for the first call with the given
         arguments.
@@ -176,8 +158,9 @@ def transform_collection_to_sentence(collection: Collection[Text]) -> Text:
 def minimal_kwargs(
     kwargs: Dict[Text, Any], func: Callable, excluded_keys: Optional[List] = None
 ) -> Dict[Text, Any]:
-    """Returns only the kwargs which are required by a function. Keys, contained in
-    the exception list, are not included.
+    """Returns only the kwargs which are required by a function.
+
+    Keys, contained in the exception list, are not included.
 
     Args:
         kwargs: All available kwargs.
@@ -209,6 +192,14 @@ def mark_as_experimental_feature(feature_name: Text) -> None:
     )
 
 
+def mark_as_beta_feature(feature_name: Text) -> None:
+    """Warns users that they are using a beta feature."""
+    logger.warning(
+        f"🔬 Beta Feature: {feature_name} is in beta. It may have unexpected "
+        "behaviour and might be changed in the future."
+    )
+
+
 def arguments_of(func: Callable) -> List[Text]:
     """Return the parameters of the function `func` as a list of names."""
     import inspect
@@ -306,3 +297,28 @@ def warn_and_exit_if_module_path_contains_rasa_plus(
             docs=DOCS_URL_MIGRATION_GUIDE,
         )
         sys.exit(1)
+
+
+def validate_environment(
+    required_env_vars: Sequence[str],
+    required_packages: Sequence[str],
+    component_name: str,
+) -> None:
+    """Make sure all needed requirements for a component are met.
+    Args:
+         required_env_vars: List of environment variables that should be set
+         required_packages: List of packages that should be installed
+         component_name: component name that needs the requirements
+    """
+    for e in required_env_vars:
+        if not os.environ.get(e):
+            raise ProviderClientValidationError(
+                f"Missing environment variable for {component_name}: {e}"
+            )
+    for p in required_packages:
+        try:
+            importlib.import_module(p)
+        except ImportError:
+            raise MissingDependencyException(
+                f"Missing package for {component_name}: {p}"
+            )

rasa/shared/utils/health_check/embeddings_health_check_mixin.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any
+
+
+class EmbeddingsHealthCheckMixin:
+    """Mixin class that provides methods for performing embeddings health checks during
+    training and inference within components.
+
+    This mixin offers static methods that wrap the following health check functions:
+    - `perform_embeddings_health_check`
+    """
+
+    @staticmethod
+    def perform_embeddings_health_check(
+        custom_embeddings_config: Optional[Dict[str, Any]],
+        default_embeddings_config: Dict[str, Any],
+        log_source_method: str,
+        log_source_component: str,
+    ) -> None:
+        """Wraps the `perform_embeddings_health_check` function to enable
+        tracing and instrumentation.
+        """
+        from rasa.shared.utils.health_check.health_check import (
+            perform_embeddings_health_check,
+        )
+
+        perform_embeddings_health_check(
+            custom_embeddings_config,
+            default_embeddings_config,
+            log_source_method,
+            log_source_component,
+        )