rasa-pro 3.12.5__py3-none-any.whl → 3.12.6.dev2__py3-none-any.whl

rasa/__init__.py

@@ -5,5 +5,11 @@ from rasa import version
 # define the version before the other imports since these need it
 __version__ = version.__version__
 
+from litellm.integrations.langfuse.langfuse import LangFuseLogger
+
+from rasa.monkey_patches import litellm_langfuse_logger_init_fixed
+
+# Monkey-patch the init method as early as possible before the class is used
+LangFuseLogger.__init__ = litellm_langfuse_logger_init_fixed  # type: ignore
 
 logging.getLogger(__name__).addHandler(logging.NullHandler())

rasa/core/channels/voice_ready/audiocodes.py

@@ -1,5 +1,6 @@
 import asyncio
 import copy
+import hmac
 import json
 import uuid
 from collections import defaultdict
@@ -245,8 +246,13 @@ class AudiocodesInput(InputChannel):
 
     def _check_token(self, token: Optional[Text]) -> None:
         if not token:
+            structlogger.error("audiocodes.token_not_provided")
             raise HttpUnauthorized("Authentication token required.")
 
+        if not hmac.compare_digest(str(token), str(self.token)):
+            structlogger.error("audiocodes.invalid_token", invalid_token=token)
+            raise HttpUnauthorized("Invalid authentication token.")
+
     def _get_conversation(
         self, token: Optional[Text], conversation_id: Text
     ) -> Conversation:

rasa/core/channels/voice_stream/audiocodes.py

@@ -1,5 +1,6 @@
 import asyncio
 import base64
+import hmac
 import json
 from typing import Any, Awaitable, Callable, Dict, Optional, Text
 
@@ -103,6 +104,7 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
 
     def __init__(
         self,
+        token: Optional[Text],
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
@@ -110,6 +112,22 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
     ):
         mark_as_beta_feature("Audiocodes (audiocodes_stream) Channel")
         super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        self.token = token
+
+    @classmethod
+    def from_credentials(
+        cls, credentials: Optional[Dict[str, Any]]
+    ) -> VoiceInputChannel:
+        if not credentials:
+            raise ValueError("No credentials given for Audiocodes voice channel.")
+
+        return cls(
+            token=credentials.get("token"),
+            server_url=credentials["server_url"],
+            asr_config=credentials["asr"],
+            tts_config=credentials["tts"],
+            monitor_silence=credentials.get("monitor_silence", False),
+        )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         return RasaAudioBytes(base64.b64decode(input_bytes))
@@ -135,6 +153,13 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
                     )
                     if activity["name"] == "start":
                         return map_call_params(activity["parameters"])
+            elif data["type"] == "connection.validate":
+                # not part of call flow; only sent when integration is created
+                logger.info(
+                    "audiocodes_stream.collect_call_parameters.connection.validate",
+                    event_info="received request to validate integration",
+                )
+                self._send_validated(channel_websocket, data)
             else:
                 logger.warning("audiocodes_stream.unknown_message", data=data)
         return None
@@ -158,7 +183,7 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
                 elif activity["name"] == "playFinished":
                     logger.debug("audiocodes_stream.playFinished", data=activity)
                     if call_state.should_hangup:
-                        logger.info("audiocodes.hangup")
+                        logger.info("audiocodes_stream.hangup")
                         self._send_hangup(ws, data)
                         # the conversation should continue until
                         # we receive a end message from audiocodes
@@ -180,11 +205,10 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
         elif data["type"] == "session.end":
             logger.debug("audiocodes_stream.end", data=data)
             return EndConversationAction()
-        elif data["type"] == "connection.validate":
-            # not part of call flow; only sent when integration is created
-            self._send_validated(ws, data)
         else:
-            logger.warning("audiocodes_stream.unknown_message", data=data)
+            logger.warning(
+                "audiocodes_stream.map_input_message.unknown_message", data=data
+            )
 
         return ContinueConversationAction()
 
@@ -254,6 +278,17 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
+    def _is_token_valid(self, token: Optional[Text]) -> bool:
+        # If no token is set, always return True
+        if not self.token:
+            return True
+
+        # Token is required, but not provided
+        if not token:
+            return False
+
+        return hmac.compare_digest(str(self.token), str(token))
+
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
@@ -266,17 +301,26 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
 
         @blueprint.websocket("/websocket")  # type: ignore
         async def receive(request: Request, ws: Websocket) -> None:
-            # TODO: validate API key header
-            logger.info("audiocodes.receive", message="Starting audio streaming")
+            if not self._is_token_valid(request.token):
+                logger.error(
+                    "audiocodes_stream.invalid_token",
+                    invalid_token=request.token,
+                )
+                await ws.close(code=1008, reason="Invalid token")
+                return
+
+            logger.info(
+                "audiocodes_stream.receive", event_info="Started websocket connection"
+            )
             try:
                 await self.run_audio_streaming(on_new_message, ws)
             except Exception as e:
                 logger.exception(
-                    "audiocodes.receive",
+                    "audiocodes_stream.receive",
                     message="Error during audio streaming",
                     error=e,
                 )
-                # return 500 error
+                await ws.close(code=1011, reason="Error during audio streaming")
                 raise
 
         return blueprint

rasa/core/channels/voice_stream/genesys.py

@@ -1,4 +1,7 @@
 import asyncio
+import base64
+import hashlib
+import hmac
 import json
 from typing import Any, Awaitable, Callable, Dict, Optional, Text
 
@@ -45,6 +48,7 @@ in the documentation but observed in their example app
 https://github.com/GenesysCloudBlueprints/audioconnector-server-reference-implementation
 """
 MAXIMUM_BINARY_MESSAGE_SIZE = 64000  # 64KB
+HEADER_API_KEY = "X-Api-Key"
 logger = structlog.get_logger(__name__)
 
 
@@ -86,8 +90,31 @@ class GenesysInputChannel(VoiceInputChannel):
     def name(cls) -> str:
         return "genesys"
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
+    def __init__(
+        self, api_key: Text, client_secret: Optional[Text], *args: Any, **kwargs: Any
+    ) -> None:
         super().__init__(*args, **kwargs)
+        self.api_key = api_key
+        self.client_secret = client_secret
+
+    @classmethod
+    def from_credentials(
+        cls, credentials: Optional[Dict[str, Any]]
+    ) -> VoiceInputChannel:
+        if not credentials:
+            raise ValueError("No credentials given for Genesys voice channel.")
+
+        if not credentials.get("api_key"):
+            raise ValueError("No API key given for Genesys voice channel (api_key).")
+
+        return cls(
+            api_key=credentials["api_key"],
+            client_secret=credentials.get("client_secret"),
+            server_url=credentials["server_url"],
+            asr_config=credentials["asr"],
+            tts_config=credentials["tts"],
+            monitor_silence=credentials.get("monitor_silence", False),
+        )
 
     def _ensure_channel_data_initialized(self) -> None:
         """Initialize Genesys-specific channel data if not already present.
@@ -273,6 +300,93 @@ class GenesysInputChannel(VoiceInputChannel):
         logger.debug("genesys.disconnect", message=message)
         _schedule_ws_task(ws.send(json.dumps(message)))
 
+    def _calculate_signature(self, request: Request) -> str:
+        """Calculate the signature using request data."""
+        org_id = request.headers.get("Audiohook-Organization-Id")
+        session_id = request.headers.get("Audiohook-Session-Id")
+        correlation_id = request.headers.get("Audiohook-Correlation-Id")
+        api_key = request.headers.get(HEADER_API_KEY)
+
+        # order of components is important!
+        components = [
+            ("@request-target", "/webhooks/genesys/websocket"),
+            ("audiohook-session-id", session_id),
+            ("audiohook-organization-id", org_id),
+            ("audiohook-correlation-id", correlation_id),
+            (HEADER_API_KEY.lower(), api_key),
+            ("@authority", self.server_url),
+        ]
+
+        # Create signature base string
+        signing_string = ""
+        for name, value in components:
+            signing_string += f'"{name}": {value}\n'
+
+        # Add @signature-params
+        signature_input = request.headers["Signature-Input"]
+        _, params_str = signature_input.split("=", 1)
+        signing_string += f'"@signature-params": {params_str}'
+
+        # Calculate the HMAC signature
+        key_bytes = base64.b64decode(self.client_secret)
+        signature = hmac.new(
+            key_bytes, signing_string.encode("utf-8"), hashlib.sha256
+        ).digest()
+        return base64.b64encode(signature).decode("utf-8")
+
+    async def _verify_signature(self, request: Request) -> bool:
+        """Verify the HTTP message signature from Genesys."""
+        if not self.client_secret:
+            logger.info(
+                "genesys.verify_signature.no_client_secret",
+                event_info="Signature verification skipped",
+            )
+            return True  # Skip verification if no client secret
+
+        signature = request.headers.get("Signature")
+        signature_input = request.headers.get("Signature-Input")
+        if not signature or not signature_input:
+            logger.error("genesys.signature.missing_signature_header")
+            return False
+
+        try:
+            actual_signature = signature.split("=", 1)[1].strip(':"')
+            expected_signature = self._calculate_signature(request)
+            return hmac.compare_digest(
+                expected_signature.encode("utf-8"), actual_signature.encode("utf-8")
+            )
+        except Exception as e:
+            logger.exception("genesys.signature.verification_error", error=e)
+            return False
+
+    def _ensure_required_headers(self, request: Request) -> bool:
+        """Ensure required headers are present in the request."""
+        required_headers = [
+            "Audiohook-Organization-Id",
+            "Audiohook-Correlation-Id",
+            "Audiohook-Session-Id",
+            HEADER_API_KEY,
+        ]
+
+        missing_headers = [
+            header for header in required_headers if header not in request.headers
+        ]
+
+        if missing_headers:
+            logger.error(
+                "genesys.missing_required_headers",
+                missing_headers=missing_headers,
+            )
+            return False
+        return True
+
+    def _ensure_api_key(self, request: Request) -> bool:
+        """Ensure the API key is present in the request."""
+        api_key = request.headers.get(HEADER_API_KEY)
+        if not hmac.compare_digest(str(self.api_key), str(api_key)):
+            return False
+        return True
+
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
@@ -289,23 +403,39 @@ class GenesysInputChannel(VoiceInputChannel):
                 "genesys.receive",
                 audiohook_session_id=request.headers.get("audiohook-session-id"),
             )
-            # validate required headers
-            required_headers = [
-                "audiohook-organization-id",
-                "audiohook-correlation-id",
-                "audiohook-session-id",
-                "x-api-key",
-            ]
-
-            for header in required_headers:
-                if header not in request.headers:
-                    await ws.close(1008, f"Missing required header: {header}")
-                    return
-
-            # TODO: validate API key header
+
+            # verify signature
+            if not await self._verify_signature(request):
+                logger.error("genesys.receive.invalid_signature")
+                await ws.close(code=1008, reason="Invalid signature")
+                return
+
+            # ensure required headers are present
+            if not self._ensure_required_headers(request):
+                await ws.close(code=1002, reason="Missing required headers")
+                return
+
+            # ensure API key is correct
+            if not self._ensure_api_key(request):
+                logger.error(
+                    "genesys.receive.invalid_api_key",
+                    invalid_api_key=request.headers.get(HEADER_API_KEY),
+                )
+                await ws.close(code=1008, reason="Invalid API key")
+                return
+
             # process audio streaming
             logger.info("genesys.receive", message="Starting audio streaming")
-            await self.run_audio_streaming(on_new_message, ws)
+            try:
+                await self.run_audio_streaming(on_new_message, ws)
+            except Exception as e:
+                logger.exception(
+                    "genesys.receive",
+                    message="Error during audio streaming",
+                    error=e,
+                )
+                await ws.close(code=1011, reason="Error during audio streaming")
+                raise
 
         return blueprint
 

rasa/core/nlg/contextual_response_rephraser.py

@@ -7,6 +7,10 @@ from rasa import telemetry
 from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
 from rasa.core.nlg.summarize import summarize_conversation
 from rasa.shared.constants import (
+    LANGFUSE_CUSTOM_METADATA_DICT,
+    LANGFUSE_METADATA_SESSION_ID,
+    LANGFUSE_METADATA_USER_ID,
+    LANGFUSE_TAGS,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
@@ -39,6 +43,7 @@ from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
 )
 from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.licensing import get_human_readable_licence_owner
 from rasa.utils.log_utils import log_llm
 
 structlogger = structlog.get_logger()
@@ -130,6 +135,7 @@ class ContextualResponseRephraser(
             "contextual_response_rephraser.init",
             ContextualResponseRephraser.__name__,
         )
+        self.user_id = get_human_readable_licence_owner()
 
     @classmethod
     def _add_prompt_and_llm_metadata_to_response(
@@ -199,7 +205,9 @@ class ContextualResponseRephraser(
         return None
 
     @measure_llm_latency
-    async def _generate_llm_response(self, prompt: str) -> Optional[LLMResponse]:
+    async def _generate_llm_response(
+        self, prompt: str, sender_id: str
+    ) -> Optional[LLMResponse]:
         """Use LLM to generate a response.
 
         Returns an LLMResponse object containing both the generated text
@@ -207,14 +215,21 @@ class ContextualResponseRephraser(
 
         Args:
             prompt: The prompt to send to the LLM.
+            sender_id: sender_id from the tracker.
 
         Returns:
             An LLMResponse object if successful, otherwise None.
         """
         llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+        metadata = {
+            LANGFUSE_METADATA_USER_ID: self.user_id,
+            LANGFUSE_METADATA_SESSION_ID: sender_id,
+            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
+            LANGFUSE_TAGS: [self.__class__.__name__],
+        }
 
         try:
-            return await llm.acompletion(prompt)
+            return await llm.acompletion(prompt, metadata)
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -258,7 +273,9 @@ class ContextualResponseRephraser(
         The history for the prompt.
         """
         llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
-        return await summarize_conversation(tracker, llm, max_turns=5)
+        return await summarize_conversation(
+            tracker, llm, max_turns=5, user_id=self.user_id, sender_id=tracker.sender_id
+        )
 
     async def rephrase(
         self,
@@ -315,7 +332,7 @@ class ContextualResponseRephraser(
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
             llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
-        llm_response = await self._generate_llm_response(prompt)
+        llm_response = await self._generate_llm_response(prompt, tracker.sender_id)
         llm_response = LLMResponse.ensure_llm_response(llm_response)
 
         response = self._add_prompt_and_llm_metadata_to_response(

rasa/core/nlg/summarize.py

@@ -4,6 +4,12 @@ import structlog
 from jinja2 import Template
 
 from rasa.core.tracker_store import DialogueStateTracker
+from rasa.shared.constants import (
+    LANGFUSE_CUSTOM_METADATA_DICT,
+    LANGFUSE_METADATA_SESSION_ID,
+    LANGFUSE_METADATA_USER_ID,
+    LANGFUSE_TAGS,
+)
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
@@ -46,6 +52,8 @@ async def summarize_conversation(
     tracker: DialogueStateTracker,
     llm: LLMClient,
     max_turns: Optional[int] = MAX_TURNS_DEFAULT,
+    user_id: Optional[str] = None,
+    sender_id: Optional[str] = None,
 ) -> str:
     """Summarizes the dialogue using the LLM.
 
@@ -58,8 +66,14 @@ async def summarize_conversation(
         The summary of the dialogue.
     """
     prompt = _create_summarization_prompt(tracker, max_turns)
+    metadata = {
+        LANGFUSE_METADATA_USER_ID: user_id or "unknown",
+        LANGFUSE_METADATA_SESSION_ID: sender_id or "",
+        LANGFUSE_CUSTOM_METADATA_DICT: {"component": "summarize_conversation"},
+        LANGFUSE_TAGS: ["summarize_conversation"],
+    }
     try:
-        llm_response = await llm.acompletion(prompt)
+        llm_response = await llm.acompletion(prompt, metadata)
         summarization = llm_response.choices[0].strip()
         structlogger.debug(
             "summarization.success", summarization=summarization, prompt=prompt

rasa/core/policies/enterprise_search_policy.py

@@ -46,6 +46,10 @@ from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
+    LANGFUSE_CUSTOM_METADATA_DICT,
+    LANGFUSE_METADATA_SESSION_ID,
+    LANGFUSE_METADATA_USER_ID,
+    LANGFUSE_TAGS,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -545,7 +549,9 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
         if self.use_llm:
             prompt = self._render_prompt(tracker, documents.results)
-            llm_response = await self._generate_llm_answer(llm, prompt)
+            llm_response = await self._generate_llm_answer(
+                llm, prompt, tracker.sender_id
+            )
             llm_response = LLMResponse.ensure_llm_response(llm_response)
 
             self._add_prompt_and_llm_response_to_latest_message(
@@ -641,19 +647,26 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
     @measure_llm_latency
     async def _generate_llm_answer(
-        self, llm: LLMClient, prompt: Text
+        self, llm: LLMClient, prompt: Text, sender_id: str
     ) -> Optional[LLMResponse]:
         """Fetches an LLM completion for the provided prompt.
 
         Args:
             llm: The LLM client used to get the completion.
             prompt: The prompt text to send to the model.
+            sender_id: sender_id from the tracker.
 
         Returns:
             An LLMResponse object, or None if the call fails.
         """
+        metadata = {
+            LANGFUSE_METADATA_USER_ID: self.user_id,
+            LANGFUSE_METADATA_SESSION_ID: sender_id,
+            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
+            LANGFUSE_TAGS: [self.__class__.__name__],
+        }
         try:
-            return await llm.acompletion(prompt)
+            return await llm.acompletion(prompt, metadata)
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here

rasa/core/policies/intentless_policy.py

@@ -30,6 +30,10 @@ from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
+    LANGFUSE_CUSTOM_METADATA_DICT,
+    LANGFUSE_METADATA_SESSION_ID,
+    LANGFUSE_METADATA_USER_ID,
+    LANGFUSE_TAGS,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
@@ -619,6 +623,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         response_examples: List[str],
         conversation_samples: List[str],
         history: str,
+        sender_id: str,
     ) -> Optional[str]:
         """Make the llm call to generate an answer."""
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
@@ -634,11 +639,19 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             log_event="intentless_policy.generate_answer.prompt_rendered",
             prompt=prompt,
         )
-        return await self._generate_llm_answer(llm, prompt)
+        return await self._generate_llm_answer(llm, prompt, sender_id)
 
-    async def _generate_llm_answer(self, llm: LLMClient, prompt: str) -> Optional[str]:
+    async def _generate_llm_answer(
+        self, llm: LLMClient, prompt: str, sender_id: str
+    ) -> Optional[str]:
+        metadata = {
+            LANGFUSE_METADATA_USER_ID: self.user_id,
+            LANGFUSE_METADATA_SESSION_ID: sender_id,
+            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
+            LANGFUSE_TAGS: [self.__class__.__name__],
+        }
         try:
-            llm_response = await llm.acompletion(prompt)
+            llm_response = await llm.acompletion(prompt, metadata)
             return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
@@ -714,7 +727,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
                 final_response_examples.append(resp)
 
         llm_response = await self.generate_answer(
-            final_response_examples, conversation_samples, history
+            final_response_examples, conversation_samples, history, tracker.sender_id
         )
         if not llm_response:
             structlogger.debug("intentless_policy.prediction.skip_llm_fail")

rasa/core/policies/policy.py

@@ -39,6 +39,7 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaException
 from rasa.shared.nlu.constants import ACTION_NAME, ACTION_TEXT, ENTITIES, INTENT, TEXT
+from rasa.utils.licensing import get_human_readable_licence_owner
 
 if TYPE_CHECKING:
     from rasa.core.featurizers.tracker_featurizers import (
@@ -172,6 +173,7 @@ class Policy(GraphComponent):
 
         self._model_storage = model_storage
         self._resource = resource
+        self.user_id = get_human_readable_licence_owner()
 
     @classmethod
     def create(

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -23,6 +23,10 @@ from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import (
+    LANGFUSE_CUSTOM_METADATA_DICT,
+    LANGFUSE_METADATA_SESSION_ID,
+    LANGFUSE_METADATA_USER_ID,
+    LANGFUSE_TAGS,
     MODEL_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
@@ -43,6 +47,7 @@ from rasa.shared.utils.llm import (
     llm_factory,
     resolve_model_client_config,
 )
+from rasa.utils.licensing import get_human_readable_licence_owner
 from rasa.utils.log_utils import log_llm
 
 LLM_BASED_ROUTER_PROMPT_FILE_NAME = "llm_based_router_prompt.jinja2"
@@ -113,6 +118,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         self._model_storage = model_storage
         self._resource = resource
         self.validate_config()
+        self.user_id = get_human_readable_licence_owner()
 
     def validate_config(self) -> None:
         """Validate the config of the router."""
@@ -160,7 +166,6 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         **kwargs: Any,
     ) -> "LLMBasedRouter":
         """Loads trained component (see parent class for full docstring)."""
-
         # Perform health check on the resolved LLM client config
         llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
         cls.perform_llm_health_check(
@@ -232,7 +237,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
                 prompt=prompt,
             )
             # generating answer
-            answer = await self._generate_answer_using_llm(prompt)
+            answer = await self._generate_answer_using_llm(prompt, tracker.sender_id)
             log_llm(
                 logger=structlogger,
                 log_module="LLMBasedRouter",
@@ -292,7 +297,9 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
 
         return Template(self.prompt_template).render(**inputs)
 
-    async def _generate_answer_using_llm(self, prompt: str) -> Optional[str]:
+    async def _generate_answer_using_llm(
+        self, prompt: str, sender_id: str
+    ) -> Optional[str]:
         """Use LLM to generate a response.
 
         Args:
@@ -303,8 +310,15 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         """
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
 
+        metadata = {
+            LANGFUSE_METADATA_USER_ID: self.user_id,
+            LANGFUSE_METADATA_SESSION_ID: sender_id,
+            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
+            LANGFUSE_TAGS: [self.__class__.__name__],
+        }
+
         try:
-            llm_response = await llm.acompletion(prompt)
+            llm_response = await llm.acompletion(prompt, metadata)
             return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means