Gemini CLI Tutorial Series — Part 6 : More MCP Servers | by Romin Irani | Google Cloud – Community | Jul, 2025

Welcome to Part 6 of the Gemini CLI Tutorial series.

Gemini CLI Tutorial Series:

Part 1 : Installation and Getting Started
Part 2 : Gemini CLI Command line options
Part 3 : Configuration settings via settings.json and .env files
Part 4 : Built-in Tools
Part 5: Using Github MCP Server
Part 6: More MCP Servers : Firebase, Google Workspace, Google Gen AI Media Services and MCP Toolbox for Databases (this part)

In the previous part, we looked at how to configure MCP Servers in Gemini CLI to augment its functionality and help it work with tools that work with our external systems. We saw how to configure Github Official MCP Server and in this part, we are going to look at additional MCP Servers, that I hope that you find useful. My goal is to cover a few of them, with installation instructions and a working use case or two. Feel free to skim through them, if these MCP Servers are not of immediate utility to your work. The essence of adding a MCP Server to Gemini CLI remains the same.

The documentation for Firebase MCP Server is here.

The Firebase MCP Server has a dependence on the Firebase CLI, so we will assume here that you are aware of the Firebase CLI and will need to have it available locally since you must authenticate with the CLI, before using the MCP Server.

The instruction to do that is:

npx -y firebase-tools@latest login --reauth

When you run the above command, it will open up a browser window for you to authenticate the account that you wish to use with Firebase. Go ahead, give it the necessary permissions and you should ideally see a page like this:

Add the following entry to the .gemini/settings.json file in the home directory.

"firebase": {
"command": "npx",
"args": [
"-y",
"firebase-tools@latest",
"experimental:mcp"
]
}

Once you launch Gemini CLI, you should be able to view that the MCP Server was started, connected to successfully and you can see the multiple tools that the Firebase MCP Server provides, if you use the /mcp command:

I have a few Firebase projects that I had created as part of this account, so my first step is just to check a few basic things:

And it does give out a list of Firebase projects. The key to working with a Firebase project would be to set the correct environment locally with Firebase initialization done, etc. So I ask about my current environment and it comes back well saying that the current directory has none of that initialized.

So I ask it to initialize Firebase in the current directory and it goes ahead and does that.

I query on the collections that I have and all the records in one of the collections:

If you are working with Firebase and wish to use Gemini CLI + Firebase MCP Server, do check out this codelab titled “Firebase MCP in Firebase Studio”. While the tool is Firebase Studio, you can go to Step 4 and try out the various scenarios/prompts.

Kanshi Tanaike is one of the most prolific writers on Google Cloud Medium publication, is a Google Developer Expert for Workspace and has written articles/code that push the limits of what one thinks is possible with Google Apps Script.

Kanshi has written a MCP Server, that provides the key skaffolding for the MCP Protocol in Apps Script and additionally, he has also written Workspace MCP Server that exposes multiple Workspace services/functionality as MCP tools. Both of these have been released as a Apps Script library. If you are interested in the specific details, you can refer to both of the articles given below:

In this section, we are simply going to follow the instructions given in this article to setup an Apps Script with the libraries installed, deploy the MCP Server as a Web App and then configure it in the Gemini CLI to give it superpowers to work directly with our Google Workspace services like Google Docs, Sheets, Slides, etc. Let’s get started:

I will not recreate the steps here since Kanshi has already described them in detail in the following article. I am going to provide to you the MCP Server snippet that nees to go into the settings.json file that we have been using throughout.

"myworkspacemcpserver": {
"command": "npx",
"args": [
"mcp-remote",
"YOUR_APPSCRIPT_WEBAPP_URL"
],
"env": {}
}

Once Gemini CLI has been started with this MCP Server, you should be able to see the huge list of tools that are now available to you.

Do consider the above list of tools as a work in progress and something that you should check on regularly. For your reference, the projects that make this functionality available are open source over here:

I am going to try out a few prompts that simply amazed me with what is now possible directly from the Gemini CLI via the power of MCP and especially what Kanshi has done here.

Get the latest financial news for today for India and create a presentation 
titled "Latest Financial News - {put todays date}" and it should be 
for 3–5 minutes. Let the author name be "Romin Irani".

This will interact with a few tools. First up will the built-in GoogleSearch tool that we saw earlier in the series. It retrieves the latest financial information.

Once the data is there, it then identifies a tool from the Workspace MCP Server and asks for your permission. Go ahead, please !

Finally, we have the message that the presentation has been created (took about 30–45 seconds on average across a few runs).

And here is the presentation:

I hope this triggers a lot other ideas in you in working with Gemini CLI + Workspace MCP Server, written by Kanshi.

I tried a few other prompts (across various Google Workspace services). In this one, I asked it to get me live cricket scores and create a draft email.

The email was sitting in my draft folder. Nice work indeed !

Do check out Kanshi’s blog where multiple other prompts are covered.

Google’s Generative AI Media Services like Veo, Imagen, Chirp, Lyria and others need no introduction. It would be highly productive to have them integrated within Gemini CLI itself.

This is made possible by the Vertex AI Creative Studio, which is a project that demonstrates the capabilities of these services.

But what we are interested in, is the MCP Server for these services and you will get that information in the experiments/mcp-genmedia folder of this project.

In summary, there is a server for each kind of service i.e. Imagen, Veo, etc. You will need a way to run these servers locally. The way to do that is to clone the repository first and follow the instructions to build, install and then run these respective services.

The instructions for the installation and setup with Gemini CLI are given here.

I followed the instructions to build, install all the servers. The documentation then provides one large JSON blob to configure all these services in the settings.json file of Gemini CLI. I reproduce the same from the documentation. Ensure that you put this correctly in the settings.jsonfile and that you replace the Storage Bucket name and Google Cloud Project Id respectively.

Keep in mind that it will utilize the Application Default Credentials (ADC) on your local setup, so I assume that you know how to do that.

{
"mcpServers": {
"veo": {
"command": "mcp-veo-go",
"env": {
"MCP_REQUEST_MAX_TOTAL_TIMEOUT": "240000",
"MCP_SERVER_REQUEST_TIMEOUT": "30000",
"GENMEDIA_BUCKET": "YOUR_GOOGLE_CLOUD_STORGE_BUCKET",
"PROJECT_ID": "YOUR_GOOGLE_CLOUD_PROJECT_ID"
}
},
"imagen": {
"command": "mcp-imagen-go",
"env": {
"MCP_SERVER_REQUEST_TIMEOUT": "55000",
"GENMEDIA_BUCKET": "YOUR_GOOGLE_CLOUD_STORGE_BUCKET",
"PROJECT_ID": "YOUR_GOOGLE_CLOUD_PROJECT_ID"
}
},
"chirp3-hd": {
"command": "mcp-chirp3-go",
"env": {
"MCP_SERVER_REQUEST_TIMEOUT": "55000",
"GENMEDIA_BUCKET": "YOUR_GOOGLE_CLOUD_STORGE_BUCKET",
"PROJECT_ID": "YOUR_GOOGLE_CLOUD_PROJECT_ID"
}
},
"lyria": {
"command": "mcp-lyria-go",
"env": {
"GENMEDIA_BUCKET": "YOUR_GOOGLE_CLOUD_STORGE_BUCKET",
"PROJECT_ID": "YOUR_GOOGLE_CLOUD_PROJECT_ID",
"MCP_SERVER_REQUEST_TIMEOUT": "55000"
}
},
"avtool": {
"command": "mcp-avtool-go",
"env": {
"PROJECT_ID": "YOUR_GOOGLE_CLOUD_PROJECT_ID",
"MCP_SERVER_REQUEST_TIMEOUT": "55000"
}
}
}
}

On successful start of the Gemini CLI, the additional tools will now be visible when you give the /mcp command.

I will give the image generation (imagen) a try by giving the following prompt:

Here is the image that it generated. It’s beautiful but there is a flaw in what it generated if you know about Mumbai’s iconic landmarks and the mix up that it has done. But that’s not the point here.

Give the Google Gen AI Media Services MCP Servers a try.

If you are working with Databases, then I suggest that you look at MCP Toolbox for Databases. It is an open source MCP server for databases and supports a wide variety of databases, as shown below from their official documentation:

The MCP Toolbox for Databases provides executables depending on your operating system/architecture and you need to configure and run it locally. The database could be local or even remote (for e.g. a Cloud SQL instance running in Google Cloud).

Let’s first download the MCP Toolbox for Databases. Before we download create a folder on your machine that will host the MCP Toolbox binary.

mkdir mcp-toolbox
cd mcp-toolbox

Check out the releases page for your Operation System and Architecture and download the correct binary. I am using a Mac machine with the ARM chip, so here is the script that I am using for the latest version of Toolbox:

export VERSION=0.9.0
curl -O https://storage.googleapis.com/genai-toolbox/v$VERSION/darwin/arm64/toolbox
chmod +x toolbox

Just keep the entire path to the toolbox ready, since we will need that when we configure this MCP Server in the Gemini CLI settings.json file. On my machine, I setup the toolbox in the /Users/romin/toolbox-0.9.0 folder. So the entire path to the Toolbox binary is:

/Users/romin/toolbox-0.9.0/toolbox

You can refer to the official documentation on how to configure the various databases / data sources that you would the Toolbox to connect to. But one of the quickest ways to get started is via the --preview option for some of the databases that are supported. For e.g. the --preview mode is supported for Google Cloud BigQuery database, so let’s try that out for my Google Cloud Project.

The MCP server entry that needs to go into the settings.json file is shown below:

"BigQueryServer": {
"command": "/Users/romin/toolbox-0.9.0/toolbox",
"args": ["--prebuilt", "bigquery", "--stdio"],
"env": {
"BIGQUERY_PROJECT": "YOUR_GOOGLE_CLOUD_PROJECT_ID"
}
}

Notice that the command parameter has the full path to the toolbox binary. When we start up Gemini CLI, we can see that additional MCP tools are available now:

Let’s query to see what datasets are available in my project. A sample run is shown below:

If you want to customize the tools i.e. the queries and the different options that are allowed, you will need to create a file named tools.yaml , in which all the data source configuration, toolsets, tools and queries will be configured. You will need to provide as a command line parameter while starting up the toolbox binary via the MCP Server option. Let’s configure one of the datasource to understand that better.

Here is a configuration for the tools.yaml file for connecting to a public BigQuery dataset in my Google Cloud Project.

sources:
my-bq-source:
kind: bigquery
project: YOUR_PROJECT_ID
tools:
search_release_notes_bq:
kind: bigquery-sql
source: my-bq-source
statement: |
SELECT
product_name,description,published_at
FROM
`bigquery-public-data`.`google_cloud_release_notes`.`release_notes`
WHERE
DATE(published_at) >= DATE_SUB(CURRENT_DATE(), INTERVAL 7 DAY)
GROUP BY product_name,description,published_at
ORDER BY published_at DESC
description: |
Use this tool to get information on Google Cloud Release Notes.
toolsets:
my_bq_toolset:
- search_release_notes_bq

To configure this toolset/tool in Gemini CLI, we need to provide the command to configure and start the MCP Toolbox for Databases executable and provide the tools.yaml as shown above:

"BigQueryServer": {
"command": "/Users/romin/toolbox-0.9.0/toolbox",
"args": ["--tools-file", "tools.yaml", "--stdio"],
"env": {
"BIGQUERY_PROJECT": "YOUR_GOOGLE_CLOUD_PROJECT_ID"
}
}

Do check out the configuration documentation page for MCP Toolbox for Databases for more information.

This concludes our coverage of configuring various MCP Servers within Gemini CLI. We have only touched the surface in terms of the number of MCP Servers that are available and I encourage you to share any interesting ones in the comments. I wanted to also cover how to write your own MCP Server in this part, but I guess that is a bit different and not necessarily anything to do with Gemini CLI, so I shall cover it in a different blog post in the future, outside of this series. We still have a few things to cover in this series. Stay tuned.