Runnable Sequences Changed between 0.1.36 and now and I don't understand how to rewrite my code

[stevenolay]

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

/**
   * Create RunnableSequence that converts SQL Result to a Natural Language Response
   */
  private get _sqlToNaturalLanguageResponseChain() {
    const chain = RunnableSequence.from([
      {
        schema: (input) => input.schema,
        tableDescription: (input) => input.tableDescription,
        enrichedQuestion: (input) => input.enrichedQuestion,
        question: (input) => input.question,
        chatHistory: (input) => input.chatHistory,
        slug: (input) => input.slug,
        query: (input) => input.query,
        response: async (input) => {
          this._logger.log(input.query);
          const response = await this._runDbQuery({
            slug: input.slug,
            query: input.query
          }).catch((err) => {
            this._logger.error(`Error quering the DB: ${JSON.stringify(err)}`);
            return null;
          });
          this._logger.log(response);
          return response;
        }
      },
      this._psqlNaturalLanguageResponsePrompt,
      this._gpt4oMini,
      new StringOutputParser()
    ]);

    return chain;
  }

Description

I have chains that look like this. And this is no longer how the RunnableSequence interface works and I am struggling to figure out how to rewrite this code with the new RunnableSequence interfaces

System Info

node v18.19.1
npm 10.2.4

[dosubot[bot]]

To rewrite your code to work with the new RunnableSequence interfaces, you can follow these steps:

1. Define the Prompt Template:

   const template = `Answer the users question based only on the following context:
   
   <context>
     {context}
   </context>
   
   Question: {question}`;
   
   const prompt = PromptTemplate.fromTemplate(template);

2. Initialize the Model and Retriever:

   const model = new ChatOpenAI({
     temperature: 0,
     openAIApiKey: Deno.env.get("OPENAI_API_KEY"),
   });
   
   const retriever = new TavilySearchAPIRetriever({
     k: 3,
     apiKey: Deno.env.get("TAVILY_API_KEY"),
   });
   
   const formatDocs = (documents: Document[]) => documents.map((doc) => doc.pageContent).join("\n");

3. Create the Baseline Chain:

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

4. Invoke the Chain with a Simple Query:

   const simpleQuery = "what is langchain?";
   await chain.invoke(simpleQuery);

5. Rewrite-Retrieve-Read Implementation:

   • Define the Rewrite Template:

     const rewriteTemplate = `Provide a better search query for \
     web search engine to answer the given question, end \
     the queries with ’**’. Question: \
     {x} Answer:`;
     const rewritePrompt = PromptTemplate.fromTemplate(rewriteTemplate);

   • Parser to Remove the **:

     const _parse = (text) => text.replace("**", "");

   • Create the Rewriter:

     const rewriter = RunnableSequence.from([
       rewritePrompt,
       new ChatOpenAI({ temperature: 0 }),
       new StringOutputParser(),
       _parse
     ]);

   • Invoke the Rewriter with a Distracted Query:

     const distractedQuery = "man that sam bankman fried trial was crazy! what is langchain?";
     await rewriter.invoke({"x": distractedQuery});

   • Create the Rewrite-Retrieve-Read Chain:

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

   • Invoke the Rewrite-Retrieve-Read Chain:

     await rewriteRetrieveReadChain.invoke(distractedQuery);

Additionally, you can use custom functions as Runnables by leveraging the RunnableLambda constructor or relying on automatic coercion in chains. Here’s an example of using a custom function in a chain:

import { RunnableSequence } from "@langchain/core/runnables";

const storyPrompt = ChatPromptTemplate.fromTemplate("Tell me a short story about {topic}");

const storyModel = new ChatOpenAI({ model: "gpt-4o" });

const chainWithCoercedFunction = RunnableSequence.from([
  storyPrompt,
  storyModel,
  (input) => input.content.slice(0, 5),
]);

await chainWithCoercedFunction.invoke({ "topic": "bears" });

By following these steps and examples, you can adapt your code to work with the new RunnableSequence interfaces as demonstrated in the provided document. The new RunnableSequence interface allows for more flexible and modular chaining of operations, as shown in the test cases from the langchain-core repository.

The RunnableSequence class has been enhanced to support streaming and logging capabilities, as well as retry mechanisms for handling errors. You can also bind lifecycle listeners to a Runnable to handle events such as start, end, and error, providing more control over the execution flow ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[stevenolay]

When i tried this example:

import { RunnableSequence } from "@langchain/core/runnables";

const storyPrompt = ChatPromptTemplate.fromTemplate("Tell me a short story about {topic}");

const storyModel = new ChatOpenAI({ model: "gpt-4o" });

const chainWithCoercedFunction = RunnableSequence.from([
  storyPrompt,
  storyModel,
  (input) => input.content.slice(0, 5),
]);

await chainWithCoercedFunction.invoke({ "topic": "bears" });

I'm getting the following typescript compiler errors:

Argument of type '[ChatPromptTemplate<ParamsFromFString<"Tell me a short story about {topic}">, any>, ChatOpenAI, (input: any) => any]' is not assignable to parameter of type '[RunnableLike<ParamsFromFString<"Tell me a short story about {topic}">, any>, ...RunnableLike<any, any>[], RunnableLike<any, any>]'.
Type at position 1 in source is not compatible with type at position 1 in target.
Type 'ChatOpenAI' is not assignable to type 'RunnableLike<any, any>'.
Type 'ChatOpenAI' is not assignable to type 'RunnableMapLike<any, any>'.
Index signature for type 'string' is missing in type 'ChatOpenAI'.

[dosubot[bot]]

The TypeScript compiler error you're encountering is due to the fact that ChatOpenAI is not being recognized as a Runnable object. To fix this, you need to ensure that all elements in the array passed to RunnableSequence.from are Runnable objects. Here's the corrected code:

import { RunnableSequence } from "@langchain/core/runnables";
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { RunnableLambda } from "@langchain/core/runnables";

// Define the prompt template
const storyPrompt = ChatPromptTemplate.fromTemplate("Tell me a short story about {topic}");

// Initialize the model
const storyModel = new ChatOpenAI({ model: "gpt-4o" });

// Create a lambda function as a Runnable
const sliceFunction = new RunnableLambda((input) => input.content.slice(0, 5));

// Create the runnable sequence
const chainWithCoercedFunction = RunnableSequence.from([
  storyPrompt,
  storyModel,
  sliceFunction,
]);

// Invoke the chain
await chainWithCoercedFunction.invoke({ "topic": "bears" });

In this corrected code, the lambda function is wrapped in a RunnableLambda to ensure it is treated as a Runnable object. This should resolve the TypeScript compiler error you're seeing ^[1].

To continue talking to Dosu, mention @dosu.