Extend FastMCP servers with AI transcript

Hi, everyone. I'm Sanket, a Google Developer Expert in Cloud. We have all seen how AI is changing the way we write code. But the real opportunity isn't just writing the code faster; it's helping us understand, extend, test, and deploy existing applications more efficiently. I'm building a new storage analytics feature for our existing FastMCP application that manages Google Cloud storage resources. So, let's get started.

Today, we are not building a new application from scratch. We are extending an existing codebase, which is exactly how most real-world software development works. Using Antigravity CLI, we will ask it to understand the existing project and implement new tools. The first tool provides a storage summary, giving us a quick overview of bucket size and file types. The second tool analyzes how the storage is distributed, calculating the cost, etc.

And the third tool finds the stale or large objects that may need cleanup to help optimize storage usage. So that's our roadmap. We already have a working FastMCP server, and now we will use an AI agent with Antigravity CLI to extend it with a new analytics module. Before modifying an unfamiliar codebase, we enter a plan phase to understand what already exists. I'll run the command agy to open my Antigravity CLI. This is my Antigravity CLI.

To understand the existing codebase, I will type the command agy analyze .. So as you can see from the screen, it lists the directories, it will read all those particular files which are present inside. Each and every information about the functions that are present in main.py. For example, if I open main.py, it will understand this is the particular MCP function, it will initialize the MCP, it has some particular modules, it has some packages and the libraries of Python, and it will understand MCP tool functions, and then it will go through all those particular things and has context around it.

Now, as a user, we will also be getting a detailed summary of what exactly our Python functions are all about. If you see, it is just having the context around all the files which are present in this particular directory: pyproject.toml, settings.json, main.py (in which our main logic is there), and you can see what exactly is its function; it is explaining many things. Now, rather than spending time investigating files and navigating the files manually, my Antigravity CLI will quickly analyze all files which are present in my current directory and give us the architectural clarity that says, "Hey, this is what the files are all about." So I will just type the command: "Where should a new feature be added?" My Antigravity will analyze the codebase, and it will observe some patterns which are there inside the codebase.

For example, if you see this pattern called @mcp... Okay, this is the pattern that we can identify. But Antigravity CLI has also analyzed this in the background. So basically, @mcp.tool, it gives us a function that says, "Hey, this is the MCP tool, and this is the way you need to add any other functions in the future." So if the feature relies on additional system packages, it will also install some packages on top of it.

We got a pattern from Antigravity that says, "Hey, this is the function that needs to be added in this particular manner." Now, we will be moving into proto phase, where we will be actually building a new feature. So we will say agy add-module --feature storage-analytics. Instead of me manually writing hundreds of files or functions, Antigravity CLI understood my request, whatever I am giving to it, and it asked that, "Hey, this is the regex pattern I have analyzed in the background.

This is the context that I do have. Now on top of it, I will create a function, and I will tell you, 'Hey, this is the feature that is to be added in this particular way.'" So if you see, it is created with the help of @mcp.tool. It knows that, "Hey, this is the package you need to import." And while going down the line, we can see there are different kinds of packages which will be installed, and there are different types of tools that are going to be called.

For example, if we want to get metadata of the bucket, it has some pattern in the loop, and we have something called bucket name, locations, and storage bucket. And it has also added some exception handling. If, let's say, there are lots of data and I want to list out the largest object which is present inside my bucket, so I don't want to write this logic manually. I will say, "Antigravity, can you please add this?" These particular functions also need to be registered as an MCP tool.

It will actually write a production-ready code, and it will add this particular MCP tool as decorators inside the file that it will be creating. So I will just accept the changes and let the wonder happen. I have given the permission to add that particular function. It is showing me that, "Hey, this is your function. I want to delete some things." I will just accept the change. The agent isn't generating the code in isolation; it's extending the existing codebase.

I will just accept this change. So it has generated this particular file called storage_analytics.py. I'll just accept the changes. Once this is complete, we will see that it has created three Python functions, three MCP tools which were added. And now we have our implementation done, right? Now, the next step is validation. Instead of writing test cases manually, I will run the agy generate-tests command. This automatically generates our pytest test cases for a new module that we have generated now.

I will just give it permission. So instead of calling the real network API calls, it will just mock the data. Like, for example, rather than entering me a bucket name to a real bucket name, it will just mock the data and it will just do a pytest testing beside it. As you can see, this file is created. It wants to add some mock data into it. It has created a file called test_main for these particular functions which were present earlier.

So there were three functions; for each of the function, it will write a unique test case. And then instead of me doing this stuff and writing the code manually, I can say, "Antigravity, please generate my test cases". So this is how my test cases will look like. I will go back to my terminal and see my test cases that were generated. I will just select, "Yes, allow." The test cases were generated for both of these things: test_main.py and storage_analytics.

These are the three functions which were created, and then it has generated some mock data for it. And this is a test_main code that we do have earlier functions as well. So it has generated the test cases for it. I will just accept the change. So as you can see, the test suite structure contains these particular things: __init__.py, test_main.py, and storage_analytics.py. And 14 test cases were passed successfully. In less than one minute, we have just created our test cases, passed through it, and then we are ready to deploy a particular function or, let's say, a new tool using this particular Antigravity CLI.

The implementation is completed. As you can see, all the test cases passed successfully in under a second. This gives us the confidence that our new storage analytics module that we have created is working as expected before we deploy it to Cloud Run. Now, we move into the build phase and deploy our application to Google Cloud Run. So I will run the command: gcloud run deploy. While this command is running, let's see what happens behind the scenes.

First, the Cloud will get triggered in the background. Cloud Build will package code which will be there inside this machine. After that, once Cloud Build is complete, it will just package the code with the help of Docker, containerize it, and push it to Google Artifact Registry. After it's pushed through to Google Artifact Registry, it will deploy it to Cloud Run. So it will create a revision, and it will deploy that revision to a particular Google Cloud Run.

And once we have a URL, we will have our MCP tools which is defined in and deploy it with a URL, and then we will say, "Hey, Antigravity, please just call my server that you have deployed on." We don't need to manually take that link, go to settings.json and add this particular. So Antigravity has a good feature that will understand the context and it will replace the existing Cloud Run link, if you have, to a new Cloud Run link if it is present.

Now we can see the deployment to Google Cloud Run has been launched. In the meantime, we can also look to Cloud Build. See, the Cloud Build has triggered. So what's happening in the background is it is going through your code and packaging the code with the help of container, Docker. After the building phase, it will push to Google Artifact Registry. After the Artifact Registry has your build number and the SHA value committed, tagged to it, it will just deploy that revision to Google Cloud Run.

And you'll have a public or private URL, depending on your use case. As you can see, this is the build running. What it is doing in the background is, as you can see, it is pulling the Python, it is just setting some environment variables. You can see it is successfully deployed now. Now if you want to go to Cloud Run and see the deployment, you can see the last updated is "Just now". It means it has just updated the revision right now.

You can also look through the logs. You can see FastMCP, right? This is where your MCP tool is running and it has created the service. Now everything is running fine. Now, let's go back to Antigravity CLI, and automatically it will go and set this Cloud Run URL to the settings.json so that you don't need to manually change anything into your IDE. It is updating your earlier Cloud Run with the new Cloud Run that it has deployed.

We just accept the change. Let's try some prompts. "I want to create a bucket with name india-2026 and add some dummy data inside it." This is the prompt that the user has given. After that, it will analyze it, and then it will call the MCP tools, like object upload, listing the bucket, for example. And we can also cross-check it like we can also say, "Which tool have you called?" We will be getting more context on it.

Now it has created a bucket called india-2026 and uploaded some URL into it. Now, we will just say: "List all the buckets." Now the thing is, we have implemented this particular module. Now, we can see the calculate total size and object count of this bucket. So let's enter a prompt and then it will hit this particular URL. I will just say: "Calculate total size of the objects and give me the largest object present in the india-2026 bucket." This is the storage analytics for india-2026.

It has given us the three objects, and we have the object name with 98 bytes. It has storage class because, if you see, it has all the functions and gives you your storage class, blob content type, and last modified things. So whatever you see here, we have here as well. And we can also call some functions. For example, we will just say: "Give me the metadata of india-2026 bucket." It will hit this particular MCP tool.

And we can also ask, "Which tool have you called?" So it will give the information about everything. So this is how we implemented a new feature from our existing codebase. In just a few minutes, we started with an unfamiliar codebase, used AI to understand it, extend it with a new feature, generated automated tests, and deployed it on Google Cloud Run — all without manually wiring the application together. That's the power of combining Antigravity CLI with the Google Cloud Platform.

AI becomes more than a code generator; it becomes an engineering partner that helps you understand, build, test, and deploy software faster. So if you want to try it yourself, the GitHub repository and the codelabs are in the description. Feel free to explore them, run the demo and build on top of it. Thank you for joining this session. I hope this inspires you to build the next application with AI-powered workflows.

Thank you!