Runnable Agents? (for LC Expressions Language)

[hainessss]

Hey there! It's not clear to me how you include an agent in a Runnable chain

Someting like this: Is there a way of making the agent "RunnableLike"?

      const executor = createSqlAgent(model, toolkit, {
        prefix: `answers users sql question`,
        suffix: `{input}`,
      });
            
      const fullChain = RunnableSequence.from([
        {
          topic: classificationChain,
          question: (input: { question: string }) => input.question,
        },
        RunnableBranch.from([
          [
            (x: { topic: string; question: string }) =>
              x.topic.toLowerCase().includes("sql"),
              executor,
          ],
          [
            (x: { topic: string; question: string }) =>
              x.topic.toLowerCase().includes("other"),
            normalChatChain,
          ],
          normalChatChain,
        ])
      ]);

      const res = await fullChain.invoke({ question: query });

Thanks for the help!

[dosubot[bot]]

🤖

Hello!

To make your agent "RunnableLike", you can use the pipe method provided by the Runnable class. This method creates a new runnable sequence that runs each individual runnable in series, piping the output of one runnable into another runnable or runnable-like.

Here is an example of how you can use it:

const runnableAgent = new RunnableAgent(); // Assuming RunnableAgent is your agent that extends Runnable
const anotherRunnable = new AnotherRunnable(); // Assuming AnotherRunnable is another Runnable

const runnableLike = runnableAgent.pipe(anotherRunnable);

In this example, runnableLike is a RunnableLike object. The pipe method takes a RunnableLike object as an argument, which can be a Runnable, a Runnable function, or an object whose values are RunnableLike. The pipe method returns a new RunnableSequence.

This is supported by the following code from the context:

pipe<NewRunOutput>(
    coerceable: RunnableLike<RunOutput, NewRunOutput>
  ): RunnableSequence<RunInput, Exclude<NewRunOutput, Error>> {
    if (RunnableSequence.isRunnableSequence(coerceable)) {
      return new RunnableSequence({
        first: this.first,
        middle: this.middle.concat([
          this.last,
          coerceable.first,
          ...coerceable.middle,
        ]),
        last: coerceable.last,
      });
    } else {
      return new RunnableSequence({
        first: this.first,
        middle: [...this.middle, this.last],
        last: _coerceToRunnable(coerceable),
      });
    }
  }

This code shows that the pipe method is used to create a new RunnableSequence that runs each individual runnable in series, piping the output of one runnable into another runnable or runnable-like. If the object passed to the pipe method is already a RunnableSequence, it concatenates the current sequence with the passed sequence. Otherwise, it adds the passed object to the end of the current sequence.

You can find more details about this in the langchain/src/schema/runnable/base.ts file.

I hope this helps! Let me know if you have any other questions.

Sources

• langchain/src/schema/runnable/base.ts
• langchain/src/agents/toolkits/sql/sql.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.