genai-toolbox/docs/en/getting-started/local_quickstart.md

title, type, weight, description

title	type	weight	description
Quickstart	docs	2	How to get started running Toolbox locally with Python, PostgreSQL, and LangGraph.

Before you begin

This guide assumes you have already done the following:

1. Installed Python 3.9+ (including pip and your preferred virtual environment tool for managing dependencies e.g. venv)
2. Installed PostgreSQL 16+ and the psql client
3. Completed setup for usage with a LangChain chat model, such as:
   • langchain-vertexai package
   • langchain-google-genai package
   • langchain-anthropic package

Step 1: Set up your database

In this section, we will create a database, insert some data that needs to be access by our agent, and create a database user for Toolbox to connect with.

1. Connect to postgres using the psql command:

   psql -h 127.0.0.1 -U postgres
   

   Here, postgres denotes the default postgres superuser.

2. Create a new database and a new user:

   {{< notice tip >}} For a real application, it's best to follow the principle of least permission and only grant the privileges your application needs. {{< /notice >}}

     CREATE USER toolbox_user WITH PASSWORD 'my-password';
   
     CREATE DATABASE toolbox_db;
     GRANT ALL PRIVILEGES ON DATABASE toolbox_db TO toolbox_user;
   
     ALTER DATABASE toolbox_db OWNER TO toolbox_user;
   

3. End the database session:

   \q
   

4. Connect to your database with your new user:

   psql -h 127.0.0.1 -U toolbox_user -d toolbox_db
   

5. Create a table using the following command:

   CREATE TABLE hotels(
     id            INTEGER NOT NULL PRIMARY KEY,
     name          VARCHAR NOT NULL,
     location      VARCHAR NOT NULL,
     price_tier    VARCHAR NOT NULL,
     checkin_date  DATE    NOT NULL,
     checkout_date DATE    NOT NULL,
     booked        BIT     NOT NULL
   );
   

6. Insert data into the table.

   INSERT INTO hotels(id, name, location, price_tier, checkin_date, checkout_date, booked)
   VALUES 
     (1, 'Hilton Basel', 'Basel', 'Luxury', '2024-04-22', '2024-04-20', B'0'),
     (2, 'Marriott Zurich', 'Zurich', 'Upscale', '2024-04-14', '2024-04-21', B'0'),
     (3, 'Hyatt Regency Basel', 'Basel', 'Upper Upscale', '2024-04-02', '2024-04-20', B'0'),
     (4, 'Radisson Blu Lucerne', 'Lucerne', 'Midscale', '2024-04-24', '2024-04-05', B'0'),
     (5, 'Best Western Bern', 'Bern', 'Upper Midscale', '2024-04-23', '2024-04-01', B'0'),
     (6, 'InterContinental Geneva', 'Geneva', 'Luxury', '2024-04-23', '2024-04-28', B'0'),
     (7, 'Sheraton Zurich', 'Zurich', 'Upper Upscale', '2024-04-27', '2024-04-02', B'0'),
     (8, 'Holiday Inn Basel', 'Basel', 'Upper Midscale', '2024-04-24', '2024-04-09', B'0'),
     (9, 'Courtyard Zurich', 'Zurich', 'Upscale', '2024-04-03', '2024-04-13', B'0'),
     (10, 'Comfort Inn Bern', 'Bern', 'Midscale', '2024-04-04', '2024-04-16', B'0');
   

7. End the database session:

   \q
   

Step 2: Install and configure Toolbox

In this section, we will download Toolbox, configure our tools in a tools.yaml, and then run the Toolbox server.

1. Download the latest version of Toolbox as a binary:

   {{< notice tip >}} Select the correct binary corresponding to your OS and CPU architecture. {{< /notice >}}

   export OS="linux/amd64" # one of linux/amd64, darwin/arm64, darwin/amd64, or windows/amd64
   curl -O https://storage.googleapis.com/genai-toolbox/v0.1.0/$OS/toolbox
   

2. Make the binary executable:

   chmod +x toolbox
   

3. Write the following into a tools.yaml file. Be sure to update any fields such as user, password, or database that you may have customized in the previous step.

   sources:
     my-pg-source:
       kind: postgres
       host: 127.0.0.1
       port: 5432
       database: toolbox_db
       user: toolbox_user
       password: my-password
   tools:
     # Define the 5 tools we want our agent to have
     # for more info on tools check out the "Resources" section of the docs
     search-hotels-by-name:
       kind: postgres-sql
       source: my-pg-source
       description: Search for hotels based on name.
       parameters:
         - name: name
           type: string
           description: The name of the hotel.
       statement: SELECT * FROM hotels WHERE name ILIKE '%' || $1 || '%';
     search-hotels-by-location:
       kind: postgres-sql
       source: my-pg-source
       description: Search for hotels based on location.
       parameters:
         - name: location
           type: string
           description: The location of the hotel.
       statement: SELECT * FROM hotels WHERE location ILIKE '%' || $1 || '%';
     book-hotel:
       kind: postgres-sql
       source: my-pg-source
       description: >-
         Book a hotel by its ID. Returns a message indicating whether the hotel was
         successfully booked or not.
       parameters:
         - name: hotel_id
           type: string
           description: The ID of the hotel to book.
       statement: UPDATE hotels SET booked = B'1' WHERE id = $1;
     update-hotel:
       kind: postgres-sql
       source: my-pg-source
       description: >-
         Update a hotel's check-in and check-out dates by its ID. Returns a message
         indicating  whether the hotel was successfully updated or not.
       parameters:
         - name: hotel_id
           type: string
           description: The ID of the hotel to update.
         - name: checkin_date
           type: string
           description: The new check-in date of the hotel.
         - name: checkout_date
           type: string
           description: The new check-out date of the hotel.
       statement: >-
         UPDATE hotels SET checkin_date = CAST($2 as date), checkout_date = CAST($3
         as date) WHERE id = $1;
     cancel-hotel:
       kind: postgres-sql
       source: my-pg-source
       description: Cancel a hotel by its ID.
       parameters:
         - name: hotel_id
           type: string
           description: The ID of the hotel to cancel.
       statement: UPDATE hotels SET booked = B'0' WHERE id = $1;
   

4. Run the Toolbox server, pointing to the tools.yaml file created earlier:

   ./toolbox --tools_file "tools.yaml"
   

Step 3: Connect your agent to Toolbox

In this section, we will write and run a LangGraph agent that will load the Tools from Toolbox.

1. In a new terminal, install the toolbox-langchain package.

   pip install toolbox-langchain
   

2. Install other required dependencies:

   # TODO(developer): replace with correct package if needed
   pip install langgraph langchain-google-vertexai
   # pip install langchain_google_genai
   # pip install langchain_anthropic
   

3. Create a new file named langgraph_hotel_agent.py and copy the following code to create a LangGraph agent, based on their Hotels example:

   import asyncio
   
   from langgraph.prebuilt import create_react_agent
   # TODO(developer): replace this with another import if needed
   from langchain_google_vertexai import ChatVertexAI
   # from langchain_google_genai import ChatGoogleGenerativeAI
   # from langchain_anthropic import ChatAnthropic
   from langgraph.checkpoint.memory import MemorySaver
   
   from toolbox_langchain import ToolboxClient
   
   prompt = """
     You're a helpful hotel assistant. You handle hotel searching, booking and
     cancellations. When the user searches for a hotel, mention it's name, id, 
     location and price tier. Always mention hotel ids while performing any 
     searches. This is very important for any operations. For any bookings or 
     cancellations, please provide the appropriate confirmation. Be sure to 
     update checkin or checkout dates if mentioned by the user.
     Don't ask for confirmations from the user.
   """
   
   queries = [
       "Find hotels in Basel with Basel in it's name.",
       "Can you book the Hilton Basel for me?",
       "Oh wait, this is too expensive. Please cancel it and book the Hyatt Regency instead.",
       "My check in dates would be from April 10, 2024 to April 19, 2024.",
   ]
   
   def main():
       # TODO(developer): replace this with another model if needed
       model = ChatVertexAI(model_name="gemini-1.5-pro")
       # model = ChatGoogleGenerativeAI(model="gemini-1.5-pro")
       # model = ChatAnthropic(model="claude-3-5-sonnet-20240620")
   
       # Load the tools from the Toolbox server
       client = ToolboxClient("http://127.0.0.1:5000")
       tools = client.load_toolset()
   
       agent = create_react_agent(model, tools, checkpointer=MemorySaver())
   
       config = {"configurable": {"thread_id": "thread-1"}}
       for query in queries:
           inputs = {"messages": [("user", prompt + query)]}
           response = agent.invoke(inputs, stream_mode="values", config=config)
           print(response["messages"][-1].content)
   
   main()
   

4. Run your agent, and observe the results:

   python langgraph_hotel_agent.py