ParentDocumentRetreiver and Pinecone

[jambudipa]

I am looking to use the ParentDocumentRetreiver along with Pinecone in JS Langchain, as described here.

I am struggling to update that sample code to use Pinecone as the vector store. I had previously used Haystack in Python and the pipeline architecture is a little different.

I have this so far:

const pinecone = new Pinecone();

const pineconeIndex = pinecone.Index(process.env.PINECONE_INDEX);

const vectorstore = await PineconeStore.fromExistingIndex(
  new OpenAIEmbeddings(),
  { pineconeIndex }
);

const retriever = new ParentDocumentRetriever({
  vectorstore,
  docstore, // <----- what should this be?
  childSplitter: new HTMLSplitter(),
  parentK: 5
});

await retriever.addDocuments(docs);

...but I'm not sure what the docstore property should be?

[dosubot[bot]]

🤖

Hello @jambudipa! I'm Dosu, a friendly bot here to assist you with your inquiries about langchainjs, help resolve any bugs, and guide you on becoming a contributor. While we're awaiting a human maintainer, I'll do my best to assist you. Let's get started, shall we?

In the ParentDocumentRetriever configuration, the docstore property should be an instance of a class that implements the DocumentStore interface. In your case, you can use the InMemoryStore class from the langchain/storage/in_memory module. This class provides a simple in-memory storage system for documents.

Here's how you can modify your code:

import { InMemoryStore } from "langchain/storage/in_memory";

const docstore = new InMemoryStore();

const retriever = new ParentDocumentRetriever({
  vectorstore,
  docstore,
  childSplitter: new HTMLSplitter(),
  parentK: 5
});

await retriever.addDocuments(docs);

In this code, a new InMemoryStore is created and assigned to the docstore variable. This docstore is then passed to the ParentDocumentRetriever constructor.

The docstore is used to store the documents that are loaded into the system. When you call the addDocuments method of the retriever, the documents are stored in the docstore. Later, when you call the getRelevantDocuments method, the retriever retrieves relevant documents from the docstore.

You can find more details in the examples/src/retrievers/parent_document_retriever.ts file in the langchainjs repository.

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

Best,
Dosu

Sources

• examples/src/retrievers/parent_document_retriever.ts

---

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]]

🤖

Based on the code you've shared, it seems like you're trying to retrieve documents from an existing Pinecone index without adding them to the docstore in your current session. The ParentDocumentRetriever in LangChainJS uses both a vectorstore and a docstore to retrieve documents. The vectorstore is used to store and retrieve the vector embeddings of the documents, while the docstore is used to store and retrieve the actual documents themselves.

When you call retriever.addDocuments(docs);, it adds the documents to both the vectorstore and the docstore. If you're trying to retrieve documents from an existing Pinecone index without calling addDocuments(docs);, the vectorstore might be able to retrieve the vector embeddings from the Pinecone index, but the docstore won't have the actual documents to return.

To fix this issue, you need to add the documents to the docstore in your current session. You can do this by calling docstore.addDocuments(docs); before you try to retrieve the documents. Here's how you can modify your code:

const pinecone = new Pinecone();
const pineconeIndex = pinecone.Index(process.env.PINECONE_INDEX);
const docstore = new InMemoryStore();

const vectorstore = await PineconeStore.fromExistingIndex(
  new OpenAIEmbeddings(),
  { pineconeIndex }
);

const retriever = new ParentDocumentRetriever({
  vectorstore,
  docstore,
  childSplitter: new HTMLSplitter(),
  parentK: 5,
});

// Add the documents to the docstore
await docstore.addDocuments(docs);

const retrievedDocs = await retriever.getRelevantDocuments("What is emptiness?");

console.log(retrievedDocs);

Please note that you need to have the docs variable defined and populated with your documents before you can add them to the docstore.

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

Sources

• examples/src/retrievers/parent_document_retriever.ts

---

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.

[jambudipa]

@dosu-bot

It does not help. What is docs? You say I should have docs populated with the documents before hand, but I don't know what those documents are, since I have not retrieved anything yet.

[dosubot[bot]]

🤖

The docs variable should contain an array of Document objects that you want to add to the docstore. Each Document object should have a pageContent property that contains the text of the document, and a metadata property that contains any additional information about the document.

Here's an example of how you can populate the docs variable with your documents:

import { Document } from "@langchain/core/documents";

const docs = [];

for (let i = 0; i < yourDocuments.length; i++) {
  const newDoc = new Document({
    pageContent: yourDocuments[i].text, // replace with your document's text
    metadata: yourDocuments[i].metadata, // replace with your document's metadata
  });
  docs.push(newDoc);
}

After populating the docs variable, you can add the documents to the docstore using the addDocuments method:

await docstore.addDocuments(docs);

The ParentDocumentRetriever class in the LangChainJS framework is used to retrieve relevant parent documents based on a given query. It interacts with the vectorstore and docstore to store and retrieve document vectors and documents respectively.

The vectorstore is used to store the vector representations of the documents. In this case, it is an instance of PineconeStore which uses OpenAI embeddings to convert the documents into vector representations.

The docstore is an instance of InMemoryStore which is used to store the actual documents.

The ParentDocumentRetriever uses a childSplitter to split the parent documents into smaller chunks, and then retrieves the most relevant chunks based on the query. The ParentDocumentRetriever then returns the parent document of the most relevant chunk.

You can find more information about the ParentDocumentRetriever class and its methods in the examples/src/retrievers/parent_document_retriever_score_threshold.ts file in the LangChainJS repository.

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

Sources

• libs/langchain-community/src/vectorstores/weaviate.ts
• examples/src/retrievers/parent_document_retriever_score_threshold.ts

---

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.

[jambudipa]

@dosu-bot

But I don't think I want to use InMemoryStore. My code creates an index on Pinecone, I am not anticipating doing that each time I query!

Does the docstore contain just the parent documents, or the child documents too?

Having created a Pinecone index, how to I then retrieve the parent documents based on a query against the Pinecone index if I do not have the parent documents? Is it necessary to store the parent documents somewhere else? Or do I need a self query on Pinecone or something like that?

[dosubot[bot]]

🤖

Based on your code and the questions you've asked, it seems like there might be some confusion about how the ParentDocumentRetriever class works in the LangChainJS framework.

The ParentDocumentRetriever class is designed to retrieve parent documents that contain relevant information based on a given query. It does this by using a combination of a vector store and a document store. The vector store is used to store the vector representations of the documents, and the document store is used to store the actual documents.

In your case, you're using a PineconeStore as the vector store and an InMemoryStore as the document store. The PineconeStore is designed to interact with a Pinecone index, which is a vector database that allows you to perform similarity search on vectors. The InMemoryStore is a simple in-memory store that can be used to store documents.

When you call the getRelevantDocuments method on the ParentDocumentRetriever instance, it uses the vector store to find the vectors that are most similar to the vector representation of the query. It then uses the document store to retrieve the actual documents that correspond to these vectors.

Now, to answer your questions:

1. The InMemoryStore should contain the parent documents. When you add documents to the ParentDocumentRetriever instance using the addDocuments method, it splits the documents into child documents, embeds them to get their vector representations, and stores both the parent documents and their vector representations in the docstore and vectorstore respectively.

2. If you do not have the parent documents, you cannot retrieve them. The ParentDocumentRetriever class does not perform any kind of self-query on Pinecone or anything similar. It simply retrieves the documents that you have added to it.

Here's an example of how you can use the ParentDocumentRetriever class:

// Initialize the vectorstore and docstore
const vectorstore = new MemoryVectorStore(new OpenAIEmbeddings());
const docstore = new InMemoryStore();

// Create an instance of ParentDocumentRetriever
const retriever = new ParentDocumentRetriever({
  vectorstore,
  docstore,
  parentSplitter: new RecursiveCharacterTextSplitter({
    chunkOverlap: 0,
    chunkSize: 500,
  }),
  childSplitter: new RecursiveCharacterTextSplitter({
    chunkOverlap: 0,
    chunkSize: 50,
  }),
  childK: 20,
  parentK: 5,
});

// Load the parent documents and add them to the retriever
const textLoader = new TextLoader("../examples/state_of_the_union.txt");
const parentDocuments = await textLoader.load();
await retriever.addDocuments(parentDocuments);

// Retrieve the parent documents based on a query
const retrievedDocs = await retriever.getRelevantDocuments("justice breyer");
console.log(retrievedDocs);

You can find more information about how to use the ParentDocumentRetriever class in the examples/src/retrievers/parent_document_retriever.ts file in the LangChainJS repository.

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

Sources

• examples/src/retrievers/parent_document_retriever.ts

---

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.

[ladrians]

+1 to this issue, is there a sample to work on to use the docStore different from the InMemoryStore case? Was hoping to prototype using the standard Redis option or other one. Is the idea for us to subclass it to match the Uint8Array definition? Noticed that the same happens on the MultiVectorRetriever option, would be great to have a real-case sample to base on.

[jambudipa]

Oh I did sort this in the end...I had to create my own docstore:

export class FirestoreStore extends BaseStore<string, Document> {
  private firestore = getFirestore();

  lc_namespace: string[];
  protected store: Record<string, Document>;

  async mget(keys: string[]): Promise<Document[]> {
    const collection = this.firestore.collection(COLLECTION);
    const promises = keys.map(async key => {
      const snap = await collection.doc(key).get();
      return snap.exists ? (snap.data() as Document) : null;
    });
    const values = await Promise.all(promises);
    return values.filter(Boolean) as Document[];
  }

  async mset(keyValuePairs: [string, Document][]): Promise<void> {
    const collection = this.firestore.collection(COLLECTION);
    for (const [key, value] of keyValuePairs) {
      await collection.doc(key).set({ pageContent: (value as Document).pageContent, metadata: (value as Document).metadata });
    }
  }

  async mdelete(keys: string[]): Promise<void> {
    const collection = this.firestore.collection(COLLECTION);
    for (const key of keys) {
      await collection.doc(key).delete();
    }
  }

  async *yieldKeys(prefix: string = ''): AsyncGenerator<string> {
    const collection = this.firestore.collection(COLLECTION);
    const snapshot = await collection.get();
    for (const doc of snapshot.docs) {
      const key = doc.id;
      if (key.startsWith(prefix)) {
        yield key;
      }
    }
  }

  async deleteAll() {
    const collection = this.firestore.collection(COLLECTION);
    const snapshot = await collection.get();

    for (const doc of snapshot.docs) {
      await collection.doc(doc.id).delete();
    }
  }
}

[jambudipa]

What confused me is thinking it worked like Haystack...in that the documents are stored in Pinecone as metadata (if I recall correctly). Different meaning for the same word, "document"...