rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/core/http_interpreter.py

@@ -0,0 +1,89 @@
+import aiohttp
+
+import copy
+import logging
+import structlog
+
+from typing import Text, Dict, Any, Optional
+
+from rasa.core import constants
+from rasa.core.channels import UserMessage
+from rasa.shared.nlu.constants import INTENT_NAME_KEY
+from rasa.utils.endpoints import EndpointConfig
+
+logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
+
+
+class RasaNLUHttpInterpreter:
+    """Allows for an HTTP endpoint to be used to parse messages."""
+
+    def __init__(self, endpoint_config: Optional[EndpointConfig] = None) -> None:
+        """Initializes a `RasaNLUHttpInterpreter`."""
+        self.session = aiohttp.ClientSession()
+        if endpoint_config:
+            self.endpoint_config = endpoint_config
+        else:
+            self.endpoint_config = EndpointConfig(constants.DEFAULT_SERVER_URL)
+
+    async def parse(self, message: UserMessage) -> Dict[Text, Any]:
+        """Parse a text message.
+
+        Return a default value if the parsing of the text failed.
+        """
+        default_return = {
+            "intent": {INTENT_NAME_KEY: "", "confidence": 0.0},
+            "entities": [],
+            "text": "",
+        }
+
+        result = await self._rasa_http_parse(message.text, message.sender_id)
+        return result if result is not None else default_return
+
+    async def _rasa_http_parse(
+        self, text: Text, message_id: Optional[Text] = None
+    ) -> Optional[Dict[Text, Any]]:
+        """Send a text message to a running rasa NLU http server.
+
+        Return `None` on failure.
+        """
+        if not self.endpoint_config or self.endpoint_config.url is None:
+            structlogger.error(
+                "http.parse.text",
+                text=copy.deepcopy(text),
+                event_info="No rasa NLU server specified!",
+            )
+            return None
+
+        params = {
+            "token": self.endpoint_config.token,
+            "text": text,
+            "message_id": message_id,
+        }
+
+        if self.endpoint_config.url.endswith("/"):
+            url = self.endpoint_config.url + "model/parse"
+        else:
+            url = self.endpoint_config.url + "/model/parse"
+
+        # noinspection PyBroadException
+        try:
+            async with self.session.post(url, json=params) as resp:
+                if resp.status == 200:
+                    return await resp.json()
+                else:
+                    response_text = await resp.text()
+                    structlogger.error(
+                        "http.parse.text.failure",
+                        text=copy.deepcopy(text),
+                        response_text=copy.deepcopy(response_text),
+                    )
+                    return None
+        except Exception:  # skipcq: PYL-W0703
+            # need to catch all possible exceptions when doing http requests
+            # (timeouts, value errors, parser errors, ...)
+            structlogger.exception(
+                "http.parse.text.exception",
+                text=copy.deepcopy(text),
+            )
+            return None

rasa/core/information_retrieval/__init__.py

@@ -0,0 +1,7 @@
+from rasa.core.information_retrieval.information_retrieval import (  # noqa: F401
+    InformationRetrieval,
+    SearchResult,
+    SearchResultList,
+    InformationRetrievalException,
+    create_from_endpoint_config,
+)

rasa/core/information_retrieval/faiss.py

@@ -0,0 +1,124 @@
+from pathlib import Path
+from typing import TYPE_CHECKING, List, Optional, Text, Any, Dict
+
+import structlog
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders.text import TextLoader
+from langchain_community.document_loaders.directory import DirectoryLoader
+from langchain_community.vectorstores.faiss import FAISS
+from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.information_retrieval import (
+    SearchResultList,
+    InformationRetrieval,
+    InformationRetrievalException,
+)
+from rasa.utils.ml_utils import persist_faiss_vector_store
+
+if TYPE_CHECKING:
+    from langchain.schema import Document
+    from langchain.schema.embeddings import Embeddings
+
+logger = structlog.get_logger()
+
+
+class FAISS_Store(InformationRetrieval):
+    """FAISS Store implementation."""
+
+    def __init__(
+        self,
+        embeddings: "Embeddings",
+        index_path: str,
+        docs_folder: Optional[str],
+        create_index: Optional[bool] = False,
+    ):
+        """Initializes the FAISS Store."""
+        self.chunk_size = 1000
+        self.chunk_overlap = 20
+
+        path = Path(index_path) / "documents_faiss"
+        if create_index:
+            logger.info(
+                "information_retrieval.faiss_store.create_index", path=path.absolute()
+            )
+            self.index = self._create_document_index(docs_folder, embeddings)
+            self._persist(path)
+        else:
+            logger.info(
+                "information_retrieval.faiss_store.load_index", path=path.absolute()
+            )
+            self.index = FAISS.load_local(
+                str(path), embeddings, allow_dangerous_deserialization=True
+            )
+
+    @staticmethod
+    def load_documents(docs_folder: str) -> List["Document"]:
+        """Loads documents from a given folder.
+
+        Args:
+            docs_folder: The folder containing the documents.
+
+        Returns:
+            the list of documents
+        """
+        logger.info(
+            "information_retrieval.faiss_store.load_documents",
+            docs_folder=Path(docs_folder).absolute(),
+        )
+        loader = DirectoryLoader(
+            docs_folder, glob="**/*.txt", loader_cls=TextLoader, show_progress=True
+        )
+
+        return loader.load()
+
+    def _create_document_index(
+        self, docs_folder: Optional[str], embedding: "Embeddings"
+    ) -> FAISS:
+        """Creates a document index from the documents in the given folder.
+
+        Args:
+            docs_folder: The folder containing the documents.
+            embedding: The embedding to use.
+
+        Returns:
+            The document index.
+        """
+        if not docs_folder:
+            raise ValueError("parameter `docs_folder` needs to be specified")
+
+        docs = self.load_documents(docs_folder)
+        splitter = RecursiveCharacterTextSplitter(
+            chunk_size=self.chunk_size,
+            chunk_overlap=self.chunk_overlap,
+            length_function=len,
+        )
+        doc_chunks = splitter.split_documents(docs)
+
+        logger.info(
+            "information_retrieval.faiss_store._create_document_index",
+            len_chunks=len(doc_chunks),
+        )
+        if doc_chunks:
+            texts = [chunk.page_content for chunk in doc_chunks]
+            metadatas = [chunk.metadata for chunk in doc_chunks]
+            return FAISS.from_texts(texts, embedding, metadatas=metadatas, ids=None)
+        else:
+            raise ValueError(f"No documents found at '{docs_folder}'.")
+
+    def _persist(self, path: Path) -> None:
+        persist_faiss_vector_store(path, self.index)
+
+    def connect(self, config: EndpointConfig) -> None:
+        """Faiss does not need to connect to a server."""
+        pass
+
+    async def search(
+        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
+    ) -> SearchResultList:
+        logger.debug("information_retrieval.faiss_store.search", query=query)
+        try:
+            documents = await self.index.as_retriever().ainvoke(query)
+        except Exception as exc:
+            raise InformationRetrievalException from exc
+
+        return SearchResultList.from_document_list(documents)

rasa/core/information_retrieval/information_retrieval.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, Text, Any, Optional
+
+import structlog
+
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+import importlib
+
+if TYPE_CHECKING:
+    from langchain.schema import Document
+    from langchain.schema.embeddings import Embeddings
+
+
+logger = structlog.get_logger()
+
+
+@dataclass
+class SearchResult:
+    """A search result object.
+
+    Attributes:
+        text: The text content of the retrieved document result.
+        metadata: The metadata associated with the document result.
+        score: The score of the search result.
+    """
+
+    text: str
+    metadata: dict
+    score: Optional[float] = None
+
+    @classmethod
+    def from_document(cls, document: Document) -> "SearchResult":
+        """Construct a SearchResult object from Langchain Document object."""
+        return cls(text=document.page_content, metadata=document.metadata)
+
+
+@dataclass
+class SearchResultList:
+    results: List[SearchResult]
+    metadata: dict
+
+    @classmethod
+    def from_document_list(cls, documents: List["Document"]) -> "SearchResultList":
+        """
+        Convert a list of Langchain Documents to a SearchResultList object.
+
+        Args:
+            documents: List of Langchain Documents.
+
+        Returns:
+            SearchResultList object.
+        """
+        return cls(
+            results=[SearchResult.from_document(doc) for doc in documents],
+            metadata={"total_results": len(documents)},
+        )
+
+
+class InformationRetrievalException(RasaException):
+    """Base class for exceptions raised by InformationRetrieval operations."""
+
+    def __init__(self) -> None:
+        self.base_message = "An error occurred while searching for documents: "
+
+    def __str__(self) -> str:
+        return self.base_message + f"{self.__cause__}"
+
+
+class InformationRetrieval:
+    """Base class for any InformationRetrieval implementation."""
+
+    def __init__(self, embeddings: "Embeddings") -> None:
+        self.embeddings = embeddings
+
+    def connect(
+        self,
+        config: EndpointConfig,
+    ) -> None:
+        """Connect to the InformationRetrieval system."""
+        raise NotImplementedError(
+            "InformationRetrieval must implement the `connect` method."
+        )
+
+    async def search(
+        self,
+        query: Text,
+        tracker_state: dict[str, Any],
+        threshold: float = 0.0,
+    ) -> SearchResultList:
+        """Search for a document in the InformationRetrieval system."""
+        raise NotImplementedError(
+            "InformationRetrieval must implement the `search` method."
+        )
+
+
+def create_from_endpoint_config(
+    config_type: Text,
+    embeddings: "Embeddings",
+) -> InformationRetrieval:
+    """Instantiate a vector store based on its configuration."""
+    logger.debug(
+        "information_retrieval.create_from_endpoint_config", config_type=config_type
+    )
+    if config_type == "milvus":
+        from rasa.core.information_retrieval.milvus import Milvus_Store
+
+        return Milvus_Store(embeddings=embeddings)
+    elif config_type == "qdrant":
+        from rasa.core.information_retrieval.qdrant import Qdrant_Store
+
+        return Qdrant_Store(embeddings=embeddings)
+    else:
+        # Import the module dynamically
+        try:
+            module_name, class_name = config_type.rsplit(".", 1)
+            module = importlib.import_module(module_name)
+        except ValueError:
+            logger.error(
+                "information_retrieval.create_from_endpoint_config.invalid_config",
+                config_type=config_type,
+            )
+            raise ValueError(
+                f"Invalid configuration for vector store: '{config_type}'. "
+                f"Expected a module path and a class name separated by a dot."
+            )
+        except ModuleNotFoundError:
+            logger.error(
+                "information_retrieval.create_from_endpoint_config.unknown_type",
+                config_type=config_type,
+            )
+            raise ImportError(f"Cannot retrieve class from path {config_type}.")
+
+        external_class = getattr(module, class_name)
+        return external_class(embeddings=embeddings)

rasa/core/information_retrieval/milvus.py

@@ -0,0 +1,59 @@
+from typing import Text, Any, Dict
+
+import structlog
+from langchain_community.vectorstores.milvus import Milvus
+from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.information_retrieval import (
+    SearchResultList,
+    InformationRetrieval,
+    InformationRetrievalException,
+)
+
+logger = structlog.get_logger()
+
+
+class Milvus_Store(InformationRetrieval):
+    """Milvus Store implementation."""
+
+    def connect(self, config: EndpointConfig) -> None:
+        """Connect to the Milvus system."""
+        params = config.kwargs
+        self.client = Milvus(
+            self.embeddings,
+            connection_args={
+                "host": str(params.get("host")),
+                "port": str(params.get("port")),
+                "user": str(params.get("user")),
+                "password": str(params.get("password")),
+            },
+            collection_name=str(params.get("collection")),
+        )
+
+    async def search(
+        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
+    ) -> SearchResultList:
+        """Search for documents in the Milvus store.
+
+        Args:
+            query: The query to search for.
+            threshold: minimum similarity score to consider a document a match.
+
+        Returns:
+        A list of documents that match the query.
+        """
+        logger.debug("information_retrieval.milvus_store.search", query=query)
+        try:
+            hits = await self.client.asimilarity_search_with_score(query, k=4)
+        except Exception as exc:
+            raise InformationRetrievalException from exc
+
+        scores = [score for _, score in hits]
+        logger.debug(
+            "information_retrieval.milvus_store.search_results_before_threshold",
+            scores=scores,
+        )
+        # Milvus uses Euclidean distance metric by default
+        # so the lower the score, the better the match.
+        filtered_hits = [doc for doc, score in hits if score <= threshold]
+        return SearchResultList.from_document_list(filtered_hits)

rasa/core/information_retrieval/qdrant.py

@@ -0,0 +1,96 @@
+from typing import Text, Any, Dict
+
+import structlog
+from langchain_community.vectorstores.qdrant import Qdrant
+from pydantic import ValidationError
+from qdrant_client import QdrantClient
+from rasa.utils.endpoints import EndpointConfig
+
+from rasa.core.information_retrieval import (
+    SearchResultList,
+    InformationRetrieval,
+    InformationRetrievalException,
+)
+
+logger = structlog.get_logger()
+
+
+class PayloadNotFoundException(InformationRetrievalException):
+    """Exception raised for errors in missing payloads."""
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__()
+
+    def __str__(self) -> str:
+        return self.base_message + self.message + f"{self.__cause__}"
+
+
+class QdrantInformationRetrievalException(InformationRetrievalException):
+    """Exception raised for errors in the Qdrant vector store."""
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__()
+
+    def __str__(self) -> str:
+        return self.base_message + self.message + f"{self.__cause__}"
+
+
+class Qdrant_Store(InformationRetrieval):
+    def connect(
+        self,
+        config: EndpointConfig,
+    ) -> None:
+        """Connect to the Qdrant system."""
+        params = config.kwargs
+        self.client = Qdrant(
+            client=QdrantClient(
+                location=params.get("location"),
+                url=params.get("url"),
+                port=int(params.get("port", 6333)),
+                grpc_port=int(params.get("grpc_port", 6334)),
+                prefer_grpc=bool(params.get("prefer_grpc", False)),
+                https=bool(params.get("https")),
+                api_key=params.get("api_key"),
+                prefix=params.get("prefix"),
+                timeout=int(params.get("timeout", 5)),
+                host=params.get("host"),
+                path=params.get("path"),
+            ),
+            collection_name=str(params.get("collection")),
+            embeddings=self.embeddings,
+            content_payload_key=params.get("content_payload_key", "text"),
+            metadata_payload_key=params.get("metadata_payload_key", "metadata"),
+            vector_name=params.get("vector_name", None),
+        )
+
+    async def search(
+        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
+    ) -> SearchResultList:
+        """Search for a document in the Qdrant vector store.
+
+        Args:
+            query: The query to search for.
+            threshold: minimum similarity score to consider a document a match.
+
+        Returns:
+        A list of documents that match the query.
+        """
+        logger.debug("information_retrieval.qdrant_store.search", query=query)
+        try:
+            hits = await self.client.asimilarity_search(
+                query, k=4, score_threshold=threshold
+            )
+        except ValidationError as e:
+            raise PayloadNotFoundException(
+                "Payload not found in the Qdrant response. Please make sure "
+                "the `content_payload_key`and `metadata_payload_key` are correct in "
+                f"the Qdrant configuration. Error: {e}"
+                ""
+            ) from e
+        except Exception as e:
+            raise QdrantInformationRetrievalException(
+                f"Failed to search the Qdrant vector store. Encountered error: {e}"
+            ) from e
+        return SearchResultList.from_document_list(hits)

rasa/core/jobs.py

@@ -0,0 +1,63 @@
+import asyncio
+import logging
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from pytz import UnknownTimeZoneError, utc
+import rasa.shared.utils.io
+
+__scheduler = None
+
+logger = logging.getLogger(__name__)
+
+
+async def scheduler() -> AsyncIOScheduler:
+    """Thread global scheduler to handle all recurring tasks.
+
+    If no scheduler exists yet, this will instantiate one.
+    """
+    global __scheduler
+
+    if not __scheduler:
+        try:
+            __scheduler = AsyncIOScheduler(event_loop=asyncio.get_event_loop())
+            __scheduler.start()
+            return __scheduler
+        except UnknownTimeZoneError:
+            rasa.shared.utils.io.raise_warning(
+                "apscheduler could not find a timezone and is "
+                "defaulting to utc. This is probably because "
+                "your system timezone is not set. "
+                'Set it with e.g. echo "Europe/Berlin" > '
+                "/etc/timezone"
+            )
+            __scheduler = AsyncIOScheduler(
+                event_loop=asyncio.get_event_loop(), timezone=utc
+            )
+            __scheduler.start()
+            return __scheduler
+    else:
+        # scheduler already created, make sure it is running on
+        # the correct loop
+        # noinspection PyProtectedMember
+        if not __scheduler._eventloop == asyncio.get_event_loop():
+            raise RuntimeError(
+                "Detected inconsistent loop usage. "
+                "Trying to schedule a task on a new event "
+                "loop, but scheduler was created with a "
+                "different event loop. Make sure there "
+                "is only one event loop in use and that the "
+                "scheduler is running on that one."
+            )
+        return __scheduler
+
+
+def kill_scheduler() -> None:
+    """Terminate the scheduler if started.
+
+    Another call to `scheduler` will create a new scheduler.
+    """
+    global __scheduler
+
+    if __scheduler:
+        __scheduler.shutdown()
+        __scheduler = None