rasa-pro 3.12.6.dev2__py3-none-any.whl → 3.13.0.dev2__py3-none-any.whl

rasa/document_retrieval/knowledge_base_connectors/api_connector.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict, Optional
+
+from rasa.core.information_retrieval import SearchResultList
+from rasa.document_retrieval.knowledge_base_connectors.knowledge_base_connector import (
+    KnowledgeBaseConnector,
+)
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class APIConnector(KnowledgeBaseConnector):
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self.config = config
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        **kwargs: Any,
+    ) -> "APIConnector":
+        # TODO implement
+        return APIConnector(config)
+
+    async def retrieve_documents(
+        self,
+        search_query: str,
+        k: int,
+        threshold: float,
+        tracker: Optional[DialogueStateTracker],
+    ) -> Optional[SearchResultList]:
+        # TODO implement
+        return SearchResultList(results=[], metadata={})
+
+    def connect_or_raise(self) -> None:
+        # TODO implement
+        return None

rasa/document_retrieval/knowledge_base_connectors/knowledge_base_connector.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+from rasa.core.information_retrieval import SearchResultList
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class KnowledgeBaseConnector(ABC):
+    @abstractmethod
+    def connect_or_raise(self) -> None:
+        pass
+
+    @abstractmethod
+    async def retrieve_documents(
+        self,
+        search_query: str,
+        k: int,
+        threshold: float,
+        tracker: Optional[DialogueStateTracker],
+    ) -> Optional[SearchResultList]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def load(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        **kwargs: Any,
+    ) -> "KnowledgeBaseConnector":
+        pass

rasa/document_retrieval/knowledge_base_connectors/vector_store_connector.py

@@ -0,0 +1,226 @@
+import copy
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+import structlog
+
+from rasa.core.information_retrieval import (
+    InformationRetrieval,
+    InformationRetrievalException,
+    SearchResultList,
+    create_from_endpoint_config,
+)
+from rasa.core.information_retrieval.faiss import FAISS_Store
+from rasa.document_retrieval.constants import (
+    DEFAULT_EMBEDDINGS_CONFIG,
+    DEFAULT_VECTOR_STORE,
+    DEFAULT_VECTOR_STORE_TYPE,
+    VECTOR_STORE_CONFIG_KEY,
+    VECTOR_STORE_TYPE_CONFIG_KEY,
+)
+from rasa.document_retrieval.knowledge_base_connectors.knowledge_base_connector import (
+    KnowledgeBaseConnector,
+)
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.constants import EMBEDDINGS_CONFIG_KEY
+from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
+from rasa.shared.exceptions import RasaException
+from rasa.shared.providers.embedding._langchain_embedding_client_adapter import (
+    _LangchainEmbeddingClientAdapter,
+)
+from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
+    EmbeddingsHealthCheckMixin,
+)
+from rasa.shared.utils.health_check.health_check import perform_embeddings_health_check
+from rasa.shared.utils.llm import embedder_factory, resolve_model_client_config
+
+if TYPE_CHECKING:
+    from langchain.schema.embeddings import Embeddings
+
+
+structlogger = structlog.get_logger()
+
+
+class VectorStoreConnectionError(RasaException):
+    """Exception raised for errors in connecting to the vector store."""
+
+
+class VectorStoreConfigurationError(RasaException):
+    """Exception raised for errors in vector store configuration."""
+
+
+class VectorStoreType(Enum):
+    FAISS = "FAISS"
+    QDRANT = "QDRANT"
+    MILVUS = "MILVUS"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class VectorStoreConnector(KnowledgeBaseConnector, EmbeddingsHealthCheckMixin):
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        vector_store: Optional[InformationRetrieval] = None,
+    ) -> None:
+        self.config = config
+        self.vector_store_type = config.get(VECTOR_STORE_CONFIG_KEY, {}).get(
+            VECTOR_STORE_TYPE_CONFIG_KEY
+        )
+
+        # Vector store object and configuration
+        self.vector_store = vector_store
+        self.vector_store_config = self.config.get(
+            VECTOR_STORE_CONFIG_KEY, DEFAULT_VECTOR_STORE
+        )
+
+        # Embeddings configuration for encoding the search query
+        self.embeddings_config = (
+            self.config[EMBEDDINGS_CONFIG_KEY] or DEFAULT_EMBEDDINGS_CONFIG
+        )
+
+        self._model_storage = model_storage
+        self._resource = resource
+
+    @classmethod
+    def _create_plain_embedder(cls, config: Dict[str, Any]) -> "Embeddings":
+        """Creates an embedder based on the given configuration.
+
+        Returns:
+        The embedder.
+        """
+        # Copy the config so original config is not modified
+        config = copy.deepcopy(config)
+        # Resolve config and instantiate the embedding client
+        config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY), VectorStoreConnector.__name__
+        )
+        client = embedder_factory(
+            config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
+        )
+        # Wrap the embedding client in the adapter
+        return _LangchainEmbeddingClientAdapter(client)
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        **kwargs: Any,
+    ) -> "VectorStoreConnector":
+        # Perform health check on the resolved embeddings client config
+        embedding_config = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY, {})
+        )
+        perform_embeddings_health_check(
+            embedding_config,
+            DEFAULT_EMBEDDINGS_CONFIG,
+            "vector_store_connector.load",
+            VectorStoreConnector.__name__,
+        )
+
+        store_type = config.get(VECTOR_STORE_CONFIG_KEY, {}).get(
+            VECTOR_STORE_TYPE_CONFIG_KEY
+        )
+        embeddings = cls._create_plain_embedder(config)
+
+        structlogger.info("vector_store_connector.load", config=config)
+        if store_type == VectorStoreType.FAISS.value:
+            # if a vector store is not specified,
+            # default to using FAISS with the index stored in the model
+            # TODO figure out a way to get path without context manager
+            with model_storage.read_from(resource) as path:
+                vector_store = FAISS_Store(
+                    embeddings=embeddings,
+                    index_path=path,
+                    docs_folder=None,
+                    create_index=False,
+                )
+        else:
+            vector_store = create_from_endpoint_config(
+                config_type=store_type,
+                embeddings=embeddings,
+            )  # type: ignore
+
+        return cls(
+            config=config,
+            model_storage=model_storage,
+            resource=resource,
+            vector_store=vector_store,
+        )
+
+    def connect_or_raise(self) -> None:
+        """Connects to the vector store or raises an exception.
+
+        Raise exceptions for the following cases:
+        - The configuration is not specified
+        - Unable to connect to the vector store
+
+        Args:
+            endpoints: Endpoints configuration.
+        """
+        if self.vector_store_type == VectorStoreType.FAISS.value:
+            return
+        from rasa.core.utils import AvailableEndpoints
+
+        endpoints = AvailableEndpoints.get_instance()
+
+        config = endpoints.vector_store if endpoints else None
+        store_type = self.config.get(VECTOR_STORE_CONFIG_KEY, {}).get(
+            VECTOR_STORE_TYPE_CONFIG_KEY
+        )
+
+        if config is None and store_type != DEFAULT_VECTOR_STORE_TYPE:
+            structlogger.error("vector_store_connector._connect_or_raise.no_config")
+            raise VectorStoreConfigurationError(
+                """No vector store specified. Please specify a vector
+                store in the endpoints configuration."""
+            )
+        try:
+            self.vector_store.connect(config)  # type: ignore
+        except Exception as e:
+            structlogger.error(
+                "vector_store_connector._connect_or_raise.connect_error",
+                error=e,
+                config=config,
+            )
+            raise VectorStoreConnectionError(
+                f"Unable to connect to the vector store. Error: {e}"
+            )
+
+    async def retrieve_documents(
+        self,
+        search_query: str,
+        k: int,
+        threshold: float,
+        tracker: Optional[DialogueStateTracker],
+    ) -> Optional[SearchResultList]:
+        if self.vector_store is None:
+            return None
+
+        try:
+            self.connect_or_raise()
+        except (VectorStoreConfigurationError, VectorStoreConnectionError) as e:
+            structlogger.error("vector_store_connector.connection_error", error=e)
+            return None
+
+        if tracker is not None:
+            tracker_state = tracker.current_state(EventVerbosity.AFTER_RESTART)
+        else:
+            tracker_state = {}
+
+        try:
+            return await self.vector_store.search(
+                query=search_query,
+                threshold=threshold,
+                tracker_state=tracker_state,
+                k=k,
+            )
+        except InformationRetrievalException as e:
+            structlogger.error("vector_store.search_error", error=e)
+            return None

rasa/document_retrieval/query_rewriter.py

@@ -0,0 +1,234 @@
+import importlib.resources
+from enum import Enum
+from typing import Any, Dict, Optional
+
+import structlog
+from jinja2 import Template
+
+import rasa.shared.utils.io
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.constants import (
+    LLM_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    PROMPT_TEMPLATE_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    TEXT,
+    TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import FileIOException, ProviderClientAPIException
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.providers.llm.llm_client import LLMClient
+from rasa.shared.providers.llm.llm_response import LLMResponse
+from rasa.shared.utils.health_check.health_check import perform_llm_health_check
+from rasa.shared.utils.health_check.llm_health_check_mixin import (
+    LLMHealthCheckMixin,
+)
+from rasa.shared.utils.llm import (
+    AI,
+    DEFAULT_OPENAI_GENERATE_MODEL_NAME,
+    DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    USER,
+    get_prompt_template,
+    llm_factory,
+    resolve_model_client_config,
+    sanitize_message_for_prompt,
+    tracker_as_readable_transcript,
+)
+
+QUERY_REWRITER_PROMPT_FILE_NAME = "query_rewriter_prompt_template.jinja2"
+MAX_TURNS = "max_turns"
+DEFAULT_LLM_CONFIG = {
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_GENERATE_MODEL_NAME,
+    "temperature": 0.3,
+    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TIMEOUT_CONFIG_KEY: 5,
+}
+DEFAULT_QUERY_REWRITER_PROMPT_TEMPLATE = importlib.resources.read_text(
+    "rasa.document_retrieval",
+    "query_rewriter_prompt_template.jinja2",
+)
+
+TYPE_CONFIG_KEY = "type"
+
+structlogger = structlog.get_logger()
+
+
+class QueryRewritingType(Enum):
+    PLAIN = "PLAIN"
+    CONCATENATED_TURNS = "CONCATENATED_TURNS"
+    REPHRASE = "REPHRASE"
+    KEYWORD_EXTRACTION = "KEYWORD_EXTRACTION"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+class QueryRewriter(LLMHealthCheckMixin):
+    @classmethod
+    def get_default_config(cls) -> Dict[str, Any]:
+        """The default config for the query rewriter."""
+        return {
+            TYPE_CONFIG_KEY: QueryRewritingType.PLAIN,
+            MAX_TURNS: 0,
+            LLM_CONFIG_KEY: DEFAULT_LLM_CONFIG,
+            PROMPT_TEMPLATE_CONFIG_KEY: DEFAULT_QUERY_REWRITER_PROMPT_TEMPLATE,
+        }
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        prompt_template: Optional[str] = None,
+    ):
+        self.config = {**self.get_default_config(), **config}
+        self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
+            self.config.get(LLM_CONFIG_KEY), QueryRewriter.__name__
+        )
+        self.prompt_template = prompt_template or get_prompt_template(
+            config.get(PROMPT_TEMPLATE_CONFIG_KEY),
+            DEFAULT_QUERY_REWRITER_PROMPT_TEMPLATE,
+        )
+
+        self._model_storage = model_storage
+        self._resource = resource
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        **kwargs: Any,
+    ) -> "QueryRewriter":
+        """Load query rewriter."""
+        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
+        perform_llm_health_check(
+            llm_config,
+            DEFAULT_LLM_CONFIG,
+            "query_rewriter.load",
+            QueryRewriter.__name__,
+        )
+
+        # load prompt template
+        prompt_template = None
+        try:
+            with model_storage.read_from(resource) as path:
+                prompt_template = rasa.shared.utils.io.read_file(
+                    path / QUERY_REWRITER_PROMPT_FILE_NAME
+                )
+        except (FileNotFoundError, FileIOException) as e:
+            structlogger.warning(
+                "query_rewriter.load_prompt_template.failed",
+                error=e,
+                resource=resource.name,
+            )
+
+        return QueryRewriter(config, model_storage, resource, prompt_template)
+
+    def persist(self) -> None:
+        with self._model_storage.write_to(self._resource) as path:
+            rasa.shared.utils.io.write_text_file(
+                self.prompt_template, path / QUERY_REWRITER_PROMPT_FILE_NAME
+            )
+
+    @staticmethod
+    def _concatenate_turns(
+        message: Message, tracker: DialogueStateTracker, max_turns: int
+    ) -> str:
+        transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+        transcript += "\nUSER: " + message.get(TEXT)
+        return transcript
+
+    @staticmethod
+    async def _invoke_llm(prompt: str, llm: LLMClient) -> Optional[LLMResponse]:
+        try:
+            return await llm.acompletion(prompt)
+        except Exception as e:
+            # unfortunately, langchain does not wrap LLM exceptions which means
+            # we have to catch all exceptions here
+            structlogger.error("query_rewriter.llm.error", error=e)
+            raise ProviderClientAPIException(
+                message="LLM call exception", original_exception=e
+            )
+
+    async def _rephrase_message(
+        self, message: Message, tracker: DialogueStateTracker, max_turns: int = 5
+    ) -> str:
+        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
+
+        transcript = tracker_as_readable_transcript(
+            tracker, max_turns=max_turns, ai_prefix="ASSISTANT"
+        )
+
+        inputs = {
+            "conversation": transcript,
+            "user_message": message.get(TEXT),
+        }
+
+        prompt = Template(self.prompt_template).render(**inputs)
+        llm_response = await self._invoke_llm(prompt, llm)
+        llm_response = LLMResponse.ensure_llm_response(llm_response)
+
+        return llm_response.choices[0]
+
+    @staticmethod
+    def _keyword_extraction(
+        message: Message, tracker: DialogueStateTracker, max_turns: int = 5
+    ) -> str:
+        import spacy
+
+        nlp = spacy.load("en_core_web_md")
+
+        transcript = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+        transcript = transcript.replace(USER, "")
+        transcript = transcript.replace(AI, "")
+
+        doc = nlp(transcript)
+
+        keywords = set()
+        for token in doc:
+            # Extract nouns and proper nouns
+            if token.pos_ in ["NOUN", "PROPN"]:
+                keywords.add(token.lemma_)
+
+        for ent in doc.ents:
+            # Add named entities as keywords
+            keywords.add(ent.text)
+
+        # Remove stop words and punctuation
+        keywords = {
+            word
+            for word in keywords
+            if word.lower() not in nlp.Defaults.stop_words and word.isalpha()
+        }
+
+        if keywords:
+            return message.get(TEXT) + " " + " ".join(keywords)
+        else:
+            return message.get(TEXT)
+
+    async def prepare_search_query(
+        self, message: Message, tracker: DialogueStateTracker
+    ) -> str:
+        query_rewriting_type = self.config[TYPE_CONFIG_KEY]
+        max_turns: int = self.config[MAX_TURNS]
+
+        query: str
+
+        if query_rewriting_type == QueryRewritingType.CONCATENATED_TURNS.value:
+            query = self._concatenate_turns(message, tracker, max_turns)
+        elif query_rewriting_type == QueryRewritingType.KEYWORD_EXTRACTION.value:
+            query = self._keyword_extraction(message, tracker, max_turns)
+        elif query_rewriting_type == QueryRewritingType.REPHRASE.value:
+            query = await self._rephrase_message(message, tracker, max_turns)
+        elif query_rewriting_type == QueryRewritingType.PLAIN.value:
+            query = message.get(TEXT)
+        else:
+            raise ValueError(f"Invalid query rewriting type: {query_rewriting_type}")
+
+        return sanitize_message_for_prompt(query)

rasa/document_retrieval/query_rewriter_prompt_template.jinja2

@@ -0,0 +1,8 @@
+Conversation Context:
+{{conversation}}
+
+User's Latest Request: {{user_message}}
+
+Instruction: Rephrase the user's latest request into a concise search query for a knowledge base.
+
+Search Query:

rasa/engine/recipes/default_components.py

@@ -13,6 +13,7 @@ from rasa.dialogue_understanding.generator import (
     LLMCommandGenerator,
 )
 from rasa.dialogue_understanding.generator.nlu_command_adapter import NLUCommandAdapter
+from rasa.document_retrieval.document_retriever import DocumentRetriever
 from rasa.nlu.classifiers.diet_classifier import DIETClassifier
 from rasa.nlu.classifiers.fallback_classifier import FallbackClassifier
 from rasa.nlu.classifiers.keyword_intent_classifier import KeywordIntentClassifier
@@ -92,4 +93,5 @@ DEFAULT_COMPONENTS = [
     FlowPolicy,
     EnterpriseSearchPolicy,
     IntentlessPolicy,
+    DocumentRetriever,
 ]

rasa/hooks.py

@@ -1,20 +1,8 @@
 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
@@ -30,7 +18,6 @@ if TYPE_CHECKING:
 
 hookimpl = pluggy.HookimplMarker("rasa")
 logger = logging.getLogger(__name__)
-structlogger = structlog.get_logger()
 
 
 @hookimpl  # type: ignore[misc]
@@ -70,8 +57,6 @@ 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
 
 
@@ -130,43 +115,3 @@ 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/model_manager/model_api.py

@@ -483,7 +483,7 @@ def external_blueprint() -> Blueprint:
     """Create a blueprint for the model manager API."""
     from rasa.core.channels.socketio import SocketBlueprint
 
-    sio = AsyncServer(async_mode="sanic", cors_allowed_origins="*")
+    sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
     bp = SocketBlueprint(sio, "", "model_api_external")
 
     create_bridge_server(sio, running_bots)

rasa/model_manager/socket_bridge.py

@@ -131,13 +131,6 @@ async def create_bridge_client(
         structlogger.debug("model_runner.bot_message", deployment_id=deployment_id)
         await sio.emit("bot_message", data, room=sid)
 
-    @client.event  # type: ignore[misc]
-    async def error(data: Dict[str, Any]) -> None:
-        structlogger.debug(
-            "model_runner.bot_error", deployment_id=deployment_id, data=data
-        )
-        await sio.emit("error", data, room=sid)
-
     @client.event  # type: ignore[misc]
     async def tracker(data: Dict[str, Any]) -> None:
         await sio.emit("tracker", json.loads(data), room=sid)

rasa/shared/constants.py

@@ -338,8 +338,3 @@ 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"