Bedrock Agent with Tools: This agent requires that the "bind_tools()" method be implemented on the input model

[jakowenko]

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 { DocxLoader } from '@langchain/community/document_loaders/fs/docx';
import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
import { BedrockChat } from '@langchain/community/chat_models/bedrock';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';
import { BedrockEmbeddings } from '@langchain/community/embeddings/bedrock';
import { createRetrieverTool } from 'langchain/tools/retriever';
import { createToolCallingAgent, AgentExecutor } from 'langchain/agents';
import { ChatPromptTemplate } from '@langchain/core/prompts';

(async () => {
  const llm = new BedrockChat({
    model: 'anthropic.claude-v2:1',
    region: 'us-east-1',
  });

  const loader = new DocxLoader('./test.docx');
  const documents = await loader.load();

  const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 1000,
    chunkOverlap: 200,
  });
  const docs = await splitter.splitDocuments(documents);

  const vectorstore = await MemoryVectorStore.fromDocuments(docs, new BedrockEmbeddings());

  const retriever = vectorstore.asRetriever();

  const retrieverTool = createRetrieverTool(retriever, {
    name: 'doc retriever',
    description: 'Search for information in this document to help the user',
  });

  const prompt = ChatPromptTemplate.fromMessages([
    ['system', 'You are a helpful assistant'],
    ['placeholder', '{chat_history}'],
    ['human', '{input}'],
    ['placeholder', '{agent_scratchpad}'],
  ]);

  const agent = createToolCallingAgent({ llm, tools: [retrieverTool], prompt });
  const agentExecutor = new AgentExecutor({ agent, tools: [retrieverTool] });
  const result = await agentExecutor.invoke({ input: 'What is LangChain?' });
  console.log(result);
})();

Description

I'm trying to use the langchain library to create an agent using Bedrock and it seems like Bedrock doesn't support the bind_tools function and I was looking to see if there is a way to overcome this. I did find this langchain-aws pull request that seemed to support it when using an Anthropic model.

I'm able to invoke the retriever directly, but when I try to use this as a tool within the agent I get the following error.

Error: This agent requires that the "bind_tools()" method be implemented on the input model.

System Info

[email protected]
@langchain/[email protected]
@langchain/[email protected]

OS: macOS 14.5
npm version: 10.5.0
node version: 20.12.2

[dosubot[bot]]

Hey @jakowenko! I'm a bot designed to help you with bugs, questions, and contributions. I'm here to assist you while you wait for a human maintainer.

To overcome the issue of Bedrock not supporting the bind_tools function when creating an agent using the LangChain library, you need to ensure that the language model (LLM) you are using implements the bind_tools method. The createToolCallingAgent function explicitly checks for this method and throws an error if it is not present.

Here is the relevant part of the code that checks for the bind_tools method:

if (llm.bindTools === undefined) {
  throw new Error(
    `This agent requires that the "bind_tools()" method be implemented on the input model.`
  );
}

To resolve this, you can either:

1. Use a language model that already supports the bind_tools method.
2. Implement a wrapper around your current model to add support for the bind_tools method.

Here is an example of how you might implement a wrapper around a model to add the bind_tools method:

class MyModelWithTools extends BaseChatModel {
  constructor(model) {
    super();
    this.model = model;
  }

  bindTools(tools) {
    // Implement the logic to bind tools to your model
    this.tools = tools;
    return this;
  }

  // Implement other necessary methods from BaseChatModel
}

// Usage
const myModel = new MyModelWithTools(existingModel);
const agent = createToolCallingAgent({ llm: myModel, tools, prompt });

By ensuring that your model has the bind_tools method, you can successfully create an agent using the LangChain library ^[1].

To continue talking to Dosu, mention @dosu.

[jakowenko]

@dosu how would I incorporate the document tool into that above code?

const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 1000,
    chunkOverlap: 200,
  });
  const docs = await splitter.splitDocuments(documents);

  const vectorstore = await MemoryVectorStore.fromDocuments(docs, new BedrockEmbeddings());

  const retriever = vectorstore.asRetriever();

  const retrieverTool = createRetrieverTool(retriever, {
    name: 'doc retriever',
    description: 'Search for information in this document to help the user',
  });

[dosubot[bot]]

To incorporate the document tool into the provided code, you can follow these steps. This involves creating a custom model that supports the bind_tools method and integrating the retrieverTool into the agent setup.

Here's the complete code with the necessary modifications:

import { DocxLoader } from '@langchain/community/document_loaders/fs/docx';
import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
import { BedrockChat } from '@langchain/community/chat_models/bedrock';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';
import { BedrockEmbeddings } from '@langchain/community/embeddings/bedrock';
import { createRetrieverTool } from 'langchain/tools/retriever';
import { createToolCallingAgent, AgentExecutor } from 'langchain/agents';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { BaseChatModel } from 'langchain/core/models';

class MyModelWithTools extends BaseChatModel {
  constructor(model) {
    super();
    this.model = model;
  }

  bindTools(tools) {
    // Implement the logic to bind tools to your model
    this.tools = tools;
    return this;
  }

  // Implement other necessary methods from BaseChatModel
  async invoke(messages) {
    // Example implementation of the invoke method
    return this.model.invoke(messages);
  }
}

(async () => {
  const llm = new BedrockChat({
    model: 'anthropic.claude-v2:1',
    region: 'us-east-1',
  });

  const loader = new DocxLoader('./test.docx');
  const documents = await loader.load();

  const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 1000,
    chunkOverlap: 200,
  });
  const docs = await splitter.splitDocuments(documents);

  const vectorstore = await MemoryVectorStore.fromDocuments(docs, new BedrockEmbeddings());

  const retriever = vectorstore.asRetriever();

  const retrieverTool = createRetrieverTool(retriever, {
    name: 'doc retriever',
    description: 'Search for information in this document to help the user',
  });

  const prompt = ChatPromptTemplate.fromMessages([
    ['system', 'You are a helpful assistant'],
    ['placeholder', '{chat_history}'],
    ['human', '{input}'],
    ['placeholder', '{agent_scratchpad}'],
  ]);

  const myModel = new MyModelWithTools(llm);
  const agent = createToolCallingAgent({ llm: myModel, tools: [retrieverTool], prompt });
  const agentExecutor = new AgentExecutor({ agent, tools: [retrieverTool] });

  const result = await agentExecutor.invoke({ input: 'What is LangChain?' });
  console.log(result);
})();

In this code:

1. A custom model MyModelWithTools is created to wrap around the BedrockChat model and add support for the bind_tools method.
2. The retrieverTool is created using the createRetrieverTool function.
3. The MyModelWithTools instance is used to create the agent with the createToolCallingAgent function.
4. The AgentExecutor is used to invoke the agent with the integrated retrieverTool.

This setup ensures that the retrieverTool is properly integrated into the agent, allowing it to search for information in the document and help the user ^[1].

To continue talking to Dosu, mention @dosu.

[jakowenko]

@dosu the above code does not retrieve information from the test.docx so it seems the tool is not being called.

[dosubot[bot]]

To ensure that the tool is properly invoked to retrieve information from the document, you need to make sure the agent's execution plan includes the tool call. Here’s an updated version of your code with additional steps to ensure the tool is invoked correctly:

1. Ensure the prompt includes agent_scratchpad.
2. Implement the bindTools method on the LLM.
3. Create the agent with the required parameters.
4. Invoke the agent and check the results.

Here's the complete code with these steps:

import { DocxLoader } from '@langchain/community/document_loaders/fs/docx';
import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
import { BedrockChat } from '@langchain/community/chat_models/bedrock';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';
import { BedrockEmbeddings } from '@langchain/community/embeddings/bedrock';
import { createRetrieverTool } from 'langchain/tools/retriever';
import { createToolCallingAgent, AgentExecutor } from 'langchain/agents';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { BaseChatModel } from 'langchain/core/models';

class MyModelWithTools extends BaseChatModel {
  constructor(model) {
    super();
    this.model = model;
  }

  bindTools(tools) {
    this.tools = tools;
    return this;
  }

  async invoke(messages) {
    return this.model.invoke(messages);
  }
}

(async () => {
  const llm = new BedrockChat({
    model: 'anthropic.claude-v2:1',
    region: 'us-east-1',
  });

  const loader = new DocxLoader('./test.docx');
  const documents = await loader.load();

  const splitter = new RecursiveCharacterTextSplitter({
    chunkSize: 1000,
    chunkOverlap: 200,
  });
  const docs = await splitter.splitDocuments(documents);

  const vectorstore = await MemoryVectorStore.fromDocuments(docs, new BedrockEmbeddings());

  const retriever = vectorstore.asRetriever();

  const retrieverTool = createRetrieverTool(retriever, {
    name: 'doc retriever',
    description: 'Search for information in this document to help the user',
  });

  const prompt = ChatPromptTemplate.fromMessages([
    ['system', 'You are a helpful assistant'],
    ['placeholder', '{chat_history}'],
    ['human', '{input}'],
    ['placeholder', '{agent_scratchpad}'],
  ]);

  const myModel = new MyModelWithTools(llm);
  myModel.bindTools([retrieverTool]);

  const agent = await createToolCallingAgent({ llm: myModel, tools: [retrieverTool], prompt });
  const agentExecutor = new AgentExecutor({ agent, tools: [retrieverTool] });

  const result = await agentExecutor.invoke({ input: 'What is LangChain?' });
  console.log(result);
})();

Key Points:

1. Custom Model with bindTools: The MyModelWithTools class wraps around the BedrockChat model and implements the bindTools method.
2. Tool Binding: The bindTools method is called on the myModel instance to bind the retrieverTool.
3. Agent Creation: The agent is created using the createToolCallingAgent function with the custom model and tools.
4. Agent Execution: The AgentExecutor is used to invoke the agent, ensuring the tool is called to retrieve information from the document.

This setup should ensure that the retrieverTool is properly invoked to retrieve information from the test.docx document ^[1][2].

To continue talking to Dosu, mention @dosu.

[LordMsz]

I've been playing with this locally and managed to bend the BedrockChat class and utils to do this - use the new tools API with Claude 3 (claude-3-sonnet-20240229).
I wonder if anyone would be interested in this, so I should make a pull request? And anyone willing to help me get it right? Since this would be my first PR to this repo.

I also managed to make it work properly only for non-streamed messages; somehow it's not de-serializing tool argument json well with streamed mode.

@jakowenko FYI the changes needed are happening in the message formatting and parsing logic, where this behavior for tool call is completely missing, e.g. here:
https://github.com/langchain-ai/langchainjs/blob/main/libs/langchain-community/src/utils/bedrock.ts#L305

As you can see, no "tools" array is being passed here to the model, so the fact that model doesn't implement "bind_tools" it at the very top of this, but even with it, it wouldn't send the tools to the API.

If anyone finds this idea useful and willing to help, pls let me know, happy to make the PR today (after some polish).

[LordMsz]

I've made an issue and a PR for this, will see how it goes.
#5639

[khanzzirfan]

Hey team, I'm reading through this issue, but I have similar request, can I have sagemaker chat model which can support function/tool calling? The SageMakerEndpoint llm from the langchain does not support the bind_tools and tool calling as far as I tested.