how to use tool_calls info to really call a function?

[miniboxhaha]

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 multiply = tool(
  ({ a, b }: { a: number; b: number }): number => {
    /**
     * Multiply two numbers.
     */
    console.log("tool calling...");
    
    return a * b;
  },
  {
    name: "multiply",
    description: "Multiply two numbers",
    schema: z.object({
      a: z.number(),
      b: z.number(),
    })
  }
);

const llm = new ChatOllama({
  model: "llama3.2:latest",
  temperature: 0,
  baseUrl:"http://172.17.0.2:11434"
  // other params...
})

const llmWithTools = llm.bindTools([multiply])

const result = await llmWithTools.invoke("What is 2 multiplied by 3?");

Description

i am confused is result.tool_calls contains an array of every fun name and input args
but how to use it to call multiply.invoke(input_args)?
is there any api in langchain? or i should use eval()?
or maybe i totally misunderstood tool calling?
can someone help? thanks a lot

System Info

platform (linux)
Node version 20.18.3
npm version 10.8.2

[dosubot[bot]]

Hey @miniboxhaha! I'm here to help you with any issues you're facing. If you need assistance with bugs, questions, or anything else, feel free to ask.

To call the multiply function using the tool_calls information in LangChain, you should not use eval(). Instead, you can directly invoke the tool using the invoke method provided by the LangChain framework. Here's how you can do it:

1. Define your tools, including the multiply tool, using the LangChain framework:

   import { z } from "zod";
   import { tool } from "@langchain/core/tools";
   
   const multiplyTool = tool(({ a, b }: { a: number; b: number }): number => {
     return a * b;
   }, {
     name: "multiply",
     schema: z.object({
       a: z.number(),
       b: z.number(),
     }),
     description: "Multiply two numbers",
   });
   
   const tools = [multiplyTool];

2. Bind the tools to your model:

   const modelWithTools = llm.bindTools(tools);

3. Invoke the model with a relevant input, such as "What is 2 multiplied by 3?", and handle the tool calls:

   import { HumanMessage } from "@langchain/core/messages";
   
   const messages = [
     new HumanMessage("What is 2 multiplied by 3?"),
   ];
   
   const aiMessage = await modelWithTools.invoke(messages);
   
   const toolsByName = {
     multiply: multiplyTool,
   };
   
   for (const toolCall of aiMessage.tool_calls) {
     const selectedTool = toolsByName[toolCall.name];
     const toolMessage = await selectedTool.invoke(toolCall.args);
     messages.push(toolMessage);
   }
   
   console.log(messages);

4. Finally, invoke the model with the tool results to generate a final answer:

   await modelWithTools.invoke(messages);

This approach leverages the LangChain framework's capabilities to handle tool execution without the need for eval(). Make sure you are using @langchain/core>=0.2.16 to ensure compatibility with these features ^[1][2].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[miniboxhaha]

thanks, that's really help