Cannot invoke createRetrievalChain

[KJinhiro]

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

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
import { createRetrievalChain } from "langchain/chains/retrieval";
import SessionService from "../services/session";
export default class ChatService {
  retriever: any;
  chain: any;
  template: string;
  promptTemplate: any;
  model: any;
  answer: string;
  sessionService: SessionService;
  documentsChain: any;

  setupRetriever(retriever): this {
    this.retriever = retriever;

    return this;
  }

  setupPromptTemplate(): this {
    try {
      require("dotenv").config();

      this.template = process.env.TEMPLATE;
      this.promptTemplate = ChatPromptTemplate.fromMessages([
        ["system", this.template],
        ["human", "{question}"],
      ]);

      return this;
    } catch (error) {
      throw error;
    }
  }

  async setupDocumentsChain(): Promise<this> {
    try {
      this.documentsChain = await createStuffDocumentsChain({
        llm: this.model,
        prompt: this.promptTemplate,
      });

      return this;
    } catch (error) {
      throw error;
    }
  }

  setupModel(): this {
    try {
      this.model = new ChatOpenAI({ model: "gpt-3.5-turbo", temperature: 0 });

      return this;
    } catch (error) {
      throw error;
    }
  }

  async buildLLMChain(): Promise<this> {
    try {
      this.chain = await createRetrievalChain({
        retriever: this.retriever,
        combineDocsChain: this.documentsChain,
      });

      return this;
    } catch (error) {
      throw error;
    }
  }

  async chat(prompt): Promise<this> {
    try {
      this.answer = await this.chain.invoke({
        question: prompt,
      });

      return this;
    } catch (error) {
      throw error;
    }
  }
}

import { Response } from "express";
import { sendErrorResponse, sendSuccessResponse } from "../utils/response";
import { ChatRequest } from "../types/interfaces/requests/chat";

export const chat = async (
  req: ChatRequest,
  res: Response
): Promise<Response> => {
  try {
    const authenticatedUser = req.user;

    await req.vectorStoreService
      .authorize(authenticatedUser)
      .loadVectorStoresForUser();

    const loadedRetriever = req.vectorStoreService.retriever;
    const prompt = req.body.prompt;

    await req.chatService
      .setupRetriever(loadedRetriever)
      .setupModel()
      .setupPromptTemplate()
      .setupDocumentsChain();
    await req.chatService.buildLLMChain();

    const answer = (await req.chatService.chat(prompt)).answer;

    return sendSuccessResponse(res, answer);
  } catch (error) {
    return sendErrorResponse(res, `Failed chat: ${error.message}`);
  }
};

Description

await req.chatService.chat(prompt); does not seem to work even though there is no undefined in all the classes. What is wrong with my code in either ClassService or in my export async chat.

System Info

Mac
Node TypeScript
Langchain@0.2.8

[dosubot[bot]]

The issue with the createRetrievalChain function in your code might be related to the types and structures of the arguments being passed. The createRetrievalChain function expects specific types for its parameters:

1. retriever: This should be a BaseRetrieverInterface which is expected to have a method getRelevantDocuments.
2. combineDocsChain: This should be a BaseChain that takes an object as input and produces a string output.

Here is the type definition for the parameters:

export type CreateRetrievalChainParams<RunOutput> = {
  retriever: BaseRetrieverInterface;
  combineDocsChain: BaseChain;
};

And the function signature:

export async function createRetrievalChain<RunOutput>({
  retriever,
  combineDocsChain,
}: CreateRetrievalChainParams<RunOutput>): Promise<
  Runnable<
    { input: string; chat_history?: BaseMessage[] | string } & {
      [key: string]: unknown;
    },
    { context: Document[]; answer: RunOutput } & { [key: string]: unknown }
  >
> {
  // Function implementation
}

Ensure that the retriever and combineDocsChain you are passing to createRetrievalChain match these expected types. If they do not, it could lead to issues when invoking the function.

Additionally, make sure that all necessary environment variables and configurations are correctly set up, as missing configurations can also cause issues.

If the issue persists, please provide more details about the specific error message you are encountering, as this can help in diagnosing the problem more accurately ^[1][2].

To continue talking to Dosu, mention @dosu.