rasa-pro 3.12.6.dev1__tar.gz → 3.12.6.dev2__tar.gz

{rasa_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.12.6.dev1
+Version: 3.12.6.dev2
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH
@@ -63,6 +63,7 @@ Requires-Dist: keras (==2.14.0)
 Requires-Dist: langchain (>=0.2.17,<0.3.0)
 Requires-Dist: langchain-community (>=0.2.19,<0.3.0)
 Requires-Dist: langcodes (>=3.5.0,<4.0.0)
+Requires-Dist: langfuse (>=2.60.2,<2.61.0)
 Requires-Dist: litellm (>=1.52.6,<1.53.0)
 Requires-Dist: matplotlib (>=3.7,<3.8)
 Requires-Dist: mattermostwrapper (>=2.2,<2.3)
@@ -116,6 +117,7 @@ Requires-Dist: scikit-learn (>=1.5.1,<1.6.0)
 Requires-Dist: scipy (>=1.13.1,<1.14.0)
 Requires-Dist: sentencepiece[sentencepiece] (>=0.1.99,<0.2.0) ; extra == "transformers" or extra == "full"
 Requires-Dist: sentry-sdk (>=1.14.0,<1.15.0)
+Requires-Dist: setuptools (>=70.0.0,<70.1.0)
 Requires-Dist: sklearn-crfsuite (>=0.3.6,<0.4.0)
 Requires-Dist: skops (>=0.10.0,<0.11.0)
 Requires-Dist: slack-sdk (>=3.27.1,<3.28.0)
@@ -145,6 +147,7 @@ Requires-Dist: typing-utils (>=0.1.0,<0.2.0)
 Requires-Dist: ujson (>=5.8,<6.0)
 Requires-Dist: webexteamssdk (>=1.6.1,<1.7.0)
 Requires-Dist: websockets (>=10.4,<11.0)
+Requires-Dist: wheel (>=0.40.0)
 Project-URL: Documentation, https://rasa.com/docs
 Project-URL: Homepage, https://rasa.com
 Project-URL: Repository, https://github.com/rasahq/rasa

{rasa_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.12.6.dev1"
+version = "3.12.6.dev2"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -132,7 +132,7 @@ psycopg2-binary = ">=2.9.9,<2.10.0"
 python-dateutil = "~2.8.2"
 protobuf = ">=4.23.3,< 4.25.4"
 tensorflow_hub = "^0.13.0"
-#setuptools = "~70.0.0" #test if this is needed
+setuptools = "~70.0.0"
 ujson = ">=5.8,<6.0"
 regex = "~2024.7.24"
 sentry-sdk = ">=1.14.0,<1.15.0"
@@ -156,7 +156,7 @@ langchain-community = "~0.2.19"
 jinja2 = "~3.1.6"
 openai = "~1.55.3"
 dnspython = "2.6.1"
-#wheel = ">=0.40.0" #test if this is needed
+wheel = ">=0.40.0"
 certifi = ">=2024.07.04"
 cryptography = ">=44.0.1"
 jsonpatch = "^1.33"
@@ -195,6 +195,7 @@ scikit-learn = "~1.5.1"
 demoji = "^1.1.0"
 azure-identity = "~1.19.0"
 langcodes = "^3.5.0"
+langfuse = "~2.60.2"
 
 [[tool.poetry.dependencies.tensorflow-io-gcs-filesystem]]
 version = "==0.31" # newer versions don't provide wheels for Windows
@@ -330,6 +331,8 @@ convention = "google"
 "tests/test_telemetry.py" = [ "E501",]
 "tests/shared/core/test_domain.py" = [ "E501",]
 
+
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

rasa_pro-3.12.6.dev2/rasa/__init__.py

@@ -0,0 +1,15 @@
+import logging
+
+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_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/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_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/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_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/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_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/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_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/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_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/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

{rasa_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -49,6 +49,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
 
 structlogger = structlog.get_logger()
@@ -92,6 +93,8 @@ class LLMBasedCommandGenerator(
         else:
             self.flow_retrieval = None
 
+        self.user_id = get_human_readable_licence_owner()
+
     ### Abstract methods
     @staticmethod
     @abstractmethod
@@ -331,7 +334,9 @@ class LLMBasedCommandGenerator(
 
     @measure_llm_latency
     async def invoke_llm(
-        self, prompt: Union[List[dict], List[str], str]
+        self,
+        prompt: Union[List[dict], List[str], str],
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> Optional[LLMResponse]:
         """Use LLM to generate a response.
 
@@ -344,6 +349,7 @@ class LLMBasedCommandGenerator(
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
+            metadata: Optional metadata to be passed to the LLM call.
 
         Returns:
             An LLMResponse object.
@@ -355,7 +361,7 @@ class LLMBasedCommandGenerator(
             self.config.get(LLM_CONFIG_KEY), self.get_default_llm_config()
         )
         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_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/rasa/dialogue_understanding/generator/llm_command_generator.py

@@ -55,7 +55,9 @@ class LLMCommandGenerator(SingleStepLLMCommandGenerator):
         )
 
     async def invoke_llm(
-        self, prompt: Union[List[dict], List[str], str]
+        self,
+        prompt: Union[List[dict], List[str], str],
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> Optional[LLMResponse]:
         try:
             return await super().invoke_llm(prompt)

{rasa_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -47,6 +47,10 @@ from rasa.shared.constants import (
     AWS_BEDROCK_PROVIDER,
     AZURE_OPENAI_PROVIDER,
     EMBEDDINGS_CONFIG_KEY,
+    LANGFUSE_CUSTOM_METADATA_DICT,
+    LANGFUSE_METADATA_SESSION_ID,
+    LANGFUSE_METADATA_USER_ID,
+    LANGFUSE_TAGS,
     MAX_TOKENS_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
     ROUTE_TO_CALM_SLOT,
@@ -362,7 +366,14 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
             prompt=flow_prompt,
         )
 
-        response = await self.invoke_llm(flow_prompt)
+        metadata = {
+            LANGFUSE_METADATA_USER_ID: self.user_id,
+            LANGFUSE_METADATA_SESSION_ID: tracker.sender_id if tracker else "",
+            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
+            LANGFUSE_TAGS: [self.__class__.__name__],
+        }
+
+        response = await self.invoke_llm(flow_prompt, metadata)
         llm_response = LLMResponse.ensure_llm_response(response)
         # The check for 'None' maintains compatibility with older versions
         # of LLMCommandGenerator. In previous implementations, 'invoke_llm'

{rasa_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/rasa/hooks.py

@@ -1,8 +1,20 @@
 import argparse
 import logging
+import os
 from typing import TYPE_CHECKING, List, Optional, Text, Union
 
+import litellm
 import pluggy
+import structlog
+
+from rasa.shared.providers.constants import (
+    LANGFUSE_CALLBACK_NAME,
+    LANGFUSE_HOST_ENV_VAR,
+    LANGFUSE_PROJECT_ID_ENV_VAR,
+    LANGFUSE_PUBLIC_KEY_ENV_VAR,
+    LANGFUSE_SECRET_KEY_ENV_VAR,
+    RASA_LANGFUSE_INTEGRATION_ENABLED_ENV_VAR,
+)
 
 # IMPORTANT: do not import anything from rasa here - use scoped imports
 #  this avoids circular imports, as the hooks are used in different places
@@ -18,6 +30,7 @@ if TYPE_CHECKING:
 
 hookimpl = pluggy.HookimplMarker("rasa")
 logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 @hookimpl  # type: ignore[misc]
@@ -57,6 +70,8 @@ def configure_commandline(cmdline_arguments: argparse.Namespace) -> Optional[Tex
         config.configure_tracing(tracer_provider)
         config.configure_metrics(endpoints_file)
 
+    _init_langfuse_integration()
+
     return endpoints_file
 
 
@@ -115,3 +130,43 @@ def after_server_stop() -> None:
 
     if anon_pipeline is not None:
         anon_pipeline.stop()
+
+
+def _is_langfuse_integration_enabled() -> bool:
+    return (
+        os.environ.get(RASA_LANGFUSE_INTEGRATION_ENABLED_ENV_VAR, "false").lower()
+        == "true"
+    )
+
+
+def _init_langfuse_integration() -> None:
+    if not _is_langfuse_integration_enabled():
+        structlogger.info(
+            "hooks._init_langfuse_integration.disabled",
+            event_info="Langfuse integration is disabled.",
+        )
+        return
+
+    if (
+        not os.environ.get(LANGFUSE_HOST_ENV_VAR)
+        or not os.environ.get(LANGFUSE_PROJECT_ID_ENV_VAR)
+        or not os.environ.get(LANGFUSE_PUBLIC_KEY_ENV_VAR)
+        or not os.environ.get(LANGFUSE_SECRET_KEY_ENV_VAR)
+    ):
+        structlogger.warning(
+            "hooks._init_langfuse_integration.missing_langfuse_keys",
+            event_info=(
+                "Langfuse integration is enabled, but some environment variables"
+                "are missing. Please set LANGFUSE_HOST, LANGFUSE_PROJECT_ID, "
+                "LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY environment "
+                "variables to use Langfuse integration."
+            ),
+        )
+        return
+
+    litellm.success_callback = [LANGFUSE_CALLBACK_NAME]
+    litellm.failure_callback = [LANGFUSE_CALLBACK_NAME]
+    structlogger.info(
+        "hooks.langfuse_callbacks_initialized",
+        event_info="Langfuse integration initialized.",
+    )

rasa_pro-3.12.6.dev2/rasa/monkey_patches.py

@@ -0,0 +1,91 @@
+import os
+import traceback
+from typing import Any, Optional
+
+from litellm.secret_managers.main import str_to_bool
+from packaging.version import Version
+
+
+def litellm_langfuse_logger_init_fixed(
+    self: Any,  # we should not import LangfuseLogger class before we patch it
+    langfuse_public_key: Optional[str] = None,
+    langfuse_secret: Optional[str] = None,
+    langfuse_host: str = "https://cloud.langfuse.com",
+    flush_interval: int = 1,
+) -> None:
+    """Monkeypatched version of LangfuseLogger.__init__ from the LiteLLM library.
+
+    This patched version removes a call that fetched the `project_id` from
+    Langfuse Cloud even when it was already set via environment variables.
+    In the original implementation, this call was made *before* initializing
+    the LangfuseClient, which caused the application to freeze for up to 60 seconds.
+
+    By removing this premature call, the monkeypatch avoids the unnecessary network
+    request and prevents the timeout/freeze issue.
+
+    This workaround can be removed once the underlying bug is resolved in LiteLLM:
+    https://github.com/BerriAI/litellm/issues/7732
+    """
+    try:
+        import langfuse
+        from langfuse import Langfuse
+    except Exception as e:
+        raise Exception(
+            f"\033[91mLangfuse not installed, try running 'pip install langfuse' "
+            f"to fix this error: {e}\n{traceback.format_exc()}\033[0m"
+        )
+    # Instance variables
+    self.secret_key = langfuse_secret or os.getenv("LANGFUSE_SECRET_KEY", "")
+    self.public_key = langfuse_public_key or os.getenv("LANGFUSE_PUBLIC_KEY", "")
+
+    self.langfuse_host = langfuse_host or os.getenv(
+        "LANGFUSE_HOST", "https://cloud.langfuse.com"
+    )
+    self.langfuse_host.replace("http://", "https://")
+    if not self.langfuse_host.startswith("https://"):
+        self.langfuse_host = "https://" + self.langfuse_host
+
+    self.langfuse_release = os.getenv("LANGFUSE_RELEASE")
+    self.langfuse_debug = os.getenv("LANGFUSE_DEBUG")
+    self.langfuse_flush_interval = (
+        os.getenv("LANGFUSE_FLUSH_INTERVAL") or flush_interval
+    )
+
+    parameters = {
+        "public_key": self.public_key,
+        "secret_key": self.secret_key,
+        "host": self.langfuse_host,
+        "release": self.langfuse_release,
+        "debug": self.langfuse_debug,
+        "flush_interval": self.langfuse_flush_interval,  # flush interval in seconds
+    }
+
+    if Version(langfuse.version.__version__) >= Version("2.6.0"):
+        parameters["sdk_integration"] = "litellm"
+
+    self.Langfuse = Langfuse(**parameters)
+
+    if os.getenv("UPSTREAM_LANGFUSE_SECRET_KEY") is not None:
+        upstream_langfuse_debug = (
+            str_to_bool(self.upstream_langfuse_debug)
+            if self.upstream_langfuse_debug is not None
+            else None
+        )
+        self.upstream_langfuse_secret_key = os.getenv("UPSTREAM_LANGFUSE_SECRET_KEY")
+        self.upstream_langfuse_public_key = os.getenv("UPSTREAM_LANGFUSE_PUBLIC_KEY")
+        self.upstream_langfuse_host = os.getenv("UPSTREAM_LANGFUSE_HOST")
+        self.upstream_langfuse_release = os.getenv("UPSTREAM_LANGFUSE_RELEASE")
+        self.upstream_langfuse_debug = os.getenv("UPSTREAM_LANGFUSE_DEBUG")
+        self.upstream_langfuse = Langfuse(
+            public_key=self.upstream_langfuse_public_key,
+            secret_key=self.upstream_langfuse_secret_key,
+            host=self.upstream_langfuse_host,
+            release=self.upstream_langfuse_release,
+            debug=(
+                upstream_langfuse_debug
+                if upstream_langfuse_debug is not None
+                else False
+            ),
+        )
+    else:
+        self.upstream_langfuse = None

{rasa_pro-3.12.6.dev1 → rasa_pro-3.12.6.dev2}/rasa/shared/constants.py

@@ -338,3 +338,8 @@ ROLE_SYSTEM = "system"
 # Used for key values in ValidateSlotPatternFlowStackFrame
 REFILL_UTTER = "refill_utter"
 REJECTIONS = "rejections"
+
+LANGFUSE_METADATA_USER_ID = "trace_user_id"
+LANGFUSE_METADATA_SESSION_ID = "session_id"
+LANGFUSE_CUSTOM_METADATA_DICT = "trace_metadata"
+LANGFUSE_TAGS = "tags"