rag-core-api 3.2.0__py3-none-any.whl

rag_core_api/api_endpoints/chat.py

@@ -0,0 +1,28 @@
+"""Module for base class of chat endpoint."""
+
+from abc import ABC, abstractmethod
+
+from rag_core_api.models.chat_request import ChatRequest
+from rag_core_api.models.chat_response import ChatResponse
+
+
+class Chat(ABC):
+    """Base class for chat endpoint."""
+
+    @abstractmethod
+    async def achat(self, session_id: str, chat_request: ChatRequest) -> ChatResponse:
+        """
+        Abstract method to handle asynchronous chat requests.
+
+        Parameters
+        ----------
+        session_id : str
+            The unique identifier for the chat session.
+        chat_request : ChatRequest
+            The request object containing the chat details.
+
+        Returns
+        -------
+        ChatResponse
+            The response object containing the chat results.
+        """

rag_core_api/api_endpoints/information_piece_remover.py

@@ -0,0 +1,27 @@
+"""Module for the InformationPieceRemover abstract base class."""
+
+from abc import ABC, abstractmethod
+
+from rag_core_api.models.delete_request import DeleteRequest
+
+
+class InformationPieceRemover(ABC):
+    """Abstract base class for removing information pieces.
+
+    This class defines the interface for removing information pieces based on a given delete request.
+    """
+
+    @abstractmethod
+    def remove_information_piece(self, delete_request: DeleteRequest) -> None:
+        """
+        Remove information pieces based on the given delete request.
+
+        Parameters
+        ----------
+        delete_request : DeleteRequest
+            The request object containing the details of the information pieces to be deleted.
+
+        Returns
+        -------
+        None
+        """

rag_core_api/api_endpoints/information_piece_uploader.py

@@ -0,0 +1,27 @@
+"""Module for the InformationPiecesUploader abstract base class."""
+
+from abc import ABC, abstractmethod
+
+from rag_core_api.models.information_piece import InformationPiece
+
+
+class InformationPiecesUploader(ABC):
+    """Abstract base class for uploading information pieces.
+
+    This class defines the interface for uploading a list of information pieces.
+    """
+
+    @abstractmethod
+    def upload_information_piece(self, information_piece: list[InformationPiece]) -> None:
+        """
+        Abstract method to upload a list of information pieces.
+
+        Parameters
+        ----------
+        information_piece : list[InformationPiece]
+            A list of InformationPiece objects to be uploaded.
+
+        Returns
+        -------
+        None
+        """

rag_core_api/apis/rag_api.py

@@ -0,0 +1,195 @@
+"""Module containing the RAG API endpoints."""
+
+# coding: utf-8
+# flake8: noqa: D105
+
+import importlib
+import logging
+import pkgutil
+from asyncio import FIRST_COMPLETED, CancelledError, create_task, sleep, wait
+from contextlib import suppress
+from typing import Any, Awaitable, List  # noqa: F401
+
+from fastapi import (  # noqa: F401
+    APIRouter,
+    BackgroundTasks,
+    Body,
+    Cookie,
+    Depends,
+    Form,
+    Header,
+    HTTPException,
+    Path,
+    Query,
+    Request,
+    Response,
+    Security,
+    status,
+)
+
+import rag_core_api.impl
+from rag_core_api.apis.rag_api_base import BaseRagApi
+from rag_core_api.models.chat_request import ChatRequest
+from rag_core_api.models.chat_response import ChatResponse
+from rag_core_api.models.delete_request import DeleteRequest
+from rag_core_api.models.information_piece import InformationPiece
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+ns_pkg = rag_core_api.impl
+for _, name, _ in pkgutil.iter_modules(ns_pkg.__path__, ns_pkg.__name__ + "."):
+    importlib.import_module(name)
+
+
+async def _disconnected(request: Request) -> None:
+    while True:
+        try:
+            if await request.is_disconnected():
+                break
+            await sleep(1.0)
+        except CancelledError:
+            break
+
+
+@router.post(
+    "/chat/{session_id}",
+    responses={
+        200: {"model": ChatResponse, "description": "OK."},
+        500: {"description": "Internal Server Error!"},
+    },
+    tags=["rag"],
+    response_model_by_alias=True,
+)
+async def chat(
+    request: Request,
+    session_id: str = Path(..., description=""),
+    chat_request: ChatRequest = Body(None, description="Chat with RAG."),
+) -> ChatResponse | None:
+    """
+    Asynchronously handles the chat endpoint for the RAG API.
+
+    Parameters
+    ----------
+    request : Request
+        The request object.
+    session_id : str
+        The session ID for the chat.
+    chat_request : ChatRequest, optional
+        The chat request payload
+
+    Returns
+    -------
+    ChatResponse or None
+        The chat response if the chat task completes successfully, otherwise None.
+
+    Raises
+    ------
+    CancelledError
+        If the task is cancelled.
+
+    Notes
+    -----
+    This function creates two asynchronous tasks: one for handling disconnection and one for processing the chat
+    request. It waits for either task to complete first and cancels the remaining tasks.
+    """
+    disconnect_task = create_task(_disconnected(request))
+    chat_task = create_task(BaseRagApi.subclasses[0]().chat(session_id, chat_request))
+    done, pending = await wait(
+        [disconnect_task, chat_task],
+        return_when=FIRST_COMPLETED,
+    )
+
+    # cancel all remaining tasks
+    for task in pending:
+        task.cancel()
+        with suppress(CancelledError):
+            await task
+    if chat_task in done:
+        return chat_task.result()
+    logger.info("Request got cancelled!")
+    return None
+
+
+@router.post(
+    "/evaluate",
+    responses={
+        201: {"description": "Accepted."},
+        500: {"description": "Internal Server Error."},
+    },
+    tags=["rag"],
+    response_model_by_alias=True,
+)
+async def evaluate() -> None:
+    """
+    Asynchronously evaluate the RAG.
+
+    Returns
+    -------
+    None
+    """
+    return await BaseRagApi.subclasses[0]().evaluate()
+
+
+@router.post(
+    "/information_pieces/remove",
+    responses={
+        202: {"description": "Accepted."},
+        404: {"description": "Ressource not Found"},
+        422: {"description": "ID or metadata missing."},
+        500: {"description": "Internal Server Error."},
+    },
+    tags=["rag"],
+    summary="remove information piece",
+    response_model_by_alias=True,
+)
+async def remove_information_piece(
+    delete_request: DeleteRequest = Body(None, description=""),
+) -> None:
+    """
+    Asynchronously removes information pieces.
+
+    This endpoint removes information pieces based on the provided delete request.
+
+    Parameters
+    ----------
+    delete_request : DeleteRequest
+        The request body containing the details for the information piece to be removed.
+
+    Returns
+    -------
+    None
+    """
+    return await BaseRagApi.subclasses[0]().remove_information_piece(delete_request)
+
+
+@router.post(
+    "/information_pieces/upload",
+    responses={
+        201: {"description": "The file was successful uploaded."},
+        422: {"model": str, "description": "Wrong json format."},
+        500: {"model": str, "description": "Internal Server Error."},
+    },
+    tags=["rag"],
+    summary="Upload information pieces for vectordatabase",
+    response_model_by_alias=True,
+)
+async def upload_information_piece(
+    information_piece: List[InformationPiece] = Body(None, description=""),
+) -> None:
+    """
+    Asynchronously uploads information pieces for vectordatabase.
+
+    This endpoint allows for the upload of information pieces to the vector database.
+
+    Parameters
+    ----------
+    information_piece : List[InformationPiece]
+        A list of information pieces to be uploaded (default None).
+
+    Returns
+    -------
+    None
+    """
+    return await BaseRagApi.subclasses[0]().upload_information_piece(information_piece)

rag_core_api/apis/rag_api_base.py

@@ -0,0 +1,102 @@
+"""Module containing the base RAG API class."""
+
+# coding: utf-8
+# flake8: noqa: D105
+
+from typing import ClassVar, Dict, List, Tuple  # noqa: F401
+
+from rag_core_api.models.chat_request import ChatRequest
+from rag_core_api.models.chat_response import ChatResponse
+from rag_core_api.models.delete_request import DeleteRequest
+from rag_core_api.models.information_piece import InformationPiece
+
+
+class BaseRagApi:
+    """Base class for RAG API.
+
+    This class serves as the base for the RAG API implementations. It provides
+    asynchronous methods for handling chat, evaluating the RAG, removing information
+    pieces, and uploading information pieces to a vector database.
+
+    Attributes
+    subclasses : ClassVar[Tuple]
+        A tuple that holds all subclasses of BaseRagApi.
+    """
+
+    subclasses: ClassVar[Tuple] = ()
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        BaseRagApi.subclasses = BaseRagApi.subclasses + (cls,)
+
+    async def chat(
+        self,
+        session_id: str,
+        chat_request: ChatRequest,
+    ) -> ChatResponse:
+        """
+        Asynchronously handles the chat endpoint for the RAG API.
+
+        Parameters
+        ----------
+        request : Request
+            The request object.
+        session_id : str
+            The session ID for the chat.
+        chat_request : ChatRequest, optional
+            The chat request payload
+
+        Returns
+        -------
+        ChatResponse or None
+            The chat response if the chat task completes successfully, otherwise None.
+        """
+
+    async def evaluate(
+        self,
+    ) -> None:
+        """
+        Asynchronously evaluate the RAG.
+
+        Returns
+        -------
+        None
+        """
+
+    async def remove_information_piece(
+        self,
+        delete_request: DeleteRequest,
+    ) -> None:
+        """
+        Asynchronously removes information pieces.
+
+        This endpoint removes information pieces based on the provided delete request.
+
+        Parameters
+        ----------
+        delete_request : DeleteRequest
+            The request body containing the details for the information piece to be removed.
+
+        Returns
+        -------
+        None
+        """
+
+    async def upload_information_piece(
+        self,
+        information_piece: List[InformationPiece],
+    ) -> None:
+        """
+        Asynchronously uploads information pieces for vectordatabase.
+
+        This endpoint allows for the upload of information pieces to the vector database.
+
+        Parameters
+        ----------
+        information_piece : List[InformationPiece]
+            A list of information pieces to be uploaded (default None).
+
+        Returns
+        -------
+        None
+        """

rag_core_api/dependency_container.py

@@ -0,0 +1,274 @@
+"""Module containing the dependency injection container for managing application dependencies."""
+
+import qdrant_client
+from dependency_injector.containers import DeclarativeContainer
+from dependency_injector.providers import (  # noqa: WOT001
+    Configuration,
+    List,
+    Selector,
+    Singleton,
+)
+from langchain_community.document_compressors.flashrank_rerank import FlashrankRerank
+from langchain_community.embeddings.ollama import OllamaEmbeddings
+from langchain_ollama import ChatOllama
+from langchain_openai import ChatOpenAI
+from langchain_qdrant import QdrantVectorStore, FastEmbedSparse
+from langfuse import Langfuse
+
+from rag_core_api.impl.answer_generation_chains.answer_generation_chain import (
+    AnswerGenerationChain,
+)
+from rag_core_api.impl.answer_generation_chains.rephrasing_chain import RephrasingChain
+from rag_core_api.impl.answer_generation_chains.language_detection_chain import LanguageDetectionChain
+from rag_core_api.impl.api_endpoints.default_chat import DefaultChat
+from rag_core_api.impl.api_endpoints.default_information_pieces_remover import (
+    DefaultInformationPiecesRemover,
+)
+from rag_core_api.impl.api_endpoints.default_information_pieces_uploader import (
+    DefaultInformationPiecesUploader,
+)
+from rag_core_api.impl.embeddings.langchain_community_embedder import (
+    LangchainCommunityEmbedder,
+)
+
+
+from rag_core_api.impl.embeddings.stackit_embedder import StackitEmbedder
+from rag_core_api.impl.evaluator.langfuse_ragas_evaluator import LangfuseRagasEvaluator
+from rag_core_api.impl.graph.chat_graph import DefaultChatGraph
+from rag_core_api.impl.reranking.flashrank_reranker import FlashrankReranker
+from rag_core_api.impl.retriever.composite_retriever import CompositeRetriever
+from rag_core_api.impl.retriever.retriever_quark import RetrieverQuark
+from rag_core_api.impl.settings.chat_history_settings import ChatHistorySettings
+from rag_core_api.impl.settings.embedder_class_type_settings import (
+    EmbedderClassTypeSettings,
+)
+from rag_core_api.impl.settings.error_messages import ErrorMessages
+from rag_core_api.impl.settings.ollama_embedder_settings import OllamaEmbedderSettings
+from rag_core_api.impl.settings.ragas_settings import RagasSettings
+from rag_core_api.impl.settings.reranker_settings import RerankerSettings
+from rag_core_api.impl.settings.retriever_settings import RetrieverSettings
+from rag_core_api.impl.settings.sparse_embedder_settings import SparseEmbedderSettings
+from rag_core_api.impl.settings.stackit_embedder_settings import StackitEmbedderSettings
+from rag_core_api.impl.settings.vector_db_settings import VectorDatabaseSettings
+from rag_core_api.impl.vector_databases.qdrant_database import QdrantDatabase
+from rag_core_api.mapper.information_piece_mapper import InformationPieceMapper
+from rag_core_api.prompt_templates.answer_generation_prompt import (
+    ANSWER_GENERATION_PROMPT,
+)
+from rag_core_api.prompt_templates.question_rephrasing_prompt import (
+    QUESTION_REPHRASING_PROMPT,
+)
+from rag_core_api.prompt_templates.language_detection_prompt import LANGUAGE_DETECTION_PROMPT
+from rag_core_lib.impl.data_types.content_type import ContentType
+from rag_core_lib.impl.langfuse_manager.langfuse_manager import LangfuseManager
+from rag_core_lib.impl.llms.llm_factory import chat_model_provider
+from rag_core_lib.impl.settings.langfuse_settings import LangfuseSettings
+from rag_core_lib.impl.settings.ollama_llm_settings import OllamaSettings
+from rag_core_lib.impl.settings.rag_class_types_settings import RAGClassTypeSettings
+from rag_core_lib.impl.settings.retry_decorator_settings import RetryDecoratorSettings
+from rag_core_lib.impl.settings.stackit_vllm_settings import StackitVllmSettings
+from rag_core_lib.impl.tracers.langfuse_traced_runnable import LangfuseTracedRunnable
+from rag_core_lib.impl.utils.async_threadsafe_semaphore import AsyncThreadsafeSemaphore
+
+
+class DependencyContainer(DeclarativeContainer):
+    """Dependency injection container for managing application dependencies."""
+
+    class_selector_config = Configuration()
+    chat_history_config = Configuration()
+
+    # Settings
+    vector_database_settings = VectorDatabaseSettings()
+    retriever_settings = RetrieverSettings()
+    ollama_settings = OllamaSettings()
+    ollama_embedder_settings = OllamaEmbedderSettings()
+    langfuse_settings = LangfuseSettings()
+    stackit_vllm_settings = StackitVllmSettings()
+    error_messages = ErrorMessages()
+    rag_class_type_settings = RAGClassTypeSettings()
+    ragas_settings = RagasSettings()
+    reranker_settings = RerankerSettings()
+    embedder_class_type_settings = EmbedderClassTypeSettings()
+    stackit_embedder_settings = StackitEmbedderSettings()
+    chat_history_settings = ChatHistorySettings()
+    sparse_embedder_settings = SparseEmbedderSettings()
+    retry_decorator_settings = RetryDecoratorSettings()
+    chat_history_config.from_dict(chat_history_settings.model_dump())
+
+    class_selector_config.from_dict(rag_class_type_settings.model_dump() | embedder_class_type_settings.model_dump())
+
+    embedder = Selector(
+        class_selector_config.embedder_type,
+        ollama=Singleton(
+            LangchainCommunityEmbedder, embedder=Singleton(OllamaEmbeddings, **ollama_embedder_settings.model_dump())
+        ),
+        stackit=Singleton(StackitEmbedder, stackit_embedder_settings, retry_decorator_settings),
+    )
+
+    sparse_embedder = Singleton(FastEmbedSparse, **sparse_embedder_settings.model_dump())
+
+    vectordb_client = Singleton(
+        qdrant_client.QdrantClient,
+        location=vector_database_settings.location,
+    )
+
+    vectorstore = Singleton(
+        QdrantVectorStore,
+        client=vectordb_client,
+        collection_name=vector_database_settings.collection_name,
+        embedding=embedder,
+        sparse_embedding=sparse_embedder,
+        validate_collection_config=False,
+        retrieval_mode=vector_database_settings.retrieval_mode,
+    )
+
+    vector_database = Singleton(
+        QdrantDatabase,
+        settings=vector_database_settings,
+        embedder=embedder,
+        sparse_embedder=sparse_embedder,
+        vectorstore=vectorstore,
+    )
+
+    flashrank_reranker = Singleton(FlashrankRerank, top_n=reranker_settings.k_documents)
+    reranker = Singleton(FlashrankReranker, flashrank_reranker)
+
+    information_pieces_uploader = Singleton(DefaultInformationPiecesUploader, vector_database)
+
+    information_pieces_remover = Singleton(DefaultInformationPiecesRemover, vector_database)
+
+    image_retriever = Singleton(
+        RetrieverQuark,
+        vector_database,
+        ContentType.IMAGE,
+        retriever_settings.image_k_documents,
+        retriever_settings.image_threshold,
+    )
+    table_retriever = Singleton(
+        RetrieverQuark,
+        vector_database,
+        ContentType.TABLE,
+        retriever_settings.table_k_documents,
+        retriever_settings.table_threshold,
+    )
+    text_retriever = Singleton(
+        RetrieverQuark,
+        vector_database,
+        ContentType.TEXT,
+        retriever_settings.k_documents,
+        retriever_settings.threshold,
+    )
+    summary_retriever = Singleton(
+        RetrieverQuark,
+        vector_database,
+        ContentType.SUMMARY,
+        retriever_settings.summary_k_documents,
+        retriever_settings.summary_threshold,
+    )
+
+    composed_retriever = Singleton(
+        CompositeRetriever,
+        List(image_retriever, table_retriever, text_retriever, summary_retriever),
+        reranker,
+    )
+
+    information_piece_mapper = Singleton(InformationPieceMapper)
+
+    large_language_model = Selector(
+        class_selector_config.llm_type,
+        ollama=Singleton(chat_model_provider, ollama_settings, "ollama"),
+        stackit=Singleton(chat_model_provider, stackit_vllm_settings, "openai"),
+    )
+
+    prompt = ANSWER_GENERATION_PROMPT
+    rephrasing_prompt = QUESTION_REPHRASING_PROMPT
+    language_detection_prompt = LANGUAGE_DETECTION_PROMPT
+
+    langfuse = Singleton(
+        Langfuse,
+        public_key=langfuse_settings.public_key,
+        secret_key=langfuse_settings.secret_key,
+        host=langfuse_settings.host,
+    )
+
+    langfuse_manager = Singleton(
+        LangfuseManager,
+        langfuse=langfuse,
+        managed_prompts={
+            AnswerGenerationChain.__name__: prompt,
+            RephrasingChain.__name__: rephrasing_prompt,
+            LanguageDetectionChain.__name__: language_detection_prompt,
+        },
+        llm=large_language_model,
+    )
+
+    answer_generation_chain = Singleton(
+        AnswerGenerationChain,
+        langfuse_manager=langfuse_manager,
+    )
+
+    rephrasing_chain = Singleton(
+        RephrasingChain,
+        langfuse_manager=langfuse_manager,
+    )
+
+    language_detection_chain = Singleton(
+        LanguageDetectionChain,
+        langfuse_manager=langfuse_manager,
+    )
+
+    chat_graph = Singleton(
+        DefaultChatGraph,
+        composed_retriever=composed_retriever,
+        rephrasing_chain=rephrasing_chain,
+        language_detection_chain=language_detection_chain,
+        mapper=information_piece_mapper,
+        answer_generation_chain=answer_generation_chain,
+        error_messages=error_messages,
+        chat_history_settings=chat_history_settings,
+    )
+
+    # wrap graph in tracer
+    traced_chat_graph = Singleton(
+        LangfuseTracedRunnable,
+        inner_chain=chat_graph,
+        settings=langfuse_settings,
+    )
+
+    chat_endpoint = Singleton(DefaultChat, traced_chat_graph)
+
+    ragas_llm = (
+        Singleton(
+            ChatOpenAI,
+            model=ragas_settings.model,
+            timeout=ragas_settings.timeout,
+            api_key=ragas_settings.openai_api_key,
+        )
+        if ragas_settings.use_openai
+        else Selector(
+            class_selector_config.llm_type,
+            stackit=Singleton(
+                ChatOpenAI,
+                model=ragas_settings.model if ragas_settings.model else stackit_vllm_settings.model,
+                timeout=ragas_settings.timeout,
+                openai_api_base=stackit_vllm_settings.base_url,
+                openai_api_key=stackit_vllm_settings.api_key,
+            ),
+            ollama=Singleton(
+                ChatOllama,
+                model=ragas_settings.model if ragas_settings.model else ollama_settings.model,
+                base_url=ollama_settings.base_url,
+            ),
+        )
+    )
+
+    evaluator = Singleton(
+        LangfuseRagasEvaluator,
+        chat_endpoint=chat_endpoint,
+        settings=ragas_settings,
+        langfuse_manager=langfuse_manager,
+        embedder=embedder,
+        semaphore=Singleton(AsyncThreadsafeSemaphore, ragas_settings.max_concurrency),
+        chat_history_config=chat_history_config,
+        chat_llm=ragas_llm,
+    )

rag_core_api/embeddings/embedder.py

@@ -0,0 +1,5 @@
+"""Backward-compatible re-export for the Embedder base class."""
+
+from rag_core_lib.impl.embeddings.embedder import Embedder
+
+__all__ = ["Embedder"]

rag_core_api/evaluator/evaluator.py

@@ -0,0 +1,11 @@
+"""Module for the Evaluator class."""
+
+from abc import ABC, abstractmethod
+
+
+class Evaluator(ABC):
+    """Evaluator is responsible for evaluating questions in a dataset using various metrics."""
+
+    @abstractmethod
+    async def aevaluate() -> None:
+        """Asynchronously evaluates the questions in the evaluation dataset."""