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

rasa/document_retrieval/knowledge_base_connectors/api_connector.py

@@ -1,39 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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

@@ -1,234 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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: