Multi vector db merge in one LCEL

[choiwb]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

def retriever_alog(new_docsearch):
    retriever = new_docsearch.as_retriever(
                                        search_type=db_search_type,         
                                        search_kwargs={'k': db_doc_k, 'fetch_k': db_doc_fetch_k}
                                    )
    embeddings_filter = EmbeddingsFilter(embeddings=embeddings, similarity_threshold=db_similarity_threshold) 
    compression_retriever = ContextualCompressionRetriever(
        base_compressor=embeddings_filter, base_retriever=retriever
    )
    return compression_retriever


db_name_1 = "soc_2024.db" 
db_name_2 = "hea_2024.db"
db_name_3 = "pub_2024.db"

db_1 = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": os.path.join(db_save_path, db_name_1)},
    collection_name="LangChainCollection",
    drop_old=False,  # Drop the old Milvus collection if it exists
        )

db_2 = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": os.path.join(db_save_path, db_name_2)},
    collection_name="LangChainCollection",
    drop_old=False,  # Drop the old Milvus collection if it exists
        )

db_3 = Milvus(
    embedding_function=embeddings,
    connection_args={"uri": os.path.join(db_save_path, db_name_3)},
    collection_name="LangChainCollection",
    drop_old=False,  # Drop the old Milvus collection if it exists
        )

retriever_1 = retriever_alog(db_1)
retriever_2 = retriever_alog(db_2)
retriever_3 = retriever_alog(db_3)

retrieved_document_1 = {
    "question": lambda x: x["question"],
    "source_documents": itemgetter("question") | retriever_1,
    "chat_history": lambda x: get_buffer_string(x["chat_history"])
    }

retrieved_document_2 = {
    "question": lambda x: x["question"],
    "source_documents": itemgetter("question") | retriever_2,
    "chat_history": lambda x: get_buffer_string(x["chat_history"])
    }

retrieved_document_3 = {
    "question": lambda x: x["question"],
    "source_documents": itemgetter("question") | retriever_3,
    "chat_history": lambda x: get_buffer_string(x["chat_history"])
    }

retrieval_qa_chain_1 = asa_loaded_memory | retrieved_document_1 |  (lambda x: src_doc.src_doc(x)) | final_inputs | QA_CHAIN_PROMPT | sonnet_llm | StrOutputParser()
retrieval_qa_chain_2 = asa_loaded_memory | retrieved_document_3 |  (lambda x: src_doc.src_doc(x)) | final_inputs | QA_CHAIN_PROMPT | sonnet_llm | StrOutputParser()
retrieval_qa_chain_3 = asa_loaded_memory | retrieved_document_3 |  (lambda x: src_doc.src_doc(x)) | final_inputs | QA_CHAIN_PROMPT | sonnet_llm | StrOutputParser()

Description

how to "retrieved_document_1 ", "retrieved_document_2", "retrieved_document_3" integreation of retrieval_qa_chain???
I want to parallel process of retrieved_document_1 ,2,3

System Info

.

[dosubot[bot]]

To integrate retrieved_document_1, retrieved_document_2, and retrieved_document_3 into the retrieval QA chains and process them in parallel, you can use the MultiRetrievalQAChain class. Here is how you can do it:

1. Define the retriever information for each document.
2. Create an instance of MultiRetrievalQAChain using the from_retrievers class method.

Here is an example code snippet to achieve this:

from langchain_core.language_models import BaseLanguageModel
from langchain_core.prompts import PromptTemplate
from langchain_core.retrievers import BaseRetriever
from langchain.chains.router.llm_router import LLMRouterChain
from langchain.chains.retrieval_qa.base import RetrievalQA
from langchain.chains.router.multi_retrieval_qa import MultiRetrievalQAChain

# Define your language model
llm = BaseLanguageModel()  # Replace with your actual language model

# Define retriever information for each document
retriever_infos = [
    {
        "name": "retrieved_document_1",
        "description": "Description for document 1",
        "retriever": retriever_1,  # Use your actual retriever for document 1
        "prompt": PromptTemplate(template="Your prompt for document 1", input_variables=["input"])
    },
    {
        "name": "retrieved_document_2",
        "description": "Description for document 2",
        "retriever": retriever_2,  # Use your actual retriever for document 2
        "prompt": PromptTemplate(template="Your prompt for document 2", input_variables=["input"])
    },
    {
        "name": "retrieved_document_3",
        "description": "Description for document 3",
        "retriever": retriever_3,  # Use your actual retriever for document 3
        "prompt": PromptTemplate(template="Your prompt for document 3", input_variables=["input"])
    }
]

# Create the MultiRetrievalQAChain
multi_retrieval_qa_chain = MultiRetrievalQAChain.from_retrievers(
    llm=llm,
    retriever_infos=retriever_infos
)

# Now you can use multi_retrieval_qa_chain to process inputs
result = multi_retrieval_qa_chain({"input": "Your query"})
print(result)

This code sets up the MultiRetrievalQAChain with the specified retrievers and prompts for each document, allowing you to process queries in parallel ^[1].

To continue talking to Dosu, mention @dosu.