How do I retrieve documents from a vector store using RunnableMap?

[dmdum]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

const vectorStoreRetriever = nodeData.inputs?.vectorStoreRetriever as BaseRetriever
const retrieverChain = createRetrieverChain(model, vectorStoreRetriever, REPHRASE_TEMPLATE)
const context = RunnableMap.from({
        lab_interpretation: RunnableSequence.from([
            () => ({ question: promptValuesRaw.input }),
            retrieverChain,
            RunnableLambda.from(formatDocs).withConfig({
                runName: 'FormatDocumentChunks'
            })
        ])
    }).withConfig({ tags: ['RetrieveDocs'] })

const vs_docs = await context.invoke({})

Description

I'm trying to retrieve documents from a vector store using RunnableMap. The example code is giving me TypeError: Cannot read properties of undefined (reading 'length') when I invoke the runnable. How do I retrieve documents from a vector store using RunnableMap?

System Info

windows
Node v20.11.1

[dosubot[bot]]

To retrieve documents from a vector store using RunnableMap in a Node.js environment, you can follow this example:

import { CohereEmbeddings } from "@langchain/cohere";
import { PromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";
import {
  RunnablePassthrough,
  RunnableSequence,
} from "@langchain/core/runnables";
import { Document } from "@langchain/core/documents";
import { ChatAnthropic } from "@langchain/anthropic";
import { MemoryVectorStore } from "langchain/vectorstores/memory";

const model = new ChatAnthropic();
const vectorstore = await MemoryVectorStore.fromDocuments(
  [{ pageContent: "mitochondria is the powerhouse of the cell", metadata: {} }],
  new CohereEmbeddings()
);
const retriever = vectorstore.asRetriever();
const template = `Answer the question based only on the following context:
{context}

Question: {question}`;

const prompt = PromptTemplate.fromTemplate(template);

const formatDocs = (docs: Document[]) => docs.map((doc) => doc.pageContent);

const retrievalChain = RunnableSequence.from([
  { context: retriever.pipe(formatDocs), question: new RunnablePassthrough() },
  prompt,
  model,
  new StringOutputParser(),
]);

const result = await retrievalChain.invoke(
  "what is the powerhouse of the cell?"
);
console.log(result);

/*
 Based on the given context, the powerhouse of the cell is mitochondria.
*/

This example demonstrates how to set up a retrieval chain using RunnableSequence and RunnablePassthrough to retrieve documents from a vector store and use them to answer a question ^[1].

Additionally, you can test the retriever with callbacks to ensure it works as expected:

import { Document } from "@langchain/core/documents";
import { FakeEmbeddings } from "@langchain/core/utils/testing";
import { MemoryVectorStore } from "langchain/vectorstores/memory";

test("Test Memory Retriever with Callback", async () => {
  const pageContent = "Hello world";
  const embeddings = new FakeEmbeddings();

  const vectorStore = new MemoryVectorStore(embeddings);

  expect(vectorStore).toBeDefined();

  await vectorStore.addDocuments([
    { pageContent, metadata: { a: 1 } },
    { pageContent, metadata: { a: 1 } },
    { pageContent, metadata: { a: 1 } },
    { pageContent, metadata: { a: 1 } },
  ]);

  const queryStr = "testing testing";
  let startRun = 0;
  let endRun = 0;
  let startPromiseResolve: (v?: unknown) => void;
  const startPromise = new Promise((resolve) => {
    startPromiseResolve = resolve;
  });
  let endPromiseResolve: (v?: unknown) => void;
  const endPromise = new Promise((resolve) => {
    endPromiseResolve = resolve;
  });

  const retriever = vectorStore.asRetriever({
    k: 1,
    vectorStore,
    callbacks: [
      {
        handleRetrieverStart: async (_, query) => {
          expect(query).toBe(queryStr);
          startRun += 1;
          startPromiseResolve();
        },
        handleRetrieverEnd: async (documents) => {
          expect(documents[0].pageContent).toBe(pageContent);
          endRun += 1;
          endPromiseResolve();
        },
      },
    ],
  });

  const results = await retriever.getRelevantDocuments(queryStr);

  expect(results).toEqual([new Document({ metadata: { a: 1 }, pageContent })]);
  await startPromise;
  await endPromise;
  expect(startRun).toBe(1);
  expect(endRun).toBe(1);
});

This code demonstrates how to test the retriever with callbacks to ensure it retrieves documents correctly ^[2].

For more advanced use cases, such as retrieving documents from both a vector store and a document store, you can use the MultiVectorRetriever class:

import { MultiVectorRetriever } from "langchain/retrievers/multi_vector";
import { FaissStore } from "langchain/vectorstores/faiss";
import { InMemoryStore } from "langchain/stores/in_memory";
import { Document } from "@langchain/core/documents";

const retriever = new MultiVectorRetriever({
  vectorstore: new FaissStore(),
  byteStore: new InMemoryStore<Uint8Array>(),
  idKey: "doc_id",
  childK: 20,
  parentK: 5,
});

const retrieverResult = await retriever.getRelevantDocuments("justice breyer");
console.log(retrieverResult[0].pageContent.length);

This example shows how to use the MultiVectorRetriever for more complex retrieval scenarios ^[3].

Details

About Dosu
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.

To continue the conversation, mention @dosu.

[dmdum]

@dosu Is fetching from the an existing vector store based on a question also possible without using Runnables?

[dosubot[bot]]

Yes, you can fetch documents from an existing vector store based on a question without using Runnables. You can directly use the similaritySearch method of the VectorStore class. Here is an example:

import { HNSWLib } from "@langchain/community/vectorstores/hnswlib";
import { OpenAIEmbeddings } from "@langchain/openai";
import { Document } from "@langchain/core/documents";

// Assuming you have an instance of VectorStore
const vectorStore: HNSWLib = /* your vector store instance */;

async function fetchDocuments(query: string, k: number = 4): Promise<Document<Record<string, unknown>>[]> {
  return vectorStore.similaritySearch(query, k);
}

// Example usage
const query = "Which movies are directed by Greta Gerwig?";
fetchDocuments(query).then((documents) => {
  console.log(documents);
});

This code snippet directly calls the similaritySearch method on the vectorStore instance with the query and the number of documents to retrieve (k). This approach bypasses the need for Runnables and directly interacts with the vector store ^[1][2].

Details

About Dosu
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.

To continue the conversation, mention @dosu.