Tools on LangChain

1
from langchain.agents import AgentExecutor
2
from langchain_cohere.react_multi_hop.agent import create_cohere_react_agent
3
from langchain_core.prompts import ChatPromptTemplate
4
from langchain_cohere import ChatCohere
5
6
from langchain_community.tools.tavily_search import TavilySearchResults
7
from pydantic import BaseModel, Field
8
9
os.environ["TAVILY_API_KEY"] ="TAVILY_API_KEY"
10
11
internet_search = TavilySearchResults()
12
internet_search.name = "internet_search"
13
internet_search.description = "Returns a list of relevant document snippets for a textual query retrieved from the internet."
14
15
class TavilySearchInput(BaseModel):
16
    query: str = Field(description="Query to search the internet with")
17
internet_search.args_schema = TavilySearchInput
18
19
# Define the Cohere LLM
20
llm = ChatCohere(cohere_api_key="COHERE_API_KEY",              
21
                 model="command-r-plus-08-2024",
22
                 temperature=0)
23
# Preamble
24
preamble = """
25
You are an expert who answers the user's question with the most relevant datasource. You are equipped with an internet search tool and a special vectorstore of information about how to write good essays.
26
"""
27
28
# Prompt template
29
prompt = ChatPromptTemplate.from_template("{input}")
30
31
# Create the ReAct agent
32
agent = create_cohere_react_agent(
33
    llm=llm,
34
    tools=[internet_search],
35
    prompt=prompt,
36
)
37
38
agent_executor = AgentExecutor(agent=agent, tools=[internet_search], verbose=True)
39
40
response = agent_executor.invoke({
41
    "input": "Who is the mayor of the capital of Ontario",
42
    "preamble": preamble,
43
})
44
45
print(response['output'])

1
from langchain_cohere import ChatCohere
2
from langchain_core.messages import HumanMessage
3
from pydantic import BaseModel, Field
4
5
# Data model
6
class web_search(BaseModel):
7
    """
8
    The internet. Use web_search for questions that are related to anything else than agents, prompt engineering, and adversarial attacks.
9
    """
10
    query: str = Field(description="The query to use when searching the internet.")
11
12
class vectorstore(BaseModel):
13
    """
14
    A vectorstore containing documents related to agents, prompt engineering, and adversarial attacks. Use the vectorstore for questions on these topics.
15
    """
16
    query: str = Field(description="The query to use when searching the vectorstore.")
17
18
# Preamble
19
preamble = """You are an expert at routing a user question to a vectorstore or web search.
20
The vectorstore contains documents related to agents, prompt engineering, and adversarial attacks.
21
Use the vectorstore for questions on these topics. Otherwise, use web-search."""
22
23
# LLM with tool use and preamble
24
# Define the Cohere LLM
25
llm = ChatCohere(cohere_api_key="COHERE_API_KEY",              
26
                 model="command-r-plus-08-2024")
27
28
llm_with_tools = llm.bind_tools(tools=[web_search, vectorstore], preamble=preamble)
29
30
messages = [HumanMessage("Who will the Bears draft first in the NFL draft?")]
31
response = llm_with_tools.invoke(messages, force_single_step=True)
32
print(response.response_metadata['tool_calls'])
33
34
messages = [HumanMessage("What are the types of agent memory?")]
35
response = llm_with_tools.invoke(messages, force_single_step=True)
36
print(response.response_metadata['tool_calls'])
37
38
messages = [HumanMessage("Hi, How are you?")]
39
response = llm_with_tools.invoke(messages, force_single_step=True)
40
print('tool_calls' in response.response_metadata)

1
from langchain_cohere import ChatCohere, create_sql_agent
2
from langchain_community.utilities import SQLDatabase
3
import urllib.request
4
import pandas as pd
5
import sqlite3
6
7
# Download the Chinook SQLite database
8
url = "https://github.com/lerocha/chinook-database/raw/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite"
9
urllib.request.urlretrieve(url, "Chinook.db")
10
print("Chinook database downloaded successfully.")
11
12
db = SQLDatabase.from_uri("sqlite:///Chinook.db")
13
print(db.dialect)
14
print(db.get_usable_table_names())
15
db.run("SELECT * FROM Artist LIMIT 10;")
16
17
# Define the Cohere LLM
18
llm = ChatCohere(cohere_api_key="COHERE_API_KEY",              
19
                 model="command-r-plus-08-2024",
20
                 temperature=0)
21
22
agent_executor = create_sql_agent(llm, db=db, verbose=True)
23
24
resp = agent_executor.invoke("Show me the first 5 rows of the Album table.")
25
print(resp)

1
from langchain_cohere import ChatCohere, create_csv_agent
2
3
# Define the Cohere LLM
4
llm = ChatCohere(cohere_api_key="COHERE_API_KEY",              
5
                 model="command-r-plus-08-2024",
6
                 temperature=0)
7
8
agent_executor = create_csv_agent(
9
    llm,
10
    "titanic.csv" # https://github.com/langchain-ai/langchain/blob/master/templates/csv-agent/titanic.csv
11
)
12
13
resp = agent_executor.invoke({"input":"How many people were on the titanic?"})
14
print(resp.get("output")) 

1
from langchain_core.tools import tool
2
from langchain_cohere import ChatCohere
3
4
@tool
5
def add(a: int, b: int) -> int:
6
    """Adds a and b."""
7
    return a + b
8
9
10
@tool
11
def multiply(a: int, b: int) -> int:
12
    """Multiplies a and b."""
13
    return a * b
14
15
tools = [add, multiply]
16
17
# Define the Cohere LLM
18
llm = ChatCohere(cohere_api_key="COHERE_API_KEY",              
19
                 model="command-r-plus-08-2024",
20
                 temperature=0)
21
22
llm_with_tools = llm.bind_tools(tools)
23
24
query = "What is 3 * 12? Also, what is 11 + 49?"
25
26
for chunk in llm_with_tools.stream(query):
27
    if chunk.tool_call_chunks:
28
        print(chunk.tool_call_chunks)

1
from typing import Annotated
2
from typing_extensions import TypedDict
3
from langgraph.graph import StateGraph, START, END
4
from langgraph.graph.message import add_messages
5
from langchain_cohere import ChatCohere
6
7
# Create a state graph
8
class State(TypedDict):
9
    messages: Annotated[list, add_messages]
10
11
graph_builder = StateGraph(State)
12
13
# Define the Cohere LLM
14
llm = ChatCohere(cohere_api_key="COHERE_API_KEY",              
15
                 model="command-r-plus-08-2024")
16
17
# Add nodes
18
def chatbot(state: State):
19
    return {"messages": [llm.invoke(state["messages"])]}
20
21
graph_builder.add_node("chatbot", chatbot)
22
graph_builder.add_edge(START, "chatbot")
23
graph_builder.add_edge("chatbot", END)
24
25
# Compile the graph
26
graph = graph_builder.compile()
27
28
# Run the chatbot
29
while True:
30
    user_input = input("User: ")
31
    print("User: "+ user_input)
32
    if user_input.lower() in ["quit", "exit", "q"]:
33
        print("Goodbye!")
34
        break
35
    for event in graph.stream({"messages": ("user", user_input)}):
36
        for value in event.values():
37
            print("Assistant:", value["messages"][-1].content)

1
from langchain_community.tools.tavily_search import TavilySearchResults
2
from langchain_cohere import ChatCohere
3
from langgraph.graph import StateGraph, START
4
from langgraph.graph.message import add_messages
5
from langchain_core.messages import ToolMessage
6
from langchain_core.messages import BaseMessage
7
from typing import Annotated, Literal
8
from typing_extensions import TypedDict
9
import json
10
11
12
# Create a tool
13
tool = TavilySearchResults(max_results=2)
14
tools = [tool]
15
16
17
# Create a state graph
18
class State(TypedDict):
19
    messages: Annotated[list, add_messages]
20
21
22
graph_builder = StateGraph(State)
23
24
# Define the LLM
25
llm = ChatCohere(cohere_api_key="COHERE_API_KEY",              
26
                 model="command-r-plus-08-2024")
27
28
# Bind the tools to the LLM
29
llm_with_tools = llm.bind_tools(tools)
30
31
32
# Add nodes
33
def chatbot(state: State):
34
    return {"messages": [llm_with_tools.invoke(state["messages"])]}
35
36
37
graph_builder.add_node("chatbot", chatbot)
38
39
class BasicToolNode:
40
    """A node that runs the tools requested in the last AIMessage."""
41
42
    def __init__(self, tools: list) -> None:
43
        self.tools_by_name = {tool.name: tool for tool in tools}
44
45
    def __call__(self, inputs: dict):
46
        if messages := inputs.get("messages", []):
47
            message = messages[-1]
48
        else:
49
            raise ValueError("No message found in input")
50
        outputs = []
51
        for tool_call in message.tool_calls:
52
            tool_result = self.tools_by_name[tool_call["name"]].invoke(
53
                tool_call["args"]
54
            )
55
            outputs.append(
56
                ToolMessage(
57
                    content=json.dumps(tool_result),
58
                    name=tool_call["name"],
59
                    tool_call_id=tool_call["id"],
60
                )
61
            )
62
        return {"messages": outputs}
63
64
65
tool_node = BasicToolNode(tools=[tool])
66
graph_builder.add_node("tools", tool_node)
67
68
def route_tools(
69
    state: State,
70
) -> Literal["tools", "__end__"]:
71
    """
72
    Use in the conditional_edge to route to the ToolNode if the last message
73
    has tool calls. Otherwise, route to the end.
74
    """
75
    if isinstance(state, list):
76
        ai_message = state[-1]
77
    elif messages := state.get("messages", []):
78
        ai_message = messages[-1]
79
    else:
80
        raise ValueError(f"No messages found in input state to tool_edge: {state}")
81
    if hasattr(ai_message, "tool_calls") and len(ai_message.tool_calls) > 0:
82
        return "tools"
83
    return "__end__"
84
85
86
graph_builder.add_conditional_edges(
87
    "chatbot",
88
    route_tools,
89
    {"tools": "tools", "__end__": "__end__"},
90
)
91
graph_builder.add_edge("tools", "chatbot")
92
graph_builder.add_edge(START, "chatbot")
93
94
# Compile the graph
95
graph = graph_builder.compile()
96
97
# Run the chatbot
98
while True:
99
    user_input = input("User: ")
100
    if user_input.lower() in ["quit", "exit", "q"]:
101
        print("Goodbye!")
102
        break
103
    for event in graph.stream({"messages": [("user", user_input)]}):
104
        for value in event.values():
105
            if isinstance(value["messages"][-1], BaseMessage):
106
                print("Assistant:", value["messages"][-1].content)