get_relavant_docs with metadata parameter is not working as expected

[dheekshayogananda]

Issue you'd like to raise.

I am trying to fetch relavant topics based on the metadata "country". The documents i am passing as this metadata in this particular format: Document(page_content=".........", metadata={''Country': 'Ireland'})]..... and so on now i want to filter retrived content based on the Country , How can pass the metadata to the get_relavant_docs function along with the query to get the correct content. Or is there any way to using the metadata parameter while intializing the retriver.

Retriever i am trying to use in Parent Document Retriever (Note: I do not want to use Self Query Retriever) , chroma as my vector DB.

Could you please help me on how to use the metadata parameter to get the correct filtered relavant docs

Suggestion:

No response

[dosubot[bot]]

🤖

Hello @dheekshayogananda,

I'm here to assist you with your query on the LangChain framework.

To filter retrieved content based on the 'Country' metadata in the Parent Document Retriever with Chroma as your vector DB, you can modify the where_filter parameter in the get_relevant_documents function.

Here is an example of how you can do this:

where_filter = {"path": ["Country"], "operator": "Equal", "valueString": "USA"}

output = retriever.get_relevant_documents("foo", where_filter=where_filter)

In this example, the where_filter is set to filter documents where the 'Country' metadata is equal to 'USA'. You can replace 'USA' with the country you want to filter by.

Please note that this assumes that your documents have a 'Country' metadata field. If they don't, you will need to add this field to your documents before you can filter by it.

You can find more details about this in the LangChain codebase, specifically in the libs/langchain/tests/integration_tests/retrievers/test_weaviate_hybrid_search.py file.

I hope this helps! If you have any more questions or need further clarification, feel free to ask.

Best, Dosu

Sources

• libs/langchain/tests/integration_tests/retrievers/test_weaviate_hybrid_search.py
• libs/langchain/langchain/retrievers/elastic_search_bm25.py
• libs/langchain/langchain/retrievers/kendra.py
• libs/langchain/langchain/retrievers/chaindesk.py
• libs/langchain/langchain/retrievers/chatgpt_plugin_retriever.py
• libs/langchain/langchain/retrievers/time_weighted_retriever.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[dheekshayogananda]

@dosu-bot I still see ireland data coming up when i try to filter country = "Canada"

code snippet used: where_filter = {"path": ["Country"], "operator": "Equal", "valueString": "Canada"}

parent_retriever.get_relevant_documents("what is happening in canada?",where_filter=where_filter) These are my metadata field in my docs along with the page content {'source': '....', 'row': 0, 'Country': 'Canada', 'ProductName': '.....', 'DoseForm': '......', 'SubVariant': '.......', 'Size': '......'}

[dosubot[bot]]

🤖

Based on the information provided, it seems like you're trying to filter the documents based on the 'Country' metadata using the 'where_filter' parameter in the 'get_relevant_documents' method. However, you're still seeing data from Ireland even though you're trying to filter for 'Country' equal to "Canada".

From the context provided, it appears that the LangChain framework handles metadata filtering in the 'get_relevant_documents' method through the 'attribute_filter' parameter of the 'AmazonKendraRetriever' class. This parameter is a dictionary that specifies additional filtering of results based on metadata. When the '_kendra_query' method is called within 'get_relevant_documents', it checks if 'attribute_filter' is not None. If it's not, it includes 'AttributeFilter' in the arguments for the Kendra query.

However, it's not clear how the 'where_filter' parameter you're using is handled in the 'get_relevant_documents' method or how it interacts with the Chroma vector DB. It's also not clear if the 'where_filter' parameter is equivalent to the 'attribute_filter' parameter mentioned in the context.

To better understand why you're seeing data from Ireland, we need to understand how the 'where_filter' parameter is handled in the 'get_relevant_documents' method and how it interacts with the Chroma vector DB. Unfortunately, I wasn't able to find this information in the repository.

Could you please provide more information about how the 'where_filter' parameter is supposed to work in the 'get_relevant_documents' method and how it interacts with the Chroma vector DB? This information would be very helpful in diagnosing the issue.

Sources

• libs/langchain/langchain/retrievers/kendra.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[dheekshayogananda]

@dosu-bot i see there is metadata parameter in get_relavant documents and it is not working properly

[dosubot[bot]]

🤖

Based on the information provided, it seems like the where_filter parameter is not being used in the _get_relevant_documents method of the TavilySearchAPIRetriever class. The method sends a search request to the Tavily API with the query and other parameters set in the class, but it doesn't seem to include the where_filter parameter in the request.

The where_filter parameter is typically used to filter the documents based on certain metadata fields. However, in the current implementation of the get_relevant_documents method, it doesn't seem to be used.

Here is the part of the code where the search request is sent to the Tavily API:

response = tavily.search(
    query=query,
    max_results=max_results,
    search_depth=self.search_depth.value,
    include_answer=self.include_generated_answer,
    include_domains=self.include_domains,
    exclude_domains=self.exclude_domains,
    include_raw_content=self.include_raw_content,
    include_images=self.include_images,
    **self.kwargs
)

As you can see, the where_filter parameter is not included in the parameters of the search method.

This could be the reason why you are seeing data from Ireland in the results, despite setting the where_filter to filter for 'Country' equal to "Canada".

To resolve this issue, you might need to modify the get_relevant_documents method to include the where_filter parameter in the search request to the Tavily API. However, this would require changes to the LangChain framework code, which might not be feasible if you are using a pre-compiled version of the framework.

Alternatively, you could apply the filter to the results returned by the get_relevant_documents method. Here is an example of how you could do this:

docs = parent_retriever.get_relevant_documents("what is happening in canada?")
filtered_docs = [doc for doc in docs if doc.metadata.get('Country') == 'Canada']

In this code, filtered_docs will contain only the documents where the 'Country' metadata is equal to "Canada".

I hope this helps! If you have any other questions, feel free to ask.

Sources

• libs/langchain/langchain/retrievers/elastic_search_bm25.py
• libs/langchain/langchain/retrievers/kendra.py
• libs/langchain/langchain/retrievers/cohere_rag_retriever.py
• libs/langchain/langchain/retrievers/chatgpt_plugin_retriever.py
• libs/langchain/langchain/retrievers/tavily_search_api.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[dheekshayogananda]

Thanks @dosu-bot Now , can i pass this to filtered_docs as my context when trying to query it qa = RetrievalQA.from_chain_type( llm=llm, chain_type="map_reduce", # TODO: Test out- stuff, refine, map-reduce, map-rerank retriever=parent_retriever, return_source_documents=True, )

now while querying i need to pass the filtered docs as a context to the Retrieval QA , How can that be done?

[dosubot[bot]]

🤖

Based on the context you've provided, you can pass the filtered_docs as a context to the RetrievalQA class by creating a custom class that inherits from RetrievalQA and overrides the _get_docs method. This method is responsible for retrieving the documents that will be used for question answering. Here is an example of how you can do this:

from langchain.chains.retrieval_qa import RetrievalQA
from langchain.schema.retriever import Document
from langchain.schema.callback_manager import CallbackManagerForChainRun
from typing import List

class CustomRetrievalQA(RetrievalQA):
    def _get_docs(
        self,
        question: str,
        *,
        run_manager: CallbackManagerForChainRun,
    ) -> List[Document]:
        """Get docs."""
        # Assuming filtered_docs is a list of Document objects
        return filtered_docs

In this example, CustomRetrievalQA is a new class that inherits from RetrievalQA. The _get_docs method is overridden to return filtered_docs instead of retrieving documents from the retriever.

Please note that filtered_docs should be a list of Document objects. If it's not, you'll need to convert it to the correct format before returning it.

You can then use this custom class in your code like this:

qa = CustomRetrievalQA.from_chain_type(
    llm=llm,
    chain_type="map_reduce",
    retriever=parent_retriever,
    return_source_documents=True,
)

This solution is based on the structure and purpose of the RetrievalQA class in the LangChain framework, which is designed to retrieve relevant documents based on a given question and then generate an answer from those documents. The _get_docs method in this class is responsible for retrieving the documents, so by overriding this method, you can control which documents are used for question answering.

For more information, you can refer to the RetrievalQA class in the LangChain framework here.

Sources

• How to create a custom retriever
• libs/langchain/langchain/chains/retrieval_qa/base.py
• docs/extras/use_cases/question_answering/how_to/document-context-aware-QA.ipynb
• docs/docs/use_cases/question_answering/document-context-aware-QA.ipynb
• libs/langchain/langchain/chains/retrieval_qa/init.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[dheekshayogananda]

@dosu-bot. Is there any way in which the filter can be applied before the get_relavant_docs? I mean the docs are first filtered on country first and then get_relavant_docs are fetched from the filtered docs. Basically i feel this will be ideal solution.

[dosubot[bot]]

🤖

Based on the context provided, it seems like you're trying to filter documents based on the 'Country' metadata before calling the get_relevant_docs method. However, the get_relevant_docs method in the LangChain framework doesn't directly support this kind of filtering.

To achieve this, you would need to modify the _get_relevant_documents method in the LangChain framework. Here's an example of how you can modify the method to include a filter for the 'Country' metadata:

def _get_relevant_documents(
        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
    ) -> List[Document]:
        query_dict = {
            "query": {
                "bool": {
                    "must": {
                        "match": {"content": query}
                    },
                    "filter": {
                        "term": {"Country": "Canada"}
                    }
                }
            }
        }
        res = self.client.search(index=self.index_name, body=query_dict)

        docs = []
        for r in res["hits"]["hits"]:
            docs.append(Document(page_content=r["_source"]["content"]))
        return docs

This modification uses the bool query in Elasticsearch, which allows you to combine multiple query clauses. The must clause ensures that the documents must match these conditions, and the filter clause filters the documents without affecting the score.

Please note that this assumes that your documents have a 'Country' field. If the field name is different, you should replace "Country" with the correct field name. Also, Elasticsearch is case-sensitive, so make sure the country name "Canada" matches exactly with the data in your documents.

This modification should allow you to filter documents based on the 'Country' metadata before calling the get_relevant_docs method. However, please be aware that modifying the LangChain framework code could have other implications, and it's recommended to thoroughly test your application after making these changes.

I hope this helps! If you have any other questions or need further clarification, feel free to ask.

Sources

• libs/langchain/langchain/retrievers/elastic_search_bm25.py
• libs/langchain/langchain/retrievers/kendra.py
• libs/langchain/langchain/retrievers/chaindesk.py
• libs/langchain/langchain/retrievers/chatgpt_plugin_retriever.py
• libs/experimental/langchain_experimental/retrievers/vector_sql_database.py

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[dheekshayogananda]

@dasu-bot

how can use the metadata optional parameter while initializing the retriever?

the original documentation says param metadata: Optional[Dict[str, Any]] = None¶ Optional metadata associated with the retriever. Defaults to None This metadata will be associated with each call to this retriever, and passed as arguments to the handlers defined in callbacks. You can use these to eg identify a specific instance of a retriever with its use case.

i wanted to know how can we pass this metadata while initializing the retriver like below: parent_retriever = ParentDocumentRetriever( vectorstore=vectorstore, docstore=store, child_splitter=child_splitter )

[dosubot[bot]]

🤖

@baskaryan, I could use your expertise on this one, it seems to be a bit tricky.

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[dosubot[bot]]

Hi, @dheekshayogananda

I'm helping the LangChain team manage their backlog and am marking this issue as stale. The issue you raised is about the get_relavant_docs function not working as expected when using the metadata parameter to filter relevant documents based on the "Country" metadata. There was some discussion about using the where_filter parameter and potential modifications to the LangChain framework code to address the issue. However, it seems that the issue remains unresolved.

Could you please confirm if this issue is still relevant to the latest version of the LangChain repository? If it is, kindly let the LangChain team know by commenting on the issue. Otherwise, feel free to close the issue yourself, or it will be automatically closed in 7 days.

Thank you for your understanding and cooperation.