Is there a way to set the vectorstore as the docstore when setting up a langchain multivector retriever?

[RRaffay]

This is the code I have right now:

import uuid

vectorstore = Chroma(
        collection_name="summaries",
        embedding_function=OpenAIEmbeddings(),
    )
store = InMemoryStore()
id_key = "doc_id"
retriever = MultiVectorRetriever(
    vectorstore=vectorstore, docstore=store, id_key=id_key, search_kwargs={"k": 5}
)

doc_ids = [str(uuid.uuid4()) for _ in docs]

# Could add the meta-data here for the documents to set up filtering based on the meta-data: what document to retrieve
summary_docs = [
    Document(page_content=s, metadata={id_key: doc_ids[i]})
    for i, s in enumerate(summaries)
]
retriever.vectorstore.add_documents(summary_docs)

# We can also add the original chunks to the vectorstore you should use this instead of the docstore 
for i, doc in enumerate(docs):
    doc.metadata[id_key] = doc_ids[i]
retriever.vectorstore.add_documents(docs)


    llm = ChatOpenAI(
        model_name="gpt-3.5-turbo-16k", temperature=0, openai_api_key=OPENAI_API_KEY
    )

    qa_chain = RetrievalQA.from_chain_type(
        llm=llm,
        chain_type="map_reduce",
        retriever=retriever
    )

Instead of using the

store = InMemoryStore()
id_key = "doc_id"

is there a way to use the vectorstore to retrieve the similar chunk?

When I try to put docstore=vectorstore in the retriever it returns the error

---------------------------------------------------------------------------
ValidationError                           Traceback (most recent call last)
<ipython-input-30-441f19e6a2d8> in <cell line: 9>()
      7 store = InMemoryStore()
      8 id_key = "doc_id"
----> 9 retriever = MultiVectorRetriever(
     10     vectorstore=vectorstore, docstore=vectorstore, id_key=id_key, search_kwargs={"k": 5}
     11 )

1 frames
/usr/local/lib/python3.10/dist-packages/pydantic/main.cpython-310-x86_64-linux-gnu.so in pydantic.main.BaseModel.__init__()

ValidationError: 1 validation error for MultiVectorRetriever
docstore
  instance of BaseStore expected (type=type_error.arbitrary_type; expected_arbitrary_type=BaseStore)

[dosubot[bot]]

🤖

Hello,

Thank you for your question. Unfortunately, there is no direct way to use the vectorstore as the docstore when setting up a MultiVectorRetriever in LangChain. The vectorstore and docstore are two separate components of the MultiVectorRetriever class and are expected to be of different types.

The vectorstore is of type VectorStore, which is used to store small chunks of text and their corresponding embedding vectors. On the other hand, the docstore is of type BaseStore[str, Document], which is the storage layer for the parent documents.

The docstore attribute is used in the _get_relevant_documents method to get the documents corresponding to the ids returned by the vectorstore.similarity_search method. If you try to use docstore=vectorstore in the retriever, it will result in a ValidationError because the vectorstore does not have the mget method that is required by the docstore.

If you want to achieve this functionality, you would need to create a custom class that inherits from BaseStore and implements the mget method using the vectorstore. However, this would require a deep understanding of the LangChain framework and might not be straightforward.

You can refer to the source code of the MultiVectorRetriever class and the BaseStore class for more details:

• libs/langchain/langchain/retrievers/multi_vector.py
• libs/langchain/langchain/schema/base_store.py

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

Best regards.

Sources

• libs/langchain/langchain/retrievers/multi_vector.py
• libs/langchain/langchain/schema/vectorstore.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.

[RRaffay]

@dosu-bot What should I do if I'm trying to build an application where I want to store the actual chunks in the vectorstore and return the relevant chunks from the vectorstore.

[dosubot[bot]]

🤖

Hello,

Based on your requirements, it seems like you're trying to use the vectorstore as a docstore which is causing the ValidationError. This is because the vectorstore and docstore are indeed two separate components of the MultiVectorRetriever class and are expected to be of different types.

However, you can achieve your desired functionality by using the Vectara class in the LangChain Python framework, which is a subclass of VectorStore and provides methods to store and retrieve chunks of data. Here's an example:

from langchain.vectorstores import Vectara

# Initialize Vectara
vectara = Vectara(
    vectara_customer_id="your_customer_id",
    vectara_corpus_id="your_corpus_id",
    vectara_api_key="your_api_key"
)

# Add texts
texts = ["text1", "text2", "text3"]
vectara.add_texts(texts)

# Add files
files = ["file1.txt", "file2.txt", "file3.txt"]
vectara.add_files(files)

# Retrieve similar documents
query = "your_query"
similar_docs = vectara.similarity_search(query)

If you still want to create a custom class that inherits from BaseStore and implements the mget method, you would need to define the mget method in your custom class. The mget method should take a list of keys and return a list of values corresponding to those keys. The implementation of this method would depend on how you want to retrieve the data from the vectorstore.

Here's a basic example of how you might implement this:

from langchain.schema import BaseStore
from typing import List, Optional, Sequence

class CustomStore(BaseStore[str, str]):
    def __init__(self, vectorstore):
        self.vectorstore = vectorstore

    def mget(self, keys: Sequence[str]) -> List[Optional[str]]:
        return [self.vectorstore.get(key) for key in keys]

    # Implement other methods as needed...

In this example, CustomStore is a subclass of BaseStore that uses a vectorstore to implement the mget method. The mget method takes a list of keys and returns a list of values corresponding to those keys by retrieving them from the vectorstore.

Please note that this is a basic example and you might need to adjust it based on your specific requirements and the exact implementation of your vectorstore.

I hope this helps! Let me know if you have any other questions.

Sources

• libs/langchain/langchain/vectorstores/vectara.py
• libs/langchain/langchain/schema/storage.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.

[austinmw]

Are there any other options for Docstore besides InMemory??

[mukeshs-evertz]

I am looking for a similar solution. I have huge amount raw files and then i am processing them into child and parent chunks. Where the child chunk would go to vector store and I need to find a place where i could store parent chunk and the retrieve them.

[ssifood]

i use that code but no working.

add_to_vectorstore.py
retriever = MultiVectorRetriever(
vectorstore=vectorstore,
docstore=CustomStore(vectorstore),
id_key=id_key,

CustomStore.py
class CustomStore(BaseStore[str, str]):
def init(self, vectorstore):
self.vectorstore = vectorstore

def mget(self, keys: Sequence[str]) -> List[Optional[str]]:
    return [self.vectorstore.get(key) for key in keys]

I print function mget process
print is below infromation

input
keys : ['751ce18e-73a8-4282-80e5-d5350b87c348', '1e2fb0da-4ce3-4346-bfa3-a946b3ecc747', 'bb48da68-081a-4b64-a4c8-c90b21599f5a', 'e011ef29-be34-490a-9609-caafc674fb1f']

return
{'ids': [], 'embeddings': None, 'metadatas': [], 'documents': [], 'data': None, 'uris': None}
{'ids': [], 'embeddings': None, 'metadatas': [], 'documents': [], 'data': None, 'uris': None}
{'ids': [], 'embeddings': None, 'metadatas': [], 'documents': [], 'data': None, 'uris': None}
{'ids': [], 'embeddings': None, 'metadatas': [], 'documents': [], 'data': None, 'uris': None}

Question

1. vectortore can get function?
2. why keys(input) not exsits in vectorstore, why return 4?

[ritvikgautaminfy]

For the React Docstore Agent in langchain is there any way to pass you own data(pdf,docx,etc) instead of using Wikipedia as docstore?

[JuliazUnlimited]

The easiest way is to just create your own docstore which has access to a database instead of a local dict.
You can do this by extending the BaseStore class and create a CustomStore class which you can use in your MultiVectorRetriever - or any other retriever.
The method you'll need at first is mget() because that's the one that retrieves the parent documents from the docstore (or database in our case).

Here is an example implementation of a docstore that connects to a Postgres database to retrieve parent documents from a table called "your_table":

from typing import (
	AsyncIterator,
	Iterator,
	List,
	Optional,
	Sequence,
	Tuple,
	TypeVar,
)
from langchain_core.documents import Document
from langchain.schema import BaseStore
from psycopg.rows import dict_row  # Optional: to return rows as dictionaries
# Example implementation of a PostgresStore
from postgres import PostgresStore
V = TypeVar("V")

class CustomStore(BaseStore[str, str]):
	def __init__(self, postgres_store: PostgresStore):
		self.postgres_store = postgres_store

	def mget(self, keys: Sequence[str]) -> List[Optional[str]]:
		"""" This function returns parent documents from a database."""
		try:
			# Create a cursor object
			with self.postgres_store.cursor(row_factory=dict_row) as cursor:  # Optional: Use dict_row to get rows as dictionaries
				# Create the SQL query using the IN clause
				# Generate the placeholders for the number of IDs
				placeholders = ', '.join(['%s'] * len(keys))
				query = f"""
				SELECT xxx
				FROM your_table 
				WHERE doc_id IN ({placeholders})
				ORDER by your_item_index;
				"""
				# Execute the query with the list of IDs
				cursor.execute(query, keys)
				# Fetch all results
				snippets = cursor.fetchall()
				# Check if any items were found
				if snippets:
					ids = {}
					documents = {}
					# Create a dictionary of the results.
					# every id is a key and the content is an array of the values:
					for snippet in snippets:
						doc_id = snippet["doc_id"]
						if doc_id not in documents:
							documents[doc_id] = Document(
								page_content="", 
								metadata={
									"doc_id": doc_id,
									"snippet_ids": []
								}
							)
						documents[doc_id].page_content += snippet["document"]
						documents[doc_id].metadata["snippet_ids"].append(snippet["id"])
					
					docs = [documents[key] for key in documents]
					# Test it:
					# for d in docs:
					# 	print(d.page_content)
					# 	print("\n" + "-" * 20 + "\n")
					return docs
				else:
					return []
		except Exception as e:
			print(e)

		return []

        # These are dummy methods from BaseStore:
	async def amget(self, keys: Sequence[str]) -> List[Optional[V]]:
		raise NotImplementedError

	def mset(self, key_value_pairs: Sequence[Tuple[str, V]]) -> None:
		raise NotImplementedError

	async def amset(self, key_value_pairs: Sequence[Tuple[str, V]]) -> None:
		raise NotImplementedError

	def mdelete(self, keys: Sequence[str]) -> None:
		raise NotImplementedError

	async def amdelete(self, keys: Sequence[str]) -> None:
		raise NotImplementedError

	def yield_keys(self, prefix: Optional[str] = None) -> Iterator[str]:
		raise NotImplementedError

	async def ayield_keys(self, prefix: Optional[str] = None) -> AsyncIterator[str]:
		raise NotImplementedError

You can have a look at the (docstore) BaseStore class here:

langchain/libs/core/langchain_core/stores.py

Line 31 in 152427e

class BaseStore(Generic[K, V], ABC):

I hope that helps! If you have any further questions, please let me know.