Langchain query using Pinecone and ParentDocumentRetriever returns no results

[jambudipa]

I am really not understanding how to retrieve the parent documents using Langchain's ParentDocumentRetriever when using Pinecone. The following code is working for creating the embeddings and inserting them into Pinecone:

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,
});

// We must add the parent documents via the retriever's addDocuments method
await retriever.addDocuments(docs);

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

console.log(retrievedDocs);

The retrievedDocs contains a few parent documents, as expected.

Now that my index is created, I would like to subsequently perform the same operation, but without the await retriever.addDocuments(docs):

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,
});

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

console.log(retrievedDocs);

This yields no results. The documentation is really rather unclear on this: am I expected to implement my own document store containing all of the parent documents with their accompanying IDs or something like that? Can I save the InMemoryStore to the filesystem, or use the LocalFileStore? Does this document store pertain just to the parent documents?

I am not sure how to use LocalFileStore since dropping it in as a replacement causes my IDE to become unhappy, because it extends BaseStore<string, Uint8Array>, whereas InMemoryStore extends BaseStore<string, T>.

In summary, how would I use Pinecone as a vector store in combination with ParentDocumentRetriever? What document store do I use? Does the docstore pertain to just the parent documents, is it necessary for me to store those myself?

It seems to me that this would be a pretty common use case; where might I find an example?

[dosubot[bot]]

🤖

Hey @jambudipa!

I'm Dosu, a friendly bot here to help you navigate the world of LangChainJS, solve bugs, answer questions, and even guide you to become a contributor. While we're waiting for a human maintainer, feel free to ask me anything - I'm here to make your coding journey smoother. Let's dive into your issue!

It seems like you're trying to use the ParentDocumentRetriever with Pinecone and you're having trouble understanding how the document store works. Let's break it down:

1. Vector Store: This is where the vector representations of your documents are stored. In your case, you're using Pinecone as your vector store, which is a great choice for large-scale applications.

2. Document Store: This is where the actual documents are stored. The ParentDocumentRetriever uses the document store to retrieve the parent documents of the relevant child documents. In your case, you're using the InMemoryStore as your document store. This is a simple key-value store that keeps everything in memory. It's great for testing and small-scale applications, but for larger applications, you might want to use a more robust solution like a database or a file system.

Now, to your question about why you're not getting any results when you remove the await retriever.addDocuments(docs) line. The reason is that the InMemoryStore does not persist data between different instances of your application. When you create a new instance of ParentDocumentRetriever, it creates a new, empty InMemoryStore. So, when you try to retrieve documents, it doesn't find anything because your document store is empty.

If you want to persist your documents between different instances of your application, you need to use a persistent document store. Unfortunately, the LocalFileStore won't work in this case because it stores data as Uint8Array, while the ParentDocumentRetriever expects data in a different format.

You might need to implement your own document store that can persist data in a format compatible with the ParentDocumentRetriever. This could be a simple file-based store that saves data as JSON, or a more complex solution like a database.

Here's a simple example of how you might implement a file-based document store:

class FileStore extends BaseStore<string, Document> {
  constructor(private filePath: string) {
    super();
  }

  async get(id: string): Promise<Document | undefined> {
    const data = await fs.promises.readFile(this.filePath, 'utf-8');
    const documents = JSON.parse(data);
    return documents[id];
  }

  async set(id: string, value: Document): Promise<void> {
    const data = await fs.promises.readFile(this.filePath, 'utf-8');
    const documents = JSON.parse(data);
    documents[id] = value;
    await fs.promises.writeFile(this.filePath, JSON.stringify(documents));
  }
}

You can use this FileStore as your document store like this:

const docstore = new FileStore('./documents.json');

This will save your documents to a file named documents.json in your current directory. You can then retrieve these documents in subsequent runs of your application.

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

Sources

• langchain/src/retrievers/self_query/tests/pinecone_self_query.int.test.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

Well is there already a document store that takes Document as a generic parameter? In a database, for example?

[dosubot[bot]]

🤖

Based on the information provided in the examples/src/retrievers/parent_document_retriever.ts file, the LangChain JavaScript framework does indeed use the InMemoryStore as a document store. This store takes Document as a generic parameter and is compatible with the ParentDocumentRetriever.

However, as you've noted, the InMemoryStore does not persist data between different instances of your application. It's an in-memory store, meaning it only stores data for the duration of the application's runtime.

The LocalFileStore you tried using stores data as Uint8Array, which is not compatible with the ParentDocumentRetriever. This is likely because the LocalFileStore is designed to store binary data, while the ParentDocumentRetriever expects data in a different format.

Unfortunately, I couldn't find any other document stores provided by the LangChain framework that would meet your requirements. If you need a document store that persists data to a database, you might need to implement a custom document store. This custom store should implement the same interface as InMemoryStore to ensure compatibility with the ParentDocumentRetriever.

I hope this helps clarify the situation. If you have any further questions or if there's anything else you'd like to know, please don't hesitate 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-botWould it be possible to simply extend InMemoryStore to persist and restore the object to the file system?Sent from my iPhoneOn 23 Dec 2023, at 07:05, dosubot[bot] ***@***.***> wrote: 🤖 Based on the information provided in the examples/src/retrievers/parent_document_retriever.ts file, the LangChain JavaScript framework does indeed use the InMemoryStore as a document store. This store takes Document as a generic parameter and is compatible with the ParentDocumentRetriever. However, as you've noted, the InMemoryStore does not persist data between different instances of your application. It's an in-memory store, meaning it only stores data for the duration of the application's runtime. The LocalFileStore you tried using stores data as Uint8Array, which is not compatible with the ParentDocumentRetriever. This is likely because the LocalFileStore is designed to store binary data, while the ParentDocumentRetriever expects data in a different format. Unfortunately, I couldn't find any other document stores provided by the LangChain framework that would meet your requirements. If you need a document store that persists data to a database, you might need to implement a custom document store. This custom store should implement the same interface as InMemoryStore to ensure compatibility with the ParentDocumentRetriever. I hope this helps clarify the situation. If you have any further questions or if there's anything else you'd like to know, please don't hesitate 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. —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you were mentioned.Message ID: ***@***.***>

[dosubot[bot]]

🤖

Yes, extending the InMemoryStore to persist and restore objects to the file system is a viable solution. You can create a new class that extends InMemoryStore and override the mset, mget, yieldKeys, and mdelete methods to include file system operations. Here's an example of how you can implement it using Node.js's fs module:

import { InMemoryStore } from "langchain/storage/in_memory";
import fs from 'fs';
import path from 'path';

class FileSystemStore extends InMemoryStore {
  private filePath: string;

  constructor(filePath: string) {
    super();
    this.filePath = filePath;

    // Load data from file system on instantiation
    if (fs.existsSync(this.filePath)) {
      const data = fs.readFileSync(this.filePath, 'utf8');
      this.data = JSON.parse(data);
    }
  }

  async mset(pairs: [string, any][]) {
    super.mset(pairs);
    fs.writeFileSync(this.filePath, JSON.stringify(this.data));
  }

  async mget(keys: string[]) {
    return super.mget(keys);
  }

  async* yieldKeys(prefix?: string) {
    yield* super.yieldKeys(prefix);
  }

  async mdelete(keys: string[]) {
    await super.mdelete(keys);
    fs.writeFileSync(this.filePath, JSON.stringify(this.data));
  }
}

In this example, the FileSystemStore class extends InMemoryStore and overrides its methods to include file system operations. The mset and mdelete methods are overridden to write the current state of the store to the file system after performing their operations. The mget and yieldKeys methods are not modified because they do not modify the state of the store.

Please note that this is a simple example and does not include error handling or concurrency control, which you may need to add depending on your use case. Also, this example uses synchronous file system operations for simplicity, but you may want to use asynchronous operations in a real-world application to avoid blocking the event loop.

As for the ParentDocumentRetriever, it is used to retrieve relevant parent documents based on a given query. It takes in a vectorstore and docstore as required parameters. The vectorstore is used to store and retrieve vector embeddings of the documents, while the docstore is used to store and retrieve the actual documents. It also optionally takes in parentSplitter and childSplitter parameters, childK and parentK parameters, and has addDocuments and getRelevantDocuments methods.

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

Sources

• examples/src/stores/in_memory_storage.ts
• 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.