I want to obtain answers from specific documents based on the input question instead of searching through all the documents in the vector store.

[trepont]

My requirement is to retrieve answers from specific documents in the vector store based on an input question, rather than searching through all the documents. To achieve this, I will pass two parameters as input: the question itself and a filter. The filter will determine which specific document in the vector store the question should check. Below is a code sample for clarification:

import os

from langchain import HuggingFaceHub
from langchain.retrievers import SelfQueryRetriever

os.environ["OPENAI_API_KEY"] = "API_KEY"
os.environ["HUGGINGFACEHUB_API_TOKEN"] = "API_TOKEN"
os.environ["OPENWEATHERMAP_API_KEY"] = "API_KEY"

from langchain.embeddings import HuggingFaceInstructEmbeddings
from langchain.vectorstores import FAISS,Milvus
from langchain.chains import ConversationalRetrievalChain
from langchain.memory import ConversationBufferMemory
from langchain.vectorstores import pinecone
from langchain.llms import OpenAI

embeddings = None # Global variable for embeddings
docsearch = None # Global variable for docsearc

def load_embeddings():
global embeddings
if embeddings is None:
embeddings = HuggingFaceInstructEmbeddings(
query_instruction="Represent the query for retrieval: "
)

@st.cache_resource

def prep_qa_langchain(truck_model, metadata_field_info=None, document_content_description=None):
# Making the embeddings
# Load up the FAISS index
global docsearch
print(truck_model)
if truck_model is Not None:
docsearch = FAISS.load_local("faiss_index", embeddings)

# Retrieval QA LangChain chain
repo_id = "tiiuae/falcon-7b-instruct"  # See https://huggingface.co/models?pipeline_tag=text-generation&sort=downloads for some other options

doc=docsearch.getattribute('dict')

#for d in doc:
 #  print(d.metadata)
llm = OpenAI(model_name='text-davinci-003')
#llm = HuggingFaceHub(repo_id=repo_id, model_kwargs={"max_new_tokens": 150}) #"max_new_tokens": 250

# set up FAISS as a generic retriever
# doc=docsearch.similarity_search("", k=2)

doc = docsearch.similarity_search("")

#for d in doc:
 #   print(d.metadata)
"""retriever = SelfQueryRetriever.from_llm(
    llm,
    docsearch,
    document_content_description,
    metadata_field_info,
    enable_limit=True,
    verbose=True
)"""
#retriever.get_relevant_documents("I want to watch a movie rated higher than 8.5")
retriever = docsearch.as_retriever(search_type="similarity", search_kwargs={"k": 4})

memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# create the chain to answer questions
truck_manual_rqa = ConversationalRetrievalChain.from_llm(llm=llm,
                                                       chain_type="stuff",
                                                       retriever=retriever,
                                                       memory=memory,
                                                       return_source_documents=True)

"""tools = [
    Tool(
        name="Chrysler Car Manual",
        func=truck_manual_rqa.run,
        description="useful for when you need to answer specific questions about a car owner's vehicle. Input should be a fully formed question.",
    )
]
agent = initialize_agent(
    tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)"""

def run_conversational_chain(question):

    # Additional processing based on the extra parameter
    # ...

    # Call the run() method on the chain with the question

return truck_manual_rqa.run(question)

return run_conversational_chain

return truck_manual_rqa

[guidorietbroek]

Did you categorize with namespaces?

[trepont]

Indeed, I have categorized the data based on car models. In this setup, I have created distinct collections for each model and load data accordingly when the input model is provided. However, encountering a query that involves two models makes it challenging to load indexes for both models simultaneously. As a result, I am seeking a solution to efficiently search content within specific documents, apply metadata filters, and then transmit this information through a chain-like process.

[guidorietbroek]

Did you test with metadata? Because what I believe this is the new way of namespaces. Reading the docs on Pinecone metadata does influence performance but I don’t think it will have noticeable effect when the only extra metadata is a car model.