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

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/shared/core/constants.py

@@ -52,8 +52,6 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
-ACTION_BLOCK_DIGRESSION = "action_block_digression"
-ACTION_CONTINUE_DIGRESSION = "action_continue_digression"
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
@@ -84,8 +82,6 @@ DEFAULT_ACTION_NAMES = [
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
-    ACTION_BLOCK_DIGRESSION,
-    ACTION_CONTINUE_DIGRESSION,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -205,8 +201,4 @@ CLASSIFIER_NAME_FALLBACK = "FallbackClassifier"
 
 POLICIES_THAT_EXTRACT_ENTITIES = {"TEDPolicy"}
 
-# digression constants
-KEY_ASK_CONFIRM_DIGRESSIONS = "ask_confirm_digressions"
-KEY_BLOCK_DIGRESSIONS = "block_digressions"
-
 ERROR_CODE_KEY = "error_code"

rasa/shared/core/domain.py

@@ -1678,6 +1678,14 @@ class Domain:
         """Write domain to a file."""
         as_yaml = self.as_yaml()
         rasa.shared.utils.io.write_text_file(as_yaml, filename)
+        # run the check again on the written domain to catch any errors
+        # that may have been missed in the user defined domain files
+        structlogger.info(
+            "domain.persist.domain_written_to_file",
+            event_info="The entire domain content has been written to file.",
+            filename=filename,
+        )
+        Domain.is_domain_file(filename)
 
     def as_yaml(self) -> Text:
         """Dump the `Domain` object as a YAML string.
@@ -1972,17 +1980,18 @@ class Domain:
 
         try:
             content = read_yaml_file(filename, expand_env_vars=cls.expand_env_vars)
-        except (RasaException, YamlSyntaxException):
-            structlogger.warning(
+        except (RasaException, YamlSyntaxException) as error:
+            structlogger.error(
                 "domain.cannot_load_domain_file",
                 file=filename,
+                error=error,
                 event_info=(
                     f"The file {filename} could not be loaded as domain file. "
                     f"You can use https://yamlchecker.com/ to validate "
                     f"the YAML syntax of your file."
                 ),
             )
-            return False
+            raise RasaException(f"Domain could not be loaded: {error}")
 
         return any(key in content for key in ALL_DOMAIN_KEYS)
 

rasa/shared/core/flows/flow.py

@@ -13,10 +13,6 @@ from pypred import Predicate
 import rasa.shared.utils.io
 from rasa.engine.language import Language
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.constants import (
-    KEY_ASK_CONFIRM_DIGRESSIONS,
-    KEY_BLOCK_DIGRESSIONS,
-)
 from rasa.shared.core.flows.constants import (
     KEY_ALWAYS_INCLUDE_IN_PROMPT,
     KEY_DESCRIPTION,
@@ -52,7 +48,6 @@ from rasa.shared.core.flows.steps.constants import (
     START_STEP,
 )
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
-from rasa.shared.core.flows.utils import extract_digression_prop
 from rasa.shared.core.slots import Slot
 
 structlogger = structlog.get_logger()
@@ -94,10 +89,6 @@ class Flow:
     """The path to the file where the flow is stored."""
     persisted_slots: List[str] = field(default_factory=list)
     """The list of slots that should be persisted after the flow ends."""
-    ask_confirm_digressions: List[str] = field(default_factory=list)
-    """The flow ids for which the assistant should ask for confirmation."""
-    block_digressions: List[str] = field(default_factory=list)
-    """The flow ids that the assistant should block from digressing to."""
     run_pattern_completed: bool = True
     """Whether the pattern_completed flow should be run after the flow ends."""
 
@@ -138,10 +129,6 @@ class Flow:
             # data. When the model is trained, take the provided file_path.
             file_path=data.get(KEY_FILE_PATH) if KEY_FILE_PATH in data else file_path,
             persisted_slots=data.get(KEY_PERSISTED_SLOTS, []),
-            ask_confirm_digressions=extract_digression_prop(
-                KEY_ASK_CONFIRM_DIGRESSIONS, data
-            ),
-            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
             run_pattern_completed=data.get(KEY_RUN_PATTERN_COMPLETED, True),
             translation=extract_translations(
                 translation_data=data.get(KEY_TRANSLATION, {})
@@ -220,10 +207,6 @@ class Flow:
             data[KEY_FILE_PATH] = self.file_path
         if self.persisted_slots:
             data[KEY_PERSISTED_SLOTS] = self.persisted_slots
-        if self.ask_confirm_digressions:
-            data[KEY_ASK_CONFIRM_DIGRESSIONS] = self.ask_confirm_digressions
-        if self.block_digressions:
-            data[KEY_BLOCK_DIGRESSIONS] = self.block_digressions
         if self.run_pattern_completed is not None:
             data["run_pattern_completed"] = self.run_pattern_completed
         if self.translation:

rasa/shared/core/flows/flows_yaml_schema.json

@@ -217,15 +217,12 @@
                             "reset_after_flow_ends": {
                                 "type": "boolean"
                             },
-                            "ask_confirm_digressions": {
-                                "$ref": "#/$defs/ask_confirm_digressions"
-                            },
-                            "block_digressions": {
-                                "$ref": "#/$defs/block_digressions"
-                            },
                             "utter": {
                                 "type": "string"
                             },
+                            "force_slot_filling": {
+                                "type": "boolean"
+                            },
                             "rejections": {
                                 "type": "array",
                                 "schema_name": "list of rejections",
@@ -253,32 +250,6 @@
                 }
             }
         },
-        "ask_confirm_digressions": {
-            "oneOf": [
-                {
-                    "type": "boolean"
-                },
-                {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    }
-                }
-            ]
-        },
-        "block_digressions": {
-            "oneOf": [
-                {
-                    "type": "boolean"
-                },
-                {
-                    "type": "array",
-                    "items": {
-                        "type": "string"
-                    }
-                }
-            ]
-        },
         "flow": {
             "required": [
                 "steps",
@@ -340,12 +311,6 @@
                 "persisted_slots": {
                     "$ref": "#/$defs/persisted_slots"
                 },
-                "ask_confirm_digressions": {
-                    "$ref": "#/$defs/ask_confirm_digressions"
-                },
-                "block_digressions": {
-                    "$ref": "#/$defs/block_digressions"
-                },
                 "run_pattern_completed": {
                     "type": "boolean"
                 }

rasa/shared/core/flows/steps/collect.py

@@ -1,15 +1,10 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any, Dict, List, Set, Text
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
-from rasa.shared.core.constants import (
-    KEY_ASK_CONFIRM_DIGRESSIONS,
-    KEY_BLOCK_DIGRESSIONS,
-)
 from rasa.shared.core.flows.flow_step import FlowStep
-from rasa.shared.core.flows.utils import extract_digression_prop
 from rasa.shared.core.slots import SlotRejection
 
 
@@ -29,10 +24,8 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to always ask the question even if the slot is already filled."""
     reset_after_flow_ends: bool = True
     """Whether to reset the slot value at the end of the flow."""
-    ask_confirm_digressions: List[str] = field(default_factory=list)
-    """The flow id digressions for which the assistant should ask for confirmation."""
-    block_digressions: List[str] = field(default_factory=list)
-    """The flow id digressions that should be blocked during the flow step."""
+    force_slot_filling: bool = False
+    """Whether to keep only the SetSlot command for the collected slot."""
 
     @classmethod
     def from_json(
@@ -60,10 +53,7 @@ class CollectInformationFlowStep(FlowStep):
                 SlotRejection.from_dict(rejection)
                 for rejection in data.get("rejections", [])
             ],
-            ask_confirm_digressions=extract_digression_prop(
-                KEY_ASK_CONFIRM_DIGRESSIONS, data
-            ),
-            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
+            force_slot_filling=data.get("force_slot_filling", False),
             **base.__dict__,
         )
 
@@ -79,10 +69,7 @@ class CollectInformationFlowStep(FlowStep):
         data["ask_before_filling"] = self.ask_before_filling
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
-        data["ask_confirm_digressions"] = self.ask_confirm_digressions
-        data["block_digressions"] = (
-            self.block_digressions if self.block_digressions else False
-        )
+        data["force_slot_filling"] = self.force_slot_filling
 
         return data
 

rasa/shared/core/flows/utils.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Set, Text
+from typing import TYPE_CHECKING, Any, Dict, Set, Text
 
 from rasa.shared.utils.io import raise_deprecation_warning
 
@@ -8,7 +8,6 @@ if TYPE_CHECKING:
 
 RESET_PROPERTY_NAME = "reset_after_flow_ends"
 PERSIST_PROPERTY_NAME = "persisted_slots"
-ALL_LABEL = "ALL"
 
 
 def warn_deprecated_collect_step_config() -> None:
@@ -45,20 +44,6 @@ def get_invalid_slot_persistence_config_error_message(
     )
 
 
-def extract_digression_prop(prop: str, data: Dict[str, Any]) -> List[str]:
-    """Extracts the digression property from the data.
-
-    There can be two types of properties: ask_confirm_digressions and
-    block_digressions.
-    """
-    digression_property = data.get(prop, [])
-
-    if isinstance(digression_property, bool):
-        digression_property = [ALL_LABEL] if digression_property else []
-
-    return digression_property
-
-
 def extract_translations(
     translation_data: Dict[Text, Any],
 ) -> Dict[Text, "FlowLanguageTranslation"]:

rasa/shared/core/slot_mappings.py

@@ -648,12 +648,14 @@ class SlotFillingManager:
         output_channel: "OutputChannel",
         nlg: "NaturalLanguageGenerator",
         recreate_tracker: bool = False,
+        slot_events: Optional[List[Event]] = None,
     ) -> List[Event]:
         from rasa.core.actions.action import RemoteAction
         from rasa.shared.core.trackers import DialogueStateTracker
         from rasa.utils.endpoints import ClientResponseError
 
-        slot_events: List[Event] = []
+        validated_slot_events: List[Event] = []
+        slot_events = slot_events if slot_events is not None else []
         remote_action = RemoteAction(custom_action, self._action_endpoint)
         disallowed_types = set()
 
@@ -673,9 +675,9 @@ class SlotFillingManager:
             )
             for event in custom_events:
                 if isinstance(event, SlotSet):
-                    slot_events.append(event)
+                    validated_slot_events.append(event)
                 elif isinstance(event, BotUttered):
-                    slot_events.append(event)
+                    validated_slot_events.append(event)
                 else:
                     disallowed_types.add(event.type_name)
         except (RasaException, ClientResponseError) as e:
@@ -699,7 +701,7 @@ class SlotFillingManager:
                 f"updated with this event.",
             )
 
-        return slot_events
+        return validated_slot_events
 
     async def execute_validation_action(
         self,
@@ -722,7 +724,11 @@ class SlotFillingManager:
             return cast(List[Event], slot_events)
 
         validate_events = await self._run_custom_action(
-            ACTION_VALIDATE_SLOT_MAPPINGS, output_channel, nlg, recreate_tracker=True
+            ACTION_VALIDATE_SLOT_MAPPINGS,
+            output_channel,
+            nlg,
+            recreate_tracker=True,
+            slot_events=cast(List[Event], slot_events),
         )
         validated_slot_names = [
             event.key for event in validate_events if isinstance(event, SlotSet)

rasa/shared/nlu/constants.py

@@ -55,4 +55,3 @@ SPLIT_ENTITIES_BY_COMMA_DEFAULT_VALUE = True
 SINGLE_ENTITY_ALLOWED_INTERLEAVING_CHARSET = {".", ",", " ", ";"}
 
 SET_SLOT_COMMAND = "set slot"
-HANDLE_DIGRESSIONS_COMMAND = "handle digressions"

rasa/shared/utils/common.py

@@ -7,7 +7,17 @@ import os
 import pkgutil
 import sys
 from types import ModuleType
-from typing import Any, Callable, Collection, Dict, List, Optional, Sequence, Text, Type
+from typing import (
+    Any,
+    Callable,
+    Collection,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Text,
+    Type,
+)
 
 import rasa.shared.utils.io
 from rasa.exceptions import MissingDependencyException

rasa/shared/utils/llm.py

@@ -762,7 +762,7 @@ def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
     if isinstance(slot, BooleanSlot):
         return str([True, False])
     if isinstance(slot, CategoricalSlot):
-        return str([v for v in slot.values if v != "__other__"])
+        return str([v for v in slot.values if v != "__other__"] + ["other"])
     else:
         return None
 

rasa/tracing/instrumentation/attribute_extractors.py

@@ -326,7 +326,7 @@ def extract_attrs_for_command(
 def extract_llm_config(
     self: Any,
     default_llm_config: Dict[str, Any],
-    default_embeddings_config: Dict[str, Any],
+    default_embeddings_config: Optional[Dict[str, Any]],
 ) -> Dict[str, Any]:
     if isinstance(self, ContextualResponseRephraser):
         # ContextualResponseRephraser is not a graph component, so it's
@@ -346,8 +346,12 @@ def extract_llm_config(
             default_embeddings_config,
         )
     else:
-        embeddings_property = combine_custom_and_default_config(
-            config.get(EMBEDDINGS_CONFIG_KEY), default_embeddings_config
+        embeddings_property = (
+            combine_custom_and_default_config(
+                config.get(EMBEDDINGS_CONFIG_KEY), default_embeddings_config
+            )
+            if default_embeddings_config is not None
+            else {}
         )
 
     attributes = {
@@ -402,7 +406,7 @@ def extract_attrs_for_contextual_response_rephraser(
         self,
         default_llm_config=DEFAULT_LLM_CONFIG,
         # rephraser is not using embeddings
-        default_embeddings_config={},
+        default_embeddings_config=None,
     )
 
     return extend_attributes_with_prompt_tokens_length(self, attributes, prompt)
@@ -418,7 +422,7 @@ def extract_attrs_for_create_history(
         self,
         default_llm_config=DEFAULT_LLM_CONFIG,
         # rephraser is not using embeddings
-        default_embeddings_config={},
+        default_embeddings_config=None,
     )
 
 
@@ -771,14 +775,13 @@ def extract_attrs_for_enterprise_search_generate_llm_answer(
     self: "EnterpriseSearchPolicy", llm: "BaseLLM", prompt: str
 ) -> Dict[str, Any]:
     from rasa.core.policies.enterprise_search_policy import (
-        DEFAULT_EMBEDDINGS_CONFIG,
         DEFAULT_LLM_CONFIG,
     )
 
     attributes = extract_llm_config(
         self,
         default_llm_config=DEFAULT_LLM_CONFIG,
-        default_embeddings_config=DEFAULT_EMBEDDINGS_CONFIG,
+        default_embeddings_config=None,
     )
 
     return extend_attributes_with_prompt_tokens_length(self, attributes, prompt)