We’ll use Cohere’s Python SDK for the code examples. Follow along in this notebook.

Introduction

The previous chapter showed how to implement multi-step tool use using the native Cohere API. A similar implementation is also available on LangChain.

In this chapter, we’ll look at how to use LangChain to create an assistant powered by multi-step tool use.

LangChain is an open-source framework for building applications based on large language models (LLMs). It provides tools and APIs that simplify the process of building LLM-driven applications like chatbots and virtual agents.

It provides abstractions for the various components needed to build LLM-powered applications. This includes the ReAct-style implementation of LLM agents and a collection of ready-to-use tools to simplify the development process.

In this chapter, we’ll build a data analyst that can research the web, get up-to-date data, and perform data visualization using Python.

Using Cohere with LangChain

With LangChain, the four-step tool-use workflow remains the same. The only difference is that interfacing with the LLM and tools is done via the LangChain API, as illustrated in the diagram below.

Interfacing with the LLM and tools is done via the LangChain API

LangChain makes it easy to create tools, with different options available:

Built-in tools: Ready implementations of tools that can be used immediately (see full list). We’ll use two of them in this chapter.
Toolkits: Collections of tools that are designed to be used together for specific tasks (see full list). Some examples are toolkits for working with SQL databases, Gmail, or GitHub.
Custom tools: There’s the option to build our own tools, such as those we created in the previous chapters.

Let’s get started. First, we need to install a few LangChain libraries.

pip install langchain langchain-cohere langchain-experimental

Defining Tools

To build our data analysis agent, we’ll be using two tools, both of which are LangChain built-in tools:

Tavily Search - for performing web search
Python REPL - for executing Python code

Tavily Search

The Tavily Search is used for performing web search queries. Given a query, it returns a list of relevant document snippets from the internet. It requires an API key which you can get here under the free plan.

We access Tavily Search via the langchain_community library. The steps to define the tool are shown below.

from langchain_community.tools.tavily_search import TavilySearchResults

os.environ['TAVILY_API_KEY'] = "<INSERT TAVILY API KEY HERE>"

internet_search = TavilySearchResults()
internet_search.name = "internet_search"
internet_search.description = "Returns a list of relevant document snippets for a textual query retrieved from the internet."

from langchain_core.pydantic_v1 import BaseModel, Field
class TavilySearchInput(BaseModel):
    query: str = Field(description="Query to search the internet with")
internet_search.args_schema = TavilySearchInput

Python REPL

Next, we’ll create the Python REPL to execute the Python code. For our example, we’ll need it to plot data on a chart.

We access the Python REPL via the langchain_experimental library. The steps to define the tool are shown below.

from langchain.agents import Tool
from langchain_experimental.utilities import PythonREPL

python_repl = PythonREPL()
repl_tool = Tool(
    name="python_repl",
    description="Executes python code and returns the result. The code runs in a static sandbox without interactive mode, so print output or save output to a file.",
    func=python_repl.run,
)
repl_tool.name = "python_interpreter"

# from langchain_core.pydantic_v1 import BaseModel, Field
class ToolInput(BaseModel):
    code: str = Field(description="Python code to execute.")
repl_tool.args_schema = ToolInput

Creating a ReAct Agent

In the previous chapter, we saw that the native Cohere API uses a ReAct-style approach for implementing multi-step tool use. As a quick recap, the agent workflow starts with a planning step and is followed by a series of Action-Observation-Reflection sequences until a task is deemed complete.

The same approach is used when using Cohere with LangChain, which can be utilized via the create_cohere_react_agent module.

from langchain.agents import AgentExecutor
from langchain_cohere.react_multi_hop.agent import create_cohere_react_agent
from langchain_core.prompts import ChatPromptTemplate

The overall implementation to create an agent in LangChain is pretty simple:

Create the prompt using Cohere’s template
Create an agent by passing the model type, list of tools, and the prompt
Create an agent executor using AgentExecutor

# Create the prompt
prompt = ChatPromptTemplate.from_template("{input}")

# Create the ReAct agent
agent = create_cohere_react_agent(
    llm=chat,
    tools=[internet_search, repl_tool],
    prompt=prompt,
)

agent_executor = AgentExecutor(agent=agent, tools=[internet_search, repl_tool], verbose=True)

Multi-Step Tool Use

The agent is now ready to use. We can run it using agent_executor.invoke.

Let’s ask the agent a question that requires it to run a multi-step sequence: “Create a plot of the number of full-time employees at the three tech companies with the highest market cap in the United States in 2024.”

If a human assistant were given this query, they would need to do a few steps in the right order:

First, find the three tech companies with the highest market cap in the United States in 2024
Next, find the number of full-time employees at each of the companies
Finally, create a plot based on these numbers

Let’s see how the agent performs.

agent_executor.invoke({
    "input": "Create a plot of the number of full time employees at the 3 tech companies with the highest market cap in the United States in 2024.",
})

The whole response is pretty long, so let’s break down the responses into the different steps the agent takes.

First, it generates a plan of what it needs to perform: “First, I will search for the three tech companies with the highest market cap in the US in 2024. Then, I will search for the number of full-time employees at each of these companies, and plot the data using Python.”

Then, it executes its first action: using the internet search tool to find the three companies and display the results.

> Entering new AgentExecutor chain...

First, I will search for the three tech companies with the highest market cap in the US in 2024. Then, I will search for the number of full-time employees at each of these companies, and plot the data using Python.

{'tool_name': 'internet_search', 'parameters': {'query': 'top 3 tech companies highest market cap US 2024'}}
[{'url': '<https://www.fool.com/research/largest-companies-by-market-cap/>', 'content': "It's the most valuable automaker in the world and has the world's best-selling car in the Model Y.\\nTesla is most famous for its vehicles, and it's second only to China's BYD Company (OTC:BYDDY) among the largest EV companies in terms of manufacturing. While it's most famous for Windows, Microsoft also has a diverse selection of products and services that has helped to build on its success, including:\\nMicrosoft has been the world's largest company before, and it briefly surpassed Apple for the biggest market cap in 2021. Walmart\\nWalmart (NYSE:WMT) may not have the largest market cap, but it is No. 1 in terms of revenue, and it’s the largest retailer in the world. Microsoft\\nConsidering the popularity of the Windows operating system, it’s no surprise that Microsoft (NASDAQ:MSFT) has consistently ranked as one of the largest companies in the world. Although the top spot has changed hands on multiple occasions, Apple has spent the most time there and is currently the most valuable company in the world.\\n"}, {'url': 

...(truncated)

Using the results, the agent generates a reflection step that identifies the list of companies from its results. It then executes its next action: using the internet search tool to find the number of employees of the first company in the list, Microsoft.

I have found that the three tech companies with the highest market cap in the US in 2024 are Microsoft, Apple and NVIDIA. Now, I will search for the number of full-time employees at each of these companies and plot the data.

{'tool_name': 'internet_search', 'parameters': {'query': 'Microsoft full time employees 2024'}}
[{'url': '<https://www.statista.com/statistics/273475/number-of-employees-at-the-microsoft-corporation-since-2005/>', 'content': 'Digital & Trend reports\\nOverview and forecasts on trending topics\\nIndustry & Market reports\\nIndustry and market insights and forecasts\\nCompanies & Products reports\\nKey figures and rankings about companies and products\\nConsumer & 

...(truncated)

Having received the results, it moves to the next company in the list.

{'tool_name': 'internet_search', 'parameters': {'query': 'Apple full time employees 2024'}}
[{'url': '<https://www.macrotrends.net/stocks/charts/AAPL/apple/number-of-employees>', 'content': 'Employee Count. Interactive chart of Apple 

...(truncated)

And then, the third and final company on the list.

{'tool_name': 'internet_search', 'parameters': {'query': 'NVIDIA full time employees 2024'}}
[{'url': '<https://www.macrotrends.net/stocks/charts/NVDA/nvidia/number-of-employees>', 'content': 'Employee Count. Interactive chart of NVIDIA (NVDA) annual worldwide employee count from 2010 to 2024. NVIDIA total number of employees in 2024 was 29,600, a 12.99% increase

Now that it has retrieved all the data it needs, it can proceed with the next action: writing and executing the Python code to plot this data.

It generates a code block as the parameter for calling the Python REPL tool. Here, it opts to use matplotlib as the library to plot the data and finally save it as a PNG file.

I have found the following data on the number of full-time employees at each company: 
Microsoft: 221,000
Apple: 161,000
NVIDIA: 29,600
Now, I will write and execute Python code to plot this data.
{'tool_name': 'python_interpreter', 'parameters': {'code': 'import matplotlib.pyplot as plt\\n\\n# Data on the number of full-time employees at each company\\ncompanies = [\\n    "Microsoft", "Apple", "NVIDIA"\\n]\\nfull_time_employees = [221000, 161000, 29600]\\n\\n# Plot the data\\nplt.bar(companies, full_time_employees)\\nplt.xlabel("Company")\\nplt.ylabel("Number of Full Time Employees")\\nplt.xticks(rotation=45)\\nplt.tight_layout()\\nplt.savefig("tech_companies_market_cap_employees.png")'}}

Now that it has completed the task, it generates the final response to the user. It contains a text commentary on the number of employees and a rendering of the plot it had created.

As with the previous chapters, it also generates fine-grained citations that refer to the tools it used to generate the response.

Relevant Documents: 0,1,3,4,5,7,8,9,10,11,12,15,18,20
Cited Documents: 1,3,4,7,8,10,11,15,18,20

Answer: Here is a plot showing the number of full-time employees at the three US tech companies with the highest market cap in 2024:
![Number of Full Time Employees]('tech_companies_market_cap_employees.png')

The companies with the highest number of full-time employees are Microsoft with 221,000, Apple with 161,000 and NVIDIA with 29,600.
Grounded answer: Here is a plot showing the number of full-time employees at the three US tech companies with the highest market cap in 2024:
<co: 20>! [Number of Full Time Employees]('tech_companies_market_cap_employees.png')</co: 20>

The companies with the highest number of full-time employees are <co: 1,4>Microsoft</co: 1,4> with <co: 7,8>221,000</co: 7,8>, <co: 1,3,4>Apple</co: 1,3,4> with <co: 10,11>161,000</co: 10,11> and <co: 1,4>NVIDIA</co: 1,4> with <co: 15,18>29,600</co: 15,18>.

The matplotlib plot generated through the Python REPL

Conclusion

In this chapter, we looked at how to build a multi-step agent using LangChain. This lets us build ReAct-style agents that can reason over multiple steps, similar to the one we built with the native Cohere API in the previous chapter.

This agent also had access to the two LangChain built-in tools: Tavily Search and Python REPL. The built-in tools and toolkit simplify the process of creating tool use applications, so the developer can focus on building the application’s core logic.

That concludes the LLM University module on tool use, for now. There is still so much to discuss on the subject of agents and tool use, so be sure to keep an eye on LLM University for new modules on this topic in future.

Contents

Tool Use on LangChain