rasa-pro 3.13.12__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/core/channels/voice_stream/voice_channel.py

@@ -1,5 +1,9 @@
+from __future__ import annotations
+
 import asyncio
 import copy
+import string
+import time
 from dataclasses import asdict, dataclass
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional, Tuple
 
@@ -8,6 +12,11 @@ from sanic import Websocket  # type: ignore
 from sanic.exceptions import ServerError, WebsocketClosed
 
 from rasa.core.channels import InputChannel, OutputChannel, UserMessage
+from rasa.core.channels.constants import (
+    USER_CONVERSATION_SESSION_END,
+    USER_CONVERSATION_SESSION_START,
+    USER_CONVERSATION_SILENCE_TIMEOUT,
+)
 from rasa.core.channels.voice_ready.utils import (
     CallParameters,
     validate_voice_license_scope,
@@ -29,6 +38,7 @@ from rasa.core.channels.voice_stream.call_state import (
 )
 from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
+from rasa.core.channels.voice_stream.tts.deepgram import DeepgramTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
 from rasa.core.channels.voice_stream.util import (
@@ -45,9 +55,13 @@ from rasa.utils.io import remove_emojis
 logger = structlog.get_logger(__name__)
 
 # define constants for the voice channel
-USER_CONVERSATION_SESSION_END = "/session_end"
-USER_CONVERSATION_SESSION_START = "/session_start"
-USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"
+DEFAULT_INTERRUPTION_MIN_WORDS = 3
+
+
+@dataclass
+class InterruptionConfig:
+    enabled: bool = False
+    min_words: int = DEFAULT_INTERRUPTION_MIN_WORDS
 
 
 @dataclass
@@ -120,6 +134,8 @@ def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
         return AzureTTS.from_config_dict(tts_config)
     elif name.lower() == "cartesia":
         return CartesiaTTS.from_config_dict(tts_config)
+    elif name.lower() == "deepgram":
+        return DeepgramTTS.from_config_dict(tts_config)
     else:
         mark_as_beta_feature("Custom TTS Engine")
         try:
@@ -189,7 +205,7 @@ class VoiceOutputChannel(OutputChannel):
     def update_silence_timeout(self) -> None:
         """Updates the silence timeout for the session."""
         if self.tracker_state:
-            call_state.silence_timeout = self.tracker_state["slots"][  # type: ignore[attr-defined]
+            call_state.silence_timeout = self.tracker_state["slots"][
                 SILENCE_TIMEOUT_SLOT
             ]
             logger.debug(
@@ -207,22 +223,67 @@ class VoiceOutputChannel(OutputChannel):
         """Uses the concise button output format for voice channels."""
         await self.send_text_with_buttons_concise(recipient_id, text, buttons, **kwargs)
 
+    def _track_rasa_processing_latency(self) -> None:
+        """Track and log Rasa processing completion latency."""
+        if call_state.rasa_processing_start_time:
+            call_state.rasa_processing_latency_ms = (
+                time.time() - call_state.rasa_processing_start_time
+            ) * 1000
+            logger.debug(
+                "voice_channel.rasa_processing_latency",
+                latency_ms=call_state.rasa_processing_latency_ms,
+            )
+
+    def _track_tts_first_byte_latency(self) -> None:
+        """Track and log TTS first byte latency."""
+        if call_state.tts_start_time:
+            call_state.tts_first_byte_latency_ms = (
+                time.time() - call_state.tts_start_time
+            ) * 1000
+            logger.debug(
+                "voice_channel.tts_first_byte_latency",
+                latency_ms=call_state.tts_first_byte_latency_ms,
+            )
+
+    def _track_tts_complete_latency(self) -> None:
+        """Track and log TTS completion latency."""
+        if call_state.tts_start_time:
+            call_state.tts_complete_latency_ms = (
+                time.time() - call_state.tts_start_time
+            ) * 1000
+            logger.debug(
+                "voice_channel.tts_complete_latency",
+                latency_ms=call_state.tts_complete_latency_ms,
+            )
+
     async def send_text_message(
         self, recipient_id: str, text: str, **kwargs: Any
     ) -> None:
         text = remove_emojis(text)
         self.update_silence_timeout()
+
+        # Track Rasa processing completion
+        self._track_rasa_processing_latency()
+
+        # Track TTS start time
+        call_state.tts_start_time = time.time()
+
         cached_audio_bytes = self.tts_cache.get(text)
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
         last_sent_offset = 0
+        first_audio_sent = False
         logger.debug("voice_channel.sending_audio", text=text)
 
         # Send start marker before first chunk
         try:
             await self.send_start_marker(recipient_id)
         except (WebsocketClosed, ServerError):
-            call_state.connection_failed = True  # type: ignore[attr-defined]
+            call_state.connection_failed = True
+
+        # Is the response interruptible?
+        allow_interruptions = kwargs.get("allow_interruptions", True)
+        call_state.channel_data["allow_interruptions"] = allow_interruptions
 
         if cached_audio_bytes:
             audio_stream = self.chunk_audio(cached_audio_bytes)
@@ -244,6 +305,11 @@ class VoiceOutputChannel(OutputChannel):
 
             if should_send:
                 try:
+                    # Track TTS first byte time
+                    if not first_audio_sent:
+                        self._track_tts_first_byte_latency()
+                        first_audio_sent = True
+
                     # Send only the new bytes since last send
                     new_bytes = RasaAudioBytes(collected_audio_bytes[last_sent_offset:])
                     await self.send_audio_bytes(recipient_id, new_bytes)
@@ -256,24 +322,31 @@ class VoiceOutputChannel(OutputChannel):
 
                 except (WebsocketClosed, ServerError):
                     # ignore sending error, and keep collecting and caching audio bytes
-                    call_state.connection_failed = True  # type: ignore[attr-defined]
+                    call_state.connection_failed = True
 
         # Send any remaining audio not yet sent
         remaining_bytes = len(collected_audio_bytes) - last_sent_offset
         if remaining_bytes > 0:
             try:
+                # Track TTS first byte time if not already tracked
+                if not first_audio_sent:
+                    self._track_tts_first_byte_latency()
+
                 new_bytes = RasaAudioBytes(collected_audio_bytes[last_sent_offset:])
                 await self.send_audio_bytes(recipient_id, new_bytes)
             except (WebsocketClosed, ServerError):
                 # ignore sending error
-                call_state.connection_failed = True  # type: ignore[attr-defined]
+                call_state.connection_failed = True
+
+        # Track TTS completion time
+        self._track_tts_complete_latency()
 
         try:
             await self.send_end_marker(recipient_id)
         except (WebsocketClosed, ServerError):
             # ignore sending error
             pass
-        call_state.latest_bot_audio_id = self.latest_message_id  # type: ignore[attr-defined]
+        call_state.latest_bot_audio_id = self.latest_message_id
 
         if not cached_audio_bytes:
             self.tts_cache.put(text, collected_audio_bytes)
@@ -298,7 +371,7 @@ class VoiceOutputChannel(OutputChannel):
         return
 
     async def hangup(self, recipient_id: str, **kwargs: Any) -> None:
-        call_state.should_hangup = True  # type: ignore[attr-defined]
+        call_state.should_hangup = True
 
 
 class VoiceInputChannel(InputChannel):
@@ -310,6 +383,7 @@ class VoiceInputChannel(InputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, Any]] = None,
     ):
         if self.requires_voice_license:
             validate_voice_license_scope()
@@ -318,12 +392,21 @@ class VoiceInputChannel(InputChannel):
         self.asr_config = asr_config
         self.tts_config = tts_config
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
+        if interruptions:
+            self.interruption_config = InterruptionConfig(**interruptions)
+        else:
+            self.interruption_config = InterruptionConfig()
+
+        if self.interruption_config.enabled:
+            mark_as_beta_feature(f"Interruption Handling in {self.name()}")
 
         logger.info(
             "voice_channel.initialized",
+            name=self.name(),
             server_url=self.server_url,
             asr_config=self.asr_config,
             tts_config=self.tts_config,
+            interruption_config=self.interruption_config,
         )
 
     def get_sender_id(self, call_parameters: CallParameters) -> str:
@@ -345,32 +428,32 @@ class VoiceInputChannel(InputChannel):
         if call_state.silence_timeout_watcher:
             logger.debug("voice_channel.cancelling_current_timeout_watcher_task")
             call_state.silence_timeout_watcher.cancel()
-            call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
+            call_state.silence_timeout_watcher = None
 
     @classmethod
-    def from_credentials(
-        cls,
-        credentials: Optional[Dict[str, Any]],
-    ) -> InputChannel:
+    def validate_basic_credentials(cls, credentials: Optional[Dict[str, Any]]) -> None:
+        """Validate the basic credentials for the voice channel."""
         if not credentials:
             cls.raise_missing_credentials_exception()
-
-        if not credentials.get("server_url"):
-            raise InvalidConfigException("No server_url provided in credentials.")
-        if not credentials.get("asr"):
+        if not isinstance(credentials, dict):
             raise InvalidConfigException(
-                "No ASR configuration provided in credentials."
+                "Credentials must be a dictionary for voice channel."
             )
-        if not credentials.get("tts"):
+
+        required_keys = {"server_url", "asr", "tts"}
+        credentials_keys = set(credentials.keys())
+        if not required_keys.issubset(credentials_keys):
+            missing_fields = required_keys - credentials_keys
             raise InvalidConfigException(
-                "No TTS configuration provided in credentials."
+                f"Missing required fields in credentials: {', '.join(missing_fields)} "
+                f"for channel {cls.name()}"
             )
 
-        return cls(
-            server_url=credentials["server_url"],
-            asr_config=credentials["asr"],
-            tts_config=credentials["tts"],
-        )
+    @classmethod
+    def from_credentials(
+        cls, credentials: Optional[Dict[str, Any]]
+    ) -> VoiceInputChannel:
+        raise NotImplementedError
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         raise NotImplementedError
@@ -405,6 +488,43 @@ class VoiceInputChannel(InputChannel):
         """Map a channel input message to a voice channel action."""
         raise NotImplementedError
 
+    def should_interrupt(self, e: ASREvent) -> bool:
+        """Determine if the current ASR event should interrupt playback.
+        Returns True if the bot response is interruptible
+        And if the user spoke more than 3 words.
+
+        Arguments:
+            e: The ASR event to evaluate.
+
+        Returns:
+            True if the event should interrupt playback, False otherwise.
+        """
+        # Are interruptions are enabled for the channel?
+        if not self.interruption_config.enabled:
+            return False
+
+        # Is the bot response interruptible?
+        if not call_state.channel_data.get("allow_interruptions", True):
+            return False
+
+        # Did the user speak more than 3 words?
+        min_words = self.interruption_config.min_words
+        if isinstance(e, UserIsSpeaking):
+            translator = str.maketrans("", "", string.punctuation)
+            words = e.text.translate(translator).split()
+            return len(words) >= min_words
+        return False
+
+    async def interrupt_playback(
+        self, ws: Websocket, call_parameters: CallParameters
+    ) -> None:
+        """Interrupt the current playback of audio.
+
+        This function is used for interruption handling.
+        As not all channels support flushing bot audio buffer,
+        if a channel does not implement it. It has no effect."""
+        pass
+
     async def run_audio_streaming(
         self,
         on_new_message: Callable[[UserMessage], Awaitable[Any]],
@@ -439,10 +559,8 @@ class VoiceInputChannel(InputChannel):
                 if was_bot_speaking_before and not is_bot_speaking_after:
                     logger.debug("voice_channel.bot_stopped_speaking")
                     self._cancel_silence_timeout_watcher()
-                    call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
-                        asyncio.create_task(
-                            self.monitor_silence_timeout(asr_event_queue)
-                        )
+                    call_state.silence_timeout_watcher = asyncio.create_task(
+                        self.monitor_silence_timeout(asr_event_queue)
                     )
                 if isinstance(channel_action, NewAudioAction):
                     await asr_engine.send_audio_chunks(channel_action.audio_bytes)
@@ -498,6 +616,16 @@ class VoiceInputChannel(InputChannel):
         """Create a matching voice output channel for this voice input channel."""
         raise NotImplementedError
 
+    def _track_asr_latency(self) -> None:
+        """Track and log ASR processing latency."""
+        if call_state.user_speech_start_time:
+            call_state.asr_latency_ms = (
+                time.time() - call_state.user_speech_start_time
+            ) * 1000
+            logger.debug(
+                "voice_channel.asr_latency", latency_ms=call_state.asr_latency_ms
+            )
+
     async def handle_asr_event(
         self,
         e: ASREvent,
@@ -511,7 +639,12 @@ class VoiceInputChannel(InputChannel):
             logger.debug(
                 "VoiceInputChannel.handle_asr_event.new_transcript", transcript=e.text
             )
-            call_state.is_user_speaking = False  # type: ignore[attr-defined]
+            call_state.is_user_speaking = False
+
+            # Track ASR and Rasa latencies
+            self._track_asr_latency()
+            call_state.rasa_processing_start_time = time.time()
+
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
                 text=e.text,
@@ -522,8 +655,13 @@ class VoiceInputChannel(InputChannel):
             )
             await on_new_message(message)
         elif isinstance(e, UserIsSpeaking):
+            # Track when user starts speaking for ASR latency calculation
+            if not call_state.is_user_speaking:
+                call_state.user_speech_start_time = time.time()
             self._cancel_silence_timeout_watcher()
-            call_state.is_user_speaking = True  # type: ignore[attr-defined]
+            call_state.is_user_speaking = True
+            if self.should_interrupt(e):
+                await self.interrupt_playback(voice_websocket, call_parameters)
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(

rasa/core/concurrent_lock_store.py

@@ -4,7 +4,11 @@ from collections import deque
 from typing import Deque, Optional, Text
 
 import structlog
+from pydantic import ValidationError
 
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
     DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
@@ -12,6 +16,12 @@ from rasa.core.lock_store import (
     LockError,
     LockStore,
 )
+from rasa.core.redis_connection_factory import (
+    DeploymentMode,
+    RedisConfig,
+    RedisConnectionFactory,
+)
+from rasa.shared.exceptions import RasaException
 from rasa.utils.endpoints import EndpointConfig
 
 DEFAULT_REDIS_DB = 1
@@ -74,9 +84,10 @@ class ConcurrentRedisLockStore(LockStore):
                 alphanumeric.
             socket_timeout - Timeout in seconds after which an exception will be raised
                 in case Redis doesn't respond within `socket_timeout` seconds.
+            deployment_mode - Redis deployment mode: standard, cluster, or sentinel.
+            endpoints - List of endpoints for cluster/sentinel mode in host:port format.
+            sentinel_service - Sentinel service name.
         """
-        import redis
-
         host = endpoint_config.kwargs.get("host", DEFAULT_HOSTNAME)
         port = endpoint_config.kwargs.get("port", DEFAULT_PORT)
         db = endpoint_config.kwargs.get("db", DEFAULT_REDIS_DB)
@@ -90,20 +101,34 @@ class ConcurrentRedisLockStore(LockStore):
         socket_timeout = endpoint_config.kwargs.get(
             "socket_timeout", DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
         )
-
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
+        deployment_mode = endpoint_config.kwargs.get(
+            "deployment_mode", DeploymentMode.STANDARD.value
         )
+        endpoints = endpoint_config.kwargs.get("endpoints", [])
+        sentinel_service = endpoint_config.kwargs.get("sentinel_service")
 
+        try:
+            redis_config = RedisConfig(
+                host=host,
+                port=port,
+                service_type=SupportedServiceType.LOCK_STORE,
+                db=db,
+                username=username,
+                password=password,
+                use_ssl=use_ssl,
+                ssl_certfile=ssl_certfile,
+                ssl_keyfile=ssl_keyfile,
+                ssl_ca_certs=ssl_ca_certs,
+                socket_timeout=socket_timeout,
+                deployment_mode=deployment_mode,
+                endpoints=endpoints,
+                sentinel_service=sentinel_service,
+            )
+            self.red = RedisConnectionFactory.create_connection(redis_config)
+        except ValidationError as e:
+            raise RasaException(f"Invalid Redis configuration: {e}")
+
+        self.deployment_mode = deployment_mode
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
             structlogger.debug(
@@ -129,6 +154,45 @@ class ConcurrentRedisLockStore(LockStore):
                 ),
             )
 
+    def _scan_cluster_keys(self, pattern: Text) -> list:
+        """Scan keys in cluster mode with proper cursor handling."""
+        keys = []
+        cursor = 0
+
+        while True:
+            try:
+                cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
+                keys.extend(batch_keys)
+
+                if isinstance(cursor, dict):
+                    # cursor is a dict mapping each node to its scan position. e.g
+                    # {'127.0.0.1:7000': 0, '127.0.0.1:7001': 5, '127.0.0.1:7002': 0}
+                    # A cursor value of 0 means that node has finished scanning
+                    # When all nodes show 0, the entire cluster scan is complete
+                    if all(v == 0 for v in cursor.values()):
+                        break
+                else:
+                    # if scan is complete
+                    if cursor == 0:
+                        break
+
+            except Exception as e:
+                structlogger.warning(
+                    "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
+                    event_info=f"SCAN interrupted in cluster mode: {e}. "
+                    f"Returning {len(keys)} keys found so far.",
+                )
+                break
+
+        return keys
+
+    def _get_keys_by_pattern(self, pattern: Text) -> list:
+        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
+        if self.deployment_mode == DeploymentMode.CLUSTER.value:
+            return self._scan_cluster_keys(pattern)
+        else:
+            return self.red.keys(pattern)
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:
@@ -157,11 +221,14 @@ class ConcurrentRedisLockStore(LockStore):
         tickets: Deque[Ticket] = deque()
 
         pattern = self.key_prefix + conversation_id + ":" + "[0-9]*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         for key in redis_keys:
             serialised_ticket = self.red.get(key)
             if serialised_ticket:
+                # Handle bytes to string conversion for JSON parsing
+                if isinstance(serialised_ticket, bytes):
+                    serialised_ticket = serialised_ticket.decode("utf-8")
                 ticket = Ticket.from_dict(json.loads(serialised_ticket))
                 tickets.appendleft(ticket)
 
@@ -172,7 +239,7 @@ class ConcurrentRedisLockStore(LockStore):
     def delete_lock(self, conversation_id: Text) -> None:
         """Deletes lock for conversation ID."""
         pattern = self.key_prefix + conversation_id + ":*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         if not redis_keys:
             structlogger.debug(

rasa/core/{available_endpoints.py → config/available_endpoints.py}

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
 import dataclasses
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from rasa.core.constants import MCP_SERVERS_KEY
+from rasa.shared.agents.auth.utils import validate_secrets_in_params
 from rasa.shared.core.constants import (
     GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE,
     GLOBAL_SILENCE_TIMEOUT_KEY,
@@ -57,13 +61,47 @@ class InteractionHandlingConfig:
         )
 
 
+class MCPServerConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    name: str = Field(..., description="The name of the MCP server.")
+    url: str = Field(..., description="The URL of the MCP server.")
+    type: str = Field(..., description="The type of the MCP server.")
+    additional_params: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Additional parameters for the MCP server."
+    )
+
+    @model_validator(mode="after")
+    def validate_type(self) -> MCPServerConfig:
+        # validate that type is "http"
+        if self.type not in ["http", "https"]:
+            raise ValueError(f"Invalid MCP server type: {self.type}")
+        # validate that name and url are not empty
+        if not self.name or not self.url:
+            raise ValueError("Name and URL cannot be empty")
+        # validate secrets in additional_params
+        if self.additional_params:
+            validate_secrets_in_params(
+                self.additional_params, f"MCP server - '{self.name}'"
+            )
+        return self
+
+    @model_validator(mode="before")
+    def collect_additional_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        base_fields = {"name", "url", "type"}
+        extras = {k: v for k, v in values.items() if k not in base_fields}
+        if extras:
+            values["additional_params"] = extras
+            # remove them from top level so Pydantic doesn’t complain
+            for k in extras:
+                values.pop(k)
+        return values
+
+
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
-    _instance = None
-
     @classmethod
-    def read_endpoints(cls, endpoint_file: str) -> AvailableEndpoints:
+    def read_endpoints(cls, endpoint_file: Path) -> AvailableEndpoints:
         """Read the different endpoints from a yaml file."""
         nlg = read_endpoint_config(endpoint_file, endpoint_type="nlg")
         nlu = read_endpoint_config(endpoint_file, endpoint_type="nlu")
@@ -75,6 +113,14 @@ class AvailableEndpoints:
         lock_store = read_endpoint_config(endpoint_file, endpoint_type="lock_store")
         event_broker = read_endpoint_config(endpoint_file, endpoint_type="event_broker")
         vector_store = read_endpoint_config(endpoint_file, endpoint_type="vector_store")
+        raw_mcp_servers = read_property_config_from_endpoints_file(
+            endpoint_file, property_name=MCP_SERVERS_KEY
+        )
+        mcp_servers = (
+            [MCPServerConfig(**server) for server in raw_mcp_servers]
+            if raw_mcp_servers
+            else None
+        )
         model_groups = read_property_config_from_endpoints_file(
             endpoint_file, property_name="model_groups"
         )
@@ -89,6 +135,7 @@ class AvailableEndpoints:
         )
 
         return cls(
+            endpoint_file,
             nlg,
             nlu,
             action,
@@ -97,6 +144,7 @@ class AvailableEndpoints:
             lock_store,
             event_broker,
             vector_store,
+            mcp_servers,
             model_groups,
             privacy,
             interaction_handling,
@@ -104,6 +152,7 @@ class AvailableEndpoints:
 
     def __init__(
         self,
+        config_file_path: Optional[Path] = None,
         nlg: Optional[EndpointConfig] = None,
         nlu: Optional[EndpointConfig] = None,
         action: Optional[EndpointConfig] = None,
@@ -112,6 +161,7 @@ class AvailableEndpoints:
         lock_store: Optional[EndpointConfig] = None,
         event_broker: Optional[EndpointConfig] = None,
         vector_store: Optional[EndpointConfig] = None,
+        mcp_servers: Optional[List[MCPServerConfig]] = None,
         model_groups: Optional[List[Dict[str, Any]]] = None,
         privacy: Optional[Dict[str, Any]] = None,
         interaction_handling: InteractionHandlingConfig = InteractionHandlingConfig(
@@ -119,6 +169,7 @@ class AvailableEndpoints:
         ),
     ) -> None:
         """Create an `AvailableEndpoints` object."""
+        self.config_file_path = config_file_path
         self.model = model
         self.action = action
         self.nlu = nlu
@@ -127,20 +178,7 @@ class AvailableEndpoints:
         self.lock_store = lock_store
         self.event_broker = event_broker
         self.vector_store = vector_store
+        self.mcp_servers = mcp_servers
         self.model_groups = model_groups
         self.privacy = privacy
         self.interaction_handling = interaction_handling
-
-    @classmethod
-    def get_instance(
-        cls, endpoint_file: Optional[str] = DEFAULT_ENDPOINTS_PATH
-    ) -> AvailableEndpoints:
-        """Get the singleton instance of AvailableEndpoints."""
-        # Ensure that the instance is initialized only once.
-        if cls._instance is None:
-            cls._instance = cls.read_endpoints(endpoint_file)
-        return cls._instance
-
-    @classmethod
-    def reset_instance(cls) -> None:
-        cls._instance = None