qa_interface & knowledge_brain_qa

[ghostcyber11]

Hello,
I am trying to understand each function and class but knowledge_brain_qa & qa_interface functions don't exist in master. Could you please explain why these functions were removed ?

[dosubot[bot]]

Hey @ghostcyber11! I'm here to help you out with any bugs, questions, or contributions you have. Let's tackle this together!

The knowledge_brain_qa and qa_interface functionalities were removed and replaced with more integrated and flexible solutions. Specifically:

1. KnowledgeBrainQA:

   • This class was used to handle chat interactions for the "doc" brain type, generating answers based on document-based knowledge.

2. ChatInterface:

   • This interface served as a base for creating chat-related functionalities. The BrainfulChat class extended ChatInterface and implemented methods to return appropriate answer generators based on the brain type.

These functionalities have been replaced by new classes and methods that provide more comprehensive and context-aware responses:

• CompositeBrainQA: Extends KnowledgeBrainQA and integrates functionalities from APIBrainQA and HeadlessQA based on the brain type.
• BigBrain: Integrates advanced conversational retrieval and language model chains.
• MultiContractBrain: Similar to BigBrain, it provides comprehensive and context-aware responses by leveraging document retrieval, question condensation, and document-based question answering.

These changes ensure a more integrated and flexible approach to handling different types of knowledge sources in the chat system ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[ghostcyber11]

Thank you for your response but as you can see below there is still KnowledgeBrainQA function evenif it was removed
`import json
from typing import AsyncIterable
from uuid import UUID

from langchain.chains import ConversationalRetrievalChain, LLMChain
from langchain.chains.question_answering import load_qa_chain
from langchain_community.chat_models import ChatLiteLLM
from langchain_core.prompts.chat import (
ChatPromptTemplate,
HumanMessagePromptTemplate,
SystemMessagePromptTemplate,
)
from langchain_core.prompts.prompt import PromptTemplate
from quivr_api.logger import get_logger
from quivr_api.modules.brain.knowledge_brain_qa import KnowledgeBrainQA
from quivr_api.modules.chat.dto.chats import ChatQuestion

logger = get_logger(name)

class BigBrain(KnowledgeBrainQA):
"""
The BigBrain class integrates advanced conversational retrieval and language model chains
to provide comprehensive and context-aware responses to user queries.

It leverages a combination of document retrieval, question condensation, and document-based
question answering to generate responses that are informed by a wide range of knowledge sources.
"""

def __init__(
    self,
    **kwargs,
):
    """
    Initializes the BigBrain class with specific configurations.

    Args:
        **kwargs: Arbitrary keyword arguments.
    """
    super().__init__(
        **kwargs,
    )

def get_chain(self):
    """
    Constructs and returns the conversational QA chain used by BigBrain.

    Returns:
        A ConversationalRetrievalChain instance.
    """
    system_template = """Combine these summaries in a way that makes sense and answer the user's question.
    Use markdown or any other techniques to display the content in a nice and aerated way. Answer in the language of the question.
    Here are user instructions on how to respond: {custom_personality}
    ______________________
    {summaries}"""
    messages = [
        SystemMessagePromptTemplate.from_template(system_template),
        HumanMessagePromptTemplate.from_template("{question}"),
    ]
    CHAT_COMBINE_PROMPT = ChatPromptTemplate.from_messages(messages)

    ### Question prompt
    question_prompt_template = """Use the following portion of a long document to see if any of the text is relevant to answer the question. 
    Return any relevant text verbatim. Return the answer in the same language as the question. If the answer is not in the text, just say nothing in the same language as the question.
    {context}
    Question: {question}
    Relevant text, if any, else say Nothing:"""
    QUESTION_PROMPT = PromptTemplate(
        template=question_prompt_template, input_variables=["context", "question"]
    )

    ### Condense Question Prompt

    _template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question in exactly the same language as the original question.

    Chat History:
    {chat_history}
    Follow Up Input: {question}
    Standalone question in same language as question:"""
    CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)

    api_base = None
    if self.brain_settings.ollama_api_base_url and self.model.startswith("ollama"):
        api_base = self.brain_settings.ollama_api_base_url

    llm = ChatLiteLLM(
        temperature=0,
        model=self.model,
        api_base=api_base,
        max_tokens=self.max_tokens,
    )

    retriever_doc = self.knowledge_qa.get_retriever()

    question_generator = LLMChain(llm=llm, prompt=CONDENSE_QUESTION_PROMPT)
    doc_chain = load_qa_chain(
        llm,
        chain_type="map_reduce",
        question_prompt=QUESTION_PROMPT,
        combine_prompt=CHAT_COMBINE_PROMPT,
    )

    chain = ConversationalRetrievalChain(
        retriever=retriever_doc,
        question_generator=question_generator,
        combine_docs_chain=doc_chain,
    )

    return chain

async def generate_stream(
    self, chat_id: UUID, question: ChatQuestion, save_answer: bool = True
) -> AsyncIterable:
    """
    Generates a stream of responses for a given question in real-time.

    Args:
        chat_id (UUID): The unique identifier for the chat session.
        question (ChatQuestion): The question object containing the user's query.
        save_answer (bool): Flag indicating whether to save the answer to the chat history.

    Returns:
        An asynchronous iterable of response strings.
    """
    conversational_qa_chain = self.get_chain()
    transformed_history, streamed_chat_history = (
        self.initialize_streamed_chat_history(chat_id, question)
    )
    response_tokens = []

    async for chunk in conversational_qa_chain.astream(
        {
            "question": question.question,
            "chat_history": transformed_history,
            "custom_personality": (
                self.prompt_to_use.content if self.prompt_to_use else None
            ),
        }
    ):
        if "answer" in chunk:
            response_tokens.append(chunk["answer"])
            streamed_chat_history.assistant = chunk["answer"]
            yield f"data: {json.dumps(streamed_chat_history.dict())}"

    self.save_answer(question, response_tokens, streamed_chat_history, save_answer)

`