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

title, type, weight, description

title	type	weight	description
Prompts using Gemini CLI	docs	5	How to get started using Toolbox prompts locally with PostgreSQL and [Gemini CLI](https://pypi.org/project/gemini-cli/).

Before you begin

This guide assumes you have already done the following:

1. Installed PostgreSQL 16+ and the psql client.

Step 1: Set up your database

In this section, we will create a database, insert some data that needs to be accessed 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.

   {{< notice info >}}

Having trouble connecting?

• Password Prompt: If you are prompted for a password for the postgres user and do not know it (or a blank password doesn't work), your PostgreSQL installation might require a password or a different authentication method.
• FATAL: role "postgres" does not exist: This error means the default postgres superuser role isn't available under that name on your system.
• Connection refused: Ensure your PostgreSQL server is actually running. You can typically check with sudo systemctl status postgresql and start it with sudo systemctl start postgresql on Linux systems.

Common Solution

For password issues or if the postgres role seems inaccessible directly, try switching to the postgres operating system user first. This user often has permission to connect without a password for local connections (this is called peer authentication).

sudo -i -u postgres
psql -h 127.0.0.1

Once you are in the psql shell using this method, you can proceed with the database creation steps below. Afterwards, type \q to exit psql, and then exit to return to your normal user shell.

If desired, once connected to psql as the postgres OS user, you can set a password for the postgres database user using: ALTER USER postgres WITH PASSWORD 'your_chosen_password';. This would allow direct connection with -U postgres and a password next time. {{< /notice >}}

1. 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;
   

2. End the database session:

   \q
   

   (If you used sudo -i -u postgres and then psql, remember you might also need to type exit after \q to leave the postgres user's shell session.)

3. Connect to your database with your new user:

   psql -h 127.0.0.1 -U toolbox_user -d toolbox_db
   

4. Create the required tables using the following commands:

   CREATE TABLE users (
     id SERIAL PRIMARY KEY,
     username VARCHAR(50) NOT NULL,
     email VARCHAR(100) UNIQUE NOT NULL,
     created_at TIMESTAMPTZ DEFAULT NOW()
   );
   
   CREATE TABLE restaurants (
     id SERIAL PRIMARY KEY,
     name VARCHAR(100) NOT NULL,
     location VARCHAR(100)
   );
   
   CREATE TABLE reviews (
     id SERIAL PRIMARY KEY,
     user_id INT REFERENCES users(id),
     restaurant_id INT REFERENCES restaurants(id),
     rating INT CHECK (rating >= 1 AND rating <= 5),
     review_text TEXT,
     is_published BOOLEAN DEFAULT false,
     moderation_status VARCHAR(50) DEFAULT 'pending_manual_review',      
     created_at TIMESTAMPTZ DEFAULT NOW()
   );
   

5. Insert dummy data into the tables.

   INSERT INTO users (id, username, email) VALUES
   (123, 'jane_d', 'jane.d@example.com'),
   (124, 'john_s', 'john.s@example.com'),
   (125, 'sam_b', 'sam.b@example.com');
   
   INSERT INTO restaurants (id, name, location) VALUES
   (455, 'Pizza Palace', '123 Main St'),
   (456, 'The Corner Bistro', '456 Oak Ave'),
   (457, 'Sushi Spot', '789 Pine Ln');
   
   INSERT INTO reviews (user_id, restaurant_id, rating, review_text, is_published, moderation_status) VALUES
   (124, 455, 5, 'Best pizza in town! The crust was perfect.', true, 'approved'),
   (125, 457, 4, 'Great sushi, very fresh. A bit pricey but worth it.', true, 'approved'),
   (123, 457, 5, 'Absolutely loved the dragon roll. Will be back!', true, 'approved'),
   (123, 456, 4, 'The atmosphere was lovely and the food was great. My photo upload might have been weird though.', false, 'pending_manual_review'),
   (125, 456, 1, 'This review contains inappropriate language.', false, 'rejected');
   

6. End the database session:

   \q
   

Step 2: Configure Toolbox

Create a file named tools.yaml. This file defines the database connection, the SQL tools available, and the prompts the agents will use.

kind: sources
name: my-foodiefind-db
type: postgres
host: 127.0.0.1
port: 5432
database: toolbox_db
user: toolbox_user
password: my-password
---
kind: tools
name: find_user_by_email
type: postgres-sql
source: my-foodiefind-db
description: Find a user's ID by their email address.
parameters:
  - name: email
    type: string
    description: The email address of the user to find.
statement: SELECT id FROM users WHERE email = $1;
---
kind: tools
name: find_restaurant_by_name
type: postgres-sql
source: my-foodiefind-db
description: Find a restaurant's ID by its exact name.
parameters:
  - name: name
    type: string
    description: The name of the restaurant to find.
statement: SELECT id FROM restaurants WHERE name = $1;
---
kind: tools
name: find_review_by_user_and_restaurant
type: postgres-sql
source: my-foodiefind-db
description: Find the full record for a specific review using the user's ID and the restaurant's ID.
parameters:
  - name: user_id
    type: integer
    description: The numerical ID of the user.
  - name: restaurant_id
    type: integer
    description: The numerical ID of the restaurant.
statement: SELECT * FROM reviews WHERE user_id = $1 AND restaurant_id = $2;
---
kind: prompts
name: investigate_missing_review
description: "Investigates a user's missing review by finding the user, restaurant, and the review itself, then analyzing its status."
arguments:
  - name: "user_email"
    description: "The email of the user who wrote the review."
  - name: "restaurant_name"
    description: "The name of the restaurant being reviewed."
messages:
  - content: >-
      **Goal:** Find the review written by the user with email '{{.user_email}}' for the restaurant named '{{.restaurant_name}}' and understand its status.
      **Workflow:**
      1. Use the `find_user_by_email` tool with the email '{{.user_email}}' to get the `user_id`.
      2. Use the `find_restaurant_by_name` tool with the name '{{.restaurant_name}}' to get the `restaurant_id`.
      3. Use the `find_review_by_user_and_restaurant` tool with the `user_id` and `restaurant_id` you just found.
      4. Analyze the results from the final tool call. Examine the `is_published` and `moderation_status` fields and explain the review's status to the user in a clear, human-readable sentence.

Step 3: Connect to Gemini CLI

Configure the Gemini CLI to talk to your local Toolbox MCP server.

1. Open or create your Gemini settings file: ~/.gemini/settings.json.

2. Add the following configuration to the file:

   {
     "mcpServers": {
       "MCPToolbox": {
         "httpUrl": "http://localhost:5000/mcp"
       }
     },
     "mcp": {
       "allowed": ["MCPToolbox"]
     }
   }
   

3. Start Gemini CLI using

   gemini
   

   In case Gemini CLI is already running, use /mcp refresh to refresh the MCP server.

4. Use gemini slash commands to run your prompt:

   /investigate_missing_review --user_email="jane.d@example.com" --restaurant_name="The Corner Bistro"