rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc2__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

@@ -160,7 +160,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}"

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,149 @@
+from typing import Any, Dict, List
+import structlog
+
+from litellm import Router
+
+from rasa.shared.constants import (
+    MODEL_LIST_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    ROUTER_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],
+        **kwargs: Any,
+    ):
+        self._model_group_id = model_group_id
+        self._model_configurations = model_configurations
+        self._router_settings = router_settings
+        self._extra_parameters = kwargs or {}
+        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}")
+
+    @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.router,
+            **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 _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,
+            **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

@@ -190,6 +190,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

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,
+        )