Forem: Aryan Irani

Google Workspace Studio Tutorial: Turn Google Forms into a Full CRM - Auto Lead Capture, Personalized Emails & Team Notifications

Aryan Irani — Tue, 07 Apr 2026 16:53:56 +0000

As a consultant, I've learned one universal truth, The speed of your response determines the quality of your client relationships.

When a potential lead fills out a Get in Touch form on your website, they are at their peak level of interest. If you wait 24 hours to email them back, that interest cools down. If you don't log their details in a CRM immediately, they become a lost lead in your inbox.

In this tutorial, we are going to build a Lead Capture CRM Workflow in Google Workspace Studio. This agent doesn't just collect data - it manages the relationship, logs the lead, drafts the perfect welcome email, and alerts your team, all while you're doing something else.

The Workflow Logic: The Lead-to-Call Pipeline

Using Google Workspace Studio, the agent that we will build will do the following:

Automatically adds every new form submission to a professional Google Sheet
Uses Gemini to write a warm, personalized welcome email
Draft a personalized welcome email
Send you an instant alert in Google Chat.

If you missed the previous AI Email Labeller tutorial, start there for the basics. Prefer video? Click here.

Prefer to watch instead of read? Check out the video version of the guide here.

Prerequisites

Google Workspace Business, Enterprise, or Education plan with Gemini enabled
A Google Form ready (I used Consulting Business Inquiry Form)

A Google Sheet set up as your CRM (we'll map it live)

Step 1: Create the Flow & Add the Starter

Go to studio.workspace.google.com
Click + New flow and name it Lead Capture Agent: Forms to CRM, Email, and Chat
Click Choose a starter → Select When a form response comes in

Choose your form (in my case: Consulting Business Inquiry Form)

Step 2: Building the Ledger (Add a Row)

We need a single source of truth for our leads. Use the Add a row action to point to your Lead CRM Google Sheet.

Set Add row to After last data row. This instantly turns every submission into a clean, searchable CRM row. Map every form field to the correct column:

Timestamp → Step 1: Response time
Full Name → Step 1: Full Name
Work Email → Step 1: Work Email
Company → Step 1: Company (and so on for all fields)

Step 3: Ask Gemini to Write the Personalized Welcome Email

Click + Add step → Ask Gemini
Use this prompt:

Write a warm, professional, and personalized welcome email for a new lead based on the following form response. Make it friendly and mention that we've received their message and will get back to them soon. Use any available details like their name or company to make it feel unique.
Form Response: {{Step 1: Form response}}

Use the + Variables button to insert the specific Form response chip into your prompt. This is what grounds Gemini in your lead's actual data. This is where we go beyond simple data entry. Gemini turns raw form data into a human-sounding email.

Step 4: The Handoff (Gmail & Google Chat)

Finally, we put the agent to work:

Draft an Email: Use the Draft an email action to create a Gmail draft using the content Gemini just generated in Step 3.

Update Rows: Use the Update rows action to change the Lead Status to Draft Created and Welcome Email Sent to Yes. This gives you a bird's-eye view of your sales pipeline right inside your Sheet.

Pro-Tip: Ensure these columns exist in your Sheet first

Notify in Chat: Use the Notify me in Chat action to send an instant alert:

🚀 New Lead Captured:
Details: [Step 1: Form Response]
Email Draft: [Step 4: Email Body]
ID: [Step 4: Email ID]

Testing & Activation

Before you hand the keys of your lead intake over to an AI agent, you need to verify that it's connecting all the dots. Workspace Studio's Test Run feature is your best friend here. I tested with real leads (including the Project Quantum style inquiry and a general business inquiry). Once selected, go ahead and click on Start.

The agent:

Added the row instantly to the Sheet
Drafted a natural, personalized welcome email
Sent the email
Updated the status
Posted a clean notification in Chat

Once your test confirms that every step is green and the data is flowing correctly, it's time to go live. Go ahead and click the blue Turn on button. The agent is now live and will run on every new form submission.

Why this changes everything

By the time you open your laptop, your new lead is already in your CRM, a personalized email is drafted and waiting for your review, and your team is already celebrating the new opportunity in Google Chat.

You haven't just saved time - you've created a scalable sales process.

Conclusion

By the time you open your laptop, your new lead is already logged in your CRM, a personalized welcome email is drafted and waiting in Gmail, and your team has been notified in Chat.

You haven't just saved time - you've created a scalable, professional first-impression system that makes every potential client feel valued from the very first second.

This is the true power of Google Workspace Studio: turning simple forms into intelligent business processes that run 24/7 while you focus on what you do best.

What's Next?

This is the fourth tutorial of the Google Workspace Studio tutorial series. We've built Meeting Assistants, Inbox Gatekeepers, and now CRM Agents. But the possibilities are endless.

📺 Watch the full build: If you want to see exactly how I configured the logic gates for the CRM updates, check out the video in my Google Workspace Studio YouTube Playlist.

🚀 Join the Journey: Subscribe to my channel to see how we build more agents to solve real-world business problems.

💼 Consultation: Looking to deploy these AI agents across your entire team? Reach out via my website for a custom consultation.

Feel free to reach out if you have any issues/feedback at aryanirani123@gmail.com.

Google Workspace Studio Tutorial: Auto-Organize Your Inbox with Smart Labels & Priority Notifications

Aryan Irani — Thu, 02 Apr 2026 13:42:40 +0000

The average professional spends 28% of their workday reading and answering emails. But here's the problem, not all emails are created equal. A Pizza Discount doesn't deserve the same mental space as a Project Delay notification from a CEO.

So, I decided to fix it. I used Google Workspace Studio to build what I call an Email Organiser. It's an AI agent that actually reads my mail, labels it correctly, and - most importantly - only pings my Google Chat when something is actually on fire.

Here is how I built it (and how you can too, without writing a single line of code).

If you missed my previous tutorial on the Meeting Prep Agent, start there for the basics. Prefer to watch instead of read? Check out the video version of that guide here.

Prefer to watch instead of read? Check out the video version of the guide here.

What Is Google Workspace Studio? (Quick Recap)

Google Workspace Studio is Google's no-code AI agent builder (launched December 2025). It lets anyone describe a workflow in natural language, and Gemini builds the entire automation using your Gmail, Drive, Chat, Sheets, and more.

Key Features Used Here:

New email starter
Gemini-powered classification
Conditional actions (Decide step)
Add labels + Send Chat message

Prerequisites

Google Workspace Business, Enterprise, or Education plan with Gemini enabled
Access to studio.workspace.google.com
(Optional) Pre-create these Gmail labels: Urgent, Client, Internal, Marketing/Promo, Low Priority, Spam

Step 1: Add the Starter (Trigger)

Open studio.workspace.google.com and start a new flow. Name it something like AI Email Labeller + Priority Sorter.

Starter: Select When I get an email.
Settings: Keep it on All emails. We want this agent to act as our first line of defense for every message.

Step 2: The Logic Breakdown (The Extract Action)

After adding the When I get an email starter, the next crucial step is to let Gemini analyze the incoming email. In Workspace Studio, we use the Extract step (powered by Gemini) to intelligently process the email content.

In this step, we aren't just asking Gemini a question; we are using the Extract tool to pull specific metadata out of the raw email body. To make this reliable, we need to provide a rubric so the AI knows exactly how to judge your mail.

I've pointed it at the Email Body from Step 1 and created two custom fields. Think of this as giving Gemini a Rubric to follow. Instead of guessing, the AI is now acting as a professional assistant following a strict set of rules.

Here is how I configured the two custom content fields to make them Production-Ready:

1. Custom Field: Is High Priority

The Goal: A simple true/false result that we can use later to trigger a notification.
Description for Gemini:

Analyze the sentiment and urgency. Return 'true' ONLY if the email indicates a project-blocking issue, an immediate deadline (today/tomorrow), or a direct request for a deliverable from a known client. If it is a general update, a newsletter, or a 'thank you' note, return 'false'. Do not add any punctuation or extra text.

2. Custom Field: Classification

The Goal: This will be used to apply actual labels in your Gmail sidebar.
Description for Gemini:

Classify the email into exactly one of these categories: urgent, client, internal, marketing, newsletter or other.

Step 3: The Organization (Physical Labelling)

Now that Gemini has categorized our email in its mind, we need it to physically label the email in our Gmail inbox. This is where Step 3 comes in: the Add labels action.

Mapping the ID: First, we point the agent to the right email. In the Email to label field, use the + Variables **button to insert the[Step 1: Email ID]**. This ensures the agent is acting on the exact message that triggered the flow.
The AI-Powered Toggle: Notice the AI-powered labels switch. When you turn this on, you aren't just picking a static folder; you are giving Gemini permission to apply labels based on a description.

While Google provides great templates like Receipts or Meeting updates, the real power lies in the New AI-powered label button. This is where you can create a label that perfectly matches your workflow.

For example, I created a custom label called To Respond. Instead of a simple keyword search, I gave it this description:

Prioritize emails that require my direct action. This includes messages that ask a question, request a deliverable, need my review or approval, or are pending my response.
Crucially, exclude the following:

All automated notifications and system-generated emails (e.g., Drive file access requests, comment threads, or changes to shared documents).

All Google Calendar updates (accepted, declined, rescheduled, canceled) and meeting confirmations.

Broad announcements, newsletters, marketing, or promotional emails.

Informational notes that do not require a response, such as "thank you" messages.

By using custom descriptions, your labels become much more accurate than traditional Gmail filters. You aren't just looking for "Meeting" - you're looking for the intent to meet.

Step 4: Add the Decide Step (High Priority Check)

After classifying the email and applying the label, we need to decide whether this email is important enough to notify us in Google Chat.

This is where the Decide step comes in.

Click + Add step → Select Decide.
In the prompt field, paste the following: Is this email high priority?
Click the + Variables button and insert Step 2: Is High Priority.

The full prompt should now read something like:

Step 5: Check if the Decision is True

The Decide step only makes a decision - it doesn't automatically route the flow. We need a Check if step to act on that decision.

Click on Step 5: Check if
Set the condition as follows:

If → Select Step 4: Decision
is → true

This creates two paths:

True branch: High-priority emails (Urgent or Client) → We will send a Chat notification.
False branch: Normal emails → No notification (they only get labeled).

This branching logic is what makes the agent smart - it only bothers you for important emails.

Step 6: Add Notify Me in Chat

Now we add the final action that only runs for high-priority emails.

How to Configure Step 6:

Make sure you are on Check if step (Step 5).
Click Add substep → Select Notify me in Chat.
In the Message field, create a clean and useful notification using variables. You can add or remove variables as needed.

Testing and Activation

Now that the full flow is built, it's time to test it with real emails. I sent two very different emails to my inbox. I wanted to see if Gemini could distinguish between an important email and a casual request.

Case 1: High Priority

I sent an email regarding Project Quantum - Final Contract Feedback & Signature Required.

Back in the studio, go ahead and click on Test run and select the email you would like to work on, which in this case is the Project Quantum email. Once selected, click on Start.

The Content: It mentioned a London hub deployment and a deadline of today.
The Result: Gemini nailed it. In the Test Run, it identified that a signature was needed (Step 2 extraction: true) and classified it as a client request.

The Action: Because the priority was true, the Check if logic passed. My phone immediately pinged with a Google Chat notification: 🚨 High Priority Email Received.

Case 2: The Important but Quiet (Low Priority)

Next, I sent a follow-up: Question regarding the API Documentation.

Back in the studio, follow the same steps as we did previously to test the second email.

The Content: Sarah had a few questions but explicitly said, No rush at all.
The Result: Gemini recognized that Sarah was asking a question, so it applied the To respond and Support label in my Gmail sidebar . However, it also read the No rush sentiment and set priority to false.

The Action: The Check if logic stopped the flow. No Chat notification. My focus remained unbroken, but the email was waiting for me in the right folder when I was ready for it.

Going Live (Turn On)
Once you are happy with the test results, click the blue Turn on button. Within a few seconds, you'll see a confirmation snackbar at the bottom left:

Your flow is on and ready to work!

From this point forward, the AI agent is my primary filter. It organizes the chaos in the background and only interrupts me when the work truly demands it.

Note: The agent only acts on new emails received after it is turned on. Existing emails in your inbox will not be processed retroactively.

Conclusion

You now have a fully functional AI Email Labeler + Priority Sorter running in your Gmail.

It intelligently classifies every incoming email, applies the right label, and only notifies you when something genuinely requires your attention - giving you back hours of focus every week.

This is the real power of Google Workspace Studio: turning repetitive manual work into intelligent, automatic systems.

What's Next?

This is only the beginning of our journey with Google Workspace Studio. I have a full roadmap of content coming your way to help you master every corner of this platform:

🚀 More Workflows: Stay tuned as we build dedicated AI agents for HR Onboarding, Sales Lead Management, and Automated Expense Tracking.
🧠 Deep-Dive Tutorials: I'll be releasing specific guides on mastering Variables, optimizing your Starter triggers, and advanced Prompt Engineering to make Gemini even smarter.
📺 Follow the Youtube Playlist: You can catch every click-by-click build and all upcoming tutorials in my Google Workspace Studio Tutorial Series Playlist on YouTube.

Feel free to reach out if you have any issues/feedback at aryanirani123@gmail.com.

Google Workspace Studio Tutorial: Building an AI Meeting Prep Agent

Aryan Irani — Mon, 30 Mar 2026 08:48:00 +0000

We've all been there, where you have 60 seconds before your next meeting starts. You're searching your inbox for that one PDF a client sent three days ago, or trying to remember what was discussed in last week's thread.

In the past, you needed a human Chief of Staff or a complex web of Python scripts to solve this. Today, you just need Google Workspace Studio.

In this tutorial, we are going to build a Meeting Prep Agent. This AI agent will automatically wake up 15 minutes before any meeting on your calendar, scan your recent emails and documents for context, and send a concise Google Doc directly to your Google Chat.

If you haven't read my previous tutorial on building your first AI agent in Workspace Studio, start there for the basics. Prefer to watch instead of read? Check out the video version of that guide here.

Prefer to watch instead of read? Check out the video version of the guide here.

What Is Google Workspace Studio? (Quick Recap)

Google Workspace Studio is a no-code AI agent builder launched in December 2025. It lets anyone describe a workflow in plain English, and Gemini builds the automation flow for you.

Agents run securely inside your Google Workspace, respecting all your organization's permissions and data policies. No Apps Script, no third-party tools - just natural language and seamless integration with Calendar, Gmail, Drive, and Chat.

Key Features Relevant Here:

Based on a meeting starter - triggers relative to calendar events (e.g., 15 minutes before)
Powerful Gemini AI steps for summarization and reasoning
Variables that automatically pull meeting title, attendees, description, and more
Actions like creating Docs, sharing files, and sending Chat messages

Prerequisites

A Google Workspace Business, Enterprise, or Education plan with Gemini enabled
Access to Google Workspace Studio at studio.workspace.google.com
Make sure your admin has turned on the necessary features if you don't see Studio

The Workflow Logic

To build this, we'll use a specific four-part logic within the Workspace Studio editor:

The Starter: Triggered by a Calendar event (15 minutes before start).
The Research: Gemini scans your Workspace (Emails/Docs) for the meeting's participants and topic.
The Synthesis: Gemini summarizes the Latest State of Play.
The Delivery: The briefing is sent to you via Google Chat and saved as a Google Doc for your notes.

Step 1: Setting the Meeting Starter

Navigate to studio.workspace.google.com and create a new flow. Instead of using the Describe to Design box, we'll build this manually to ensure precision.

Click on Choose a Starter and select Based on a meeting.

You can always select a specific meeting, but for this case go ahead and select Every meeting.
Timing: Set this to 15 minutes before.
Start: You have the option to select Before and After meeting. Since the user needs to prepare for an upcoming meeting we are selecting Before meeting.

Once done, go ahead and click on Choose a step.

Step 2: Adding the Research Step

Now we need the agent to find the context. Add a new step and select Ask Gemini.

This opens the configuration window where you can talk to the AI in natural language. This is where you tell Gemini exactly what to look for. Because this agent is grounded in your Workspace, it can read your history to prepare you.

In the Enter a prompt box, copy and paste this structure:

I have an upcoming meeting. Here are the details:
Title: [Step 1: Meeting title]
Description: [Step 1: Event description]
Attendees: [Step 1: All guest full names]
Please search my recent emails with these attendees and any related Drive files to create a concise meeting briefing. Include key objectives, recent discussion points, and any action items I should be aware of.

Don't just type the bracketed text! Click the + Variables button in the bottom right of the prompt box. This allows you to select the Blue Chips from Step 1.

By mapping the Meeting Title, Description, and Attendee Names, you are giving Gemini the specific search terms it needs to scan your history.

Look at the bottom of the Ask Gemini panel. Under Sources Gemini can use, ensure All sources is selected.

Web Search: This allows Gemini to look up recent public news about the attendees or their companies.
Workspace: This is the magic part - it allows Gemini to securely read your internal emails and Drive files to find those specific action items mentioned in the prompt.

Step 3: Generating the Permanent Record (Create a Doc)

Once Gemini has finished its research, we want that information saved somewhere accessible. We'll use the Create a doc action to generate a dedicated briefing file in Google Drive.

Dynamic Naming: In the New doc name field, type Meeting Brief: and then use the + Variables button to insert the [Step 1: Meeting title] chip. This ensures every doc is perfectly organized and searchable in your Drive.
Populating Content: In the Content to add field, we don't want the raw meeting description; we want the intelligence Gemini just gathered. Insert the variable [Step 2: Content created by Gemini].
Location: : By default, your file will be saved in your My Drive root folder. However, if you want to choose a custom location, you can click on the Drive button to launch the Drive Picker.

Step 4: The Final Push (Notify me in Chat)

The last step is the delivery. Since you're likely on the move or prepping between calls, a Google Chat notification is the fastest way to get your briefing.

In the Message box, we are going to combine text with variables from all three previous steps to create a high-value notification:

The Header: Type Ready for your meeting: and insert [Step 1: Meeting title].
The Summary: Add a header for Briefing Summary: and insert [Step 2: Content created by Gemini]. This gives you the TL;DR right inside the chat app.
The Deep Dive: Add Full Briefing Doc: and insert [Step 3: Link to doc].

By including the link from Step 3, you can jump from your Chat app directly into the formatted Google Doc if you need more details during the meeting.

Step 5: Testing and Activation

With your logic built, it's time to move from Design to Deployment. Google Workspace Studio offers a powerful way to verify your agent before it goes live.

The Test Run (Verification)
Before you commit to the automation, click the Test run button at the bottom of the editor. This opens a configuration panel on the right.

Select a Meeting: In the Meeting dropdown, select an actual upcoming event from your calendar.
Execute: Click Start.
Important Note: A test run takes real actions. It will actually create the Google Doc in your Drive and send the message to your Google Chat. Use this to verify that the Gemini summary looks exactly how you want it.

Workspace Studio provides real-time feedback. As the agent runs, you'll see green checkmarks appear next to each step.

Step 1 & 2: Gemini immediately identifies the attendees, extracts the key objectives (server migration, budget gaps, GDPR compliance), and - most impressively - performs a Related File Search. It finds training scripts and meeting note folders related to Project Quantum inside your Drive.

Completion: Once you see the green Run Completed banner, the flow has successfully traversed from your calendar to your inbox, through Gemini's brain, and out to your productivity tools.

Going Live (Turn On)
Once you are happy with the test results, click the blue Turn on button. Within a few seconds, you'll see a confirmation snackbar at the bottom left:

Your flow is on and ready to work!

Your AI Meeting Assistant is now officially on duty. It will sit silently in the background and trigger automatically 15 minutes before every meeting on your calendar.

The true power of this agent is visible in the output it creates for you. Within seconds of the trigger, two things happen:

1. The Google Chat Briefing

You receive a notification from the AI Meeting Assistant app. It's not just a reminder; it's a full executive summary. It lists the date, time, attendees with their email links, and the core purpose of the meeting. It even includes a Note on Action Items - even if none were found, it gives you the peace of mind that it actually checked.

2. The Professional Briefing Doc

Simultaneously, a new document titled Meeting Brief: Project Quantum - EMEA Infrastructure Pivot Review is created in your Drive. This is a perfectly formatted document containing all the context Gemini gathered. You can open this doc during your call to take notes, knowing your background research is already done and documented.

Conclusion

By building this Meeting Prep Agent, you've done more than just automate a few clicks; you've fundamentally changed your relationship with your calendar. Instead of spending your day searching for context, you are now spending your day acting on it.

This workflow is a Force Multiplier. While you are focused on your current task, your AI agent is already working 15 minutes into the future, ensuring you walk into your next conversation with total confidence.

What will you build next?

The "Meeting Prep" agent is just the beginning. You can now take these same principles - Starters, Variables, and Actions - and apply them to every corner of your work.

Ready to dive deeper?

📺 Watch the Video: If you prefer a click-by-click walkthrough of this build, check out the video version in my Google Workspace Studio YouTube Playlist.
🚀 Master the Basics: If you're just starting out, read my previous deep-dive on Datcamp's Blog, to learn about different starters and logic flows.
💼 Custom Solutions: Looking to deploy these AI agents across your entire organization? Feel free to reach out via my website for a custom consultation.

Reflections on my Trainings: Gemini for Google Workspace

Aryan Irani — Sat, 28 Mar 2026 02:42:46 +0000

It's always an incredibly rewarding experience to engage with professionals eager to embrace new technology, and my recent live training sessions on Gemini for Google Workspace were no exception.
I recently conducted live trainings on Gemini for Google Workspace with O'Reilly Media Inc. - and one thing became very clear very quickly:

Most people aren't struggling with AI tools.
They're struggling with how to think with them.

These weren't passive sessions. Over the course of 4 hours, professionals jumped in, experimented live, built prompts, refined outputs, and saw immediate results. The turnout and energy were incredible - but what stood out more than anything was how differently people approached the exact same tool. Some were instantly building workflows. Others were still testing one-off prompts.

That gap - that difference in approach - is what this post is really about.

The "Why": More Than Just a Tool, It's a New Way of Working

In today's world, efficiency isn't just a nice-to-have; it's essential. From my years working with businesses and developers using Google Workspace, I've seen the daily grind firsthand. The hours spent wrestling with spreadsheet formulas, agonizing over the perfect email tone, or just facing that daunting blank page to start a new document. Gemini isn't just another feature; it's a fundamental shift. It's about augmenting our human capabilities, not replacing them.

The Secret Sauce: Mastering Prompts with the CRISP Method (My Personal Take)

When I first started playing around with Gemini, I quickly realized that the real magic wasn't just in the AI itself, but in how we talk to it. This is where prompt engineering comes in. My personal journey into mastering prompts using the CRISP method, really came from a place of wanting consistent, high-quality results. I found that by consciously applying Context, Role, Instruction, Specifics, and Purpose, I could transform those vague requests into exactly what I needed.

It was only when I started to improve my prompts that I saw Gemini truly perform as a powerful analyst, writer, or assistant. Sharing that learning curve and giving others a shortcut to getting those great results was what I was looking at.

Gemini in Action across Google Workspace

We explored Gemini's capabilities across the core Google Workspace apps, and I loved seeing the immediate impact.

Google Docs

What We Did: Overcame writer's block, drafted content from outlines, summarized long documents, and even refined text for different tones.
My Observation: Seeing participants go from a blank page to a draft proposal summary in minutes was incredible. The Content Multiplier demo, where we took one piece of content and transformed it into a LinkedIn post, a YouTube script, and a senior executive email, always gets the biggest reaction. It highlights how Gemini can truly adapt to our communication needs and save hours of manual work.

Google Sheets

What We Did: Cleaned messy data with natural language, generated formulas without syntax, analyzed data, created pivot tables, and visualized insights with charts.
My Observation: The "aha!" moments here are always around data analysis and formula generation. Watching someone who admitted to dreading VLOOKUPs confidently ask Gemini to find the email for Employee ID 105 and get it instantly, or seeing them create a complex pivot table just by describing it - that's incredibly powerful. It democratizes data insight, making analysis accessible to everyone.

Google Slides

What We Did: Generated slides individually, created custom AI images, refined text, and produced speaker notes.
My Observation: The AI image generation is always a showstopper! It's amazing to see participants realize they don't need to be graphic designers to create stunning, unique visuals for their presentations. The Micro Pitch Deck exercise really showed how quickly you can build a professional presentation and speaker notes, making the process much more efficient.

Gmail

What We Did: Summarized long threads, used conversational search, drafted and refined emails.
My Observation: Taming the inbox is a universal challenge. The immediate relief participants feel when they see how quickly Gemini can summarize long threads or draft professional emails with the right tone is palpable. It's about giving back valuable time and boosting confidence in communication.

Automation (Apps Script)

We've covered Gemini's power within Docs, Sheets, Slides, and Gmail, focusing on immediate productivity gains. Now, let's look ahead to the next frontier: AI-Powered Automation.

While Gemini offers incredible built-in features, its true potential is unlocked when we integrate its intelligence into custom workflows. This is where Google Apps Script becomes invaluable. It's the bridge that allows us to automate repetitive tasks and build intelligent agents that can work for us in the background.

During the training, I had the opportunity to showcase some of the tools I've been developing:

Comment AI: Your AI Commenting Assistant for Google Docs

What it is: I demonstrated a prototype Apps Script add-on called Comment AI. This tool leverages Gemini to analyze the text of a Google Doc and then suggest relevant, context-aware comments or feedback directly within the document. It can help users identify areas for improvement, suggest alternative phrasing, or even flag potential compliance issues, all based on intelligent AI analysis.
The Potential: Imagine the time saved in review cycles! Instead of manually adding notes, Gemini can pre-analyze and suggest improvements, allowing reviewers to focus on strategic feedback.

You can find a step-by-step guide for this project here:

Gemini-Powered Google Drive File Labelling & Filling:

What it is: I also showcased another Apps Script project focused on Google Drive. This tool uses Gemini to understand the content of files stored in Drive. Based on that understanding, it can automatically apply consistent labels, extract key metadata, and even auto-fill relevant properties.
The Potential: Think about organizing your entire Drive! Gemini can help tag documents by project, client, or topic, making file retrieval exponentially faster and more efficient. This is a game-changer for knowledge management and team collaboration.

These projects are early-stage, but they exemplify the power of combining Google Apps Script with Gemini's AI. It's about creating custom solutions for specific business needs, turning logic and intent into automated, intelligent workflows. While we didn't build these live, seeing them in action provides a tangible glimpse into what's possible when you integrate AI into your specific operational processes.

You can learn more about this project and how to set it up in my tutorial here:

https://aryanirani123.medium.com/automating-google-drive-labels-with-google-apps-script-a-step-by-step-guide-f5dd1a5b20d8

https://medium.com/google-cloud/automating-google-drive-labels-with-gemini-and-apps-script-9acb7beab6f8

The Key Takeaway: The future isn't just about using AI tools; it's about building AI into your workflows. As these technologies evolve, your ability to harness them through custom solutions will become an increasingly valuable skill.

My Experience: From Preparation to Connection

Crafting this training wasn't just about listing features; it was about deeply understanding the challenges professionals face daily and then showing them a practical, actionable path forward with Gemini. My background as a Google Developer Expert means I'm constantly exploring these tools, so my focus was on bringing real-world scenarios and genuine business value to every demo and exercise.

Building those hands-on activities to simulate real business tasks - like creating that executive briefing or analyzing messy data - is critical for making the learning stick. It's incredibly rewarding to see participants engage, ask those insightful questions, and achieve those tangible results in just a few hours.

What's Next

The response to these live sessions has been overwhelmingly positive, and it truly energizes me to see so many professionals eager to adopt AI.

We're moving toward a world where AI literacy is a core skill - and the ability to integrate tools like Gemini into real workflows will be a major differentiator.

I'm currently working on turning this training into a structured, self-paced course so more people can learn and apply these concepts at their own pace.

If you're exploring Gemini for Google Workspace - whether individually or for your team - I'd love to hear how you're approaching it.

Stay Tuned: Keep an eye out for the upcoming video course version of this training - it will offer even more depth and flexibility for self-paced learning!

Thank you for reading and for your interest in harnessing the power of AI and Google Workspace.

Feel free to reach out if you have any issues/feedback at aryaniran123@gmail.com

Building & Deploying a Google Cloud Storage MCP Server to Cloud Run

Aryan Irani — Sat, 07 Feb 2026 07:25:41 +0000

Model Context Protocol (MCP) is changing how we connect LLMs to external data. While running MCP locally via stdio is great for testing, the real power comes when you deploy these servers to the cloud, making your tools available to any agent, anywhere.

In this guide, I'm going to walk you through building a Google Cloud Storage (GCS) MCP Server, containerizing it, and deploying it to Google Cloud Run.

We will cover:

The Server Logic: Writing our own custom MCP server.
Containerization: Docker setup for Cloud Run.
Deployment: Permissions and Cloud Build commands.
Verification: Testing with the MCP Inspector.

So let's get started.

The Server Logic (server.py)

The biggest challenge with deploying MCP servers is the transport. Locally, we usually use Stdio (standard input/output). In the cloud, we need SSE (Server-Sent Events) over HTTP.

I didn't want to maintain two separate scripts, so I wrote a single server.py that detects where it's running. If it sees a PORT environment variable (which Cloud Run injects), it spins up a web server.

Here is the implementation using FastMCP:

# server.py
import os
import logging
from mcp.server.fastmcp import FastMCP
from google.cloud import storage

# Initialize FastMCP
mcp = FastMCP("gcs-mcp-server")

# Initialize GCS Client
storage_client = storage.Client()

@mcp.tool()
def list_buckets() -> str:
    """Lists all Google Cloud Storage buckets in the project."""
    buckets = list(storage_client.list_buckets())
    return "\n".join([bucket.name for bucket in buckets])

@mcp.tool()
def create_bucket(bucket_name: str, location: str = "US") -> str:
    """Creates a new GCS bucket."""
    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "STANDARD"
    new_bucket = storage_client.create_bucket(bucket, location=location)
    return f"Created bucket {new_bucket.name} in {location}"

@mcp.tool()
def delete_bucket(bucket_name: str) -> str:
    """
    Deletes a GCS bucket. 
    WARNING: This forces deletion of all objects and versions inside.
    """
    bucket = storage_client.bucket(bucket_name)

    # Robust cleanup: List and delete all blob versions to avoid "Bucket not empty" errors
    blobs = list(storage_client.list_blobs(bucket_name, versions=True))
    for blob in blobs:
        blob.delete()

    bucket.delete(force=True)
    return f"Deleted bucket {bucket_name}"

if __name__ == "__main__":
    # DUAL MODE LOGIC
    if "PORT" in os.environ:
        # We are in Cloud Run -> Start an SSE Server
        import uvicorn
        port = int(os.environ["PORT"])
        print(f"Starting SSE server on port {port}...")

        # Critical for Cloud Run: Allow proxy headers and bind to 0.0.0.0
        uvicorn.run(
            mcp._sse_app, 
            host="0.0.0.0", 
            port=port, 
            proxy_headers=True, 
            forwarded_allow_ips='*',
            timeout_keep_alive=300 # Prevent SSE connection drops
        )
    else:
        # We are local -> Start Stdio Server
        mcp.run()

You'll notice I added some extra logic in delete_bucket. GCS is very protective; it won't let you delete a bucket if there's anything inside it. If you have Object Versioning turned on, a bucket might look empty but still have hidden archived files. My implementation explicitly hunts down every version and deletes it first.

Dockerizing (Keep It Simple)

We don't need a complex multi-stage build here. A simple Python slim image works perfectly.

The requirements.txt is minimal:

mcp[cli]
google-cloud-storage
uvicorn

And the Dockerfile:

FROM python:3.10-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD ["python", "server.py"]

Infrastructure Setup

Before we deploy, we need to make sure your CLI is pointing to the right place and your project has permissions.

Step 2.1: Initialize gcloud

Open your terminal. If you haven't logged in recently, run:

gcloud auth login
gcloud config set project <YOUR_PROJECT_ID>

Step 2.2: Grant Permissions

By default, Cloud Run cannot manage Storage buckets. We need to find the Service Account that Cloud Run uses and give it the Storage Admin role.

Run these commands in your terminal:

# 1. Get your Project ID and Number
export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

# 2. Grant the permission
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
    --role="roles/storage.admin"

Expected Output: You should see a YAML list of bindings updated with "Updated IAM policy for project [your-project-id]."

Deploying to Cloud Run

Instead of typing long commands every time, we use a deployment script. Save this as deploy.sh in your project folder.

#!/bin/bash
set -e

# Configuration
PROJECT_ID=$(gcloud config get-value project)
SERVICE_NAME="gcs-mcp-server"
REGION="us-central1"
IMAGE_NAME="gcr.io/${PROJECT_ID}/${SERVICE_NAME}"

if [ -z "$PROJECT_ID" ]; then
    echo "Error: No Google Cloud project selected. Run 'gcloud config set project <PROJECT_ID>' first."
    exit 1
fi

echo "Deploying ${SERVICE_NAME} to Project: ${PROJECT_ID}..."

# 1. Build the container image
echo "Building container image..."
gcloud builds submit --tag $IMAGE_NAME

# 2. Deploy to Cloud Run
echo "Deploying to Cloud Run..."
# Note: --allow-unauthenticated is used here for simplicity to allow easy testing.
# For production, remove this flag and configure IAM authentication.
gcloud run deploy $SERVICE_NAME \
    --image $IMAGE_NAME \
    --platform managed \
    --region $REGION \
    --allow-unauthenticated

echo "Deployment complete!"
echo "Service URL:"
gcloud run services describe $SERVICE_NAME --platform managed --region $REGION --format 'value(status.url)'

Running the Deployment

Now, make the script executable and run it:

chmod +x deploy.sh
./deploy.sh

What You Will See (Terminal Output)
Build Step: You will see a stream of logs starting with Creating temporary tarball... followed by Docker build steps (Step 1/5, Step 2/5). This ends with SUCCESS.
Deploy Step: You will see Deploying container to Cloud Run service [gcs-mcp-server] in project...

Success:


Service [gcs-mcp-server] has been deployed and is serving 100 percent of traffic.
Service URL: https://gcs-mcp-server-xyz-uc.a.run.app

Copy that Service URL. You need it.

Verification

Go to the Google Cloud Console and navigate to Cloud Run.

1. The Service Dashboard

Click on gcs-mcp-server. You should see a green checkmark indicating the service is healthy.

Revisions Tab: Ensure the latest revision is receiving 100% traffic.

Logs Tab: This is crucial. If your code crashes, this is where you look. You should see a log entry: Starting SSE server on port 8080.... If you see that, your code successfully detected the environment and started Uvicorn.

2. Testing with MCP Inspector

You don't need to write Python code to verify the server is working. Use the MCP Inspector from your terminal.
The Command:

npx @modelcontextprotocol/inspector \
  --transport sse \
  --server-url https://<YOUR-SERVICE-URL>/sse

Note: You MUST append /sse to the URL. The root URL / will likely give you a 404 or Method Not Allowed.

What You Will See: A web interface will open in your browser.

1.Start by establishing connection by clicking Connect.

2.On the left sidebar, click Tools and List Tools. You should see
list_buckets, create_bucket, and delete_bucket listed.

3.Click list_buckets and hit Run.

4.You should see a JSON response with your bucket names.

Conclusion

That's it! You've gone from a local script to a deployed, scalable microservice that acts as a tool for your AI agents.

By moving your tools to Cloud Run, you decouple them from your agent's runtime. Your agent can be a script on your laptop, a service in Vertex AI, or a workflow in a completely different environment - it doesn't matter. As long as it can hit that URL, it has access to your Google Cloud Storage tools.

2025 in Review: AI Agents, Automation, and a Year of Building

Aryan Irani — Tue, 27 Jan 2026 11:23:32 +0000

Every year since I started writing and working in tech, I’ve written a yearly recap — not just to list what I did, but to pause, acknowledge growth, and remind myself why I build in the first place.

2025 was a meaningful year for me. A year of graduating, publishing my add-ons to the Workspace Marketplace, teaching developers, experimenting with AI agents, and contributing to the Google Workspace and Gemini ecosystem in every way I could.

A Personal Milestone: Graduating as an Engineer

This year, I completed my Bachelor of Technology in Computer Engineering from NMIMS, Mumbai. It’s hard to overstate how special that moment was. Balancing final-year projects and exams with consistent writing, building tools, recording tutorials, and community engagement was challenging at times — but it all reinforced the discipline and problem-solving mindset that engineering instilled in me.

What starts as small experiments or hobby projects can grow into meaningful work when done consistently.

Graduating marked the close of one chapter and the exciting start of another, where I can now focus even more deeply on creating practical AI and automation solutions.

I graduated :) - Engineering was fun while it lasted. | Aryan Irani | 22 comments

I graduated :) - Engineering was fun while it lasted. | 22 comments on LinkedIn

linkedin.com

Mumbai Tech Week — Sharing My Work on a Big Stage

One of the year’s highlights was presenting at Mumbai Tech Week 2025, thanks to GDG MAD Mumbai and Faiz Malkani. I demoed two Gemini-powered projects live:

A Different Kind of Stage — My TEDx Talk

2025 also brought a deeply personal speaking experience — my TEDx talk at TEDxGEA Youth. This was the first time I stood in front of a crowd not to dive into tech tutorials or code demos, but to open up about myself, my journey, and the messy, human side of building a career in tech.

At 21, I shared how I went from a directionless 15-year-old to a technical writer and co-founder of MadLads Studios. It wasn’t about expertise or polished skills — it was about curiosity sparking everything: starting with simple book reviews, automating Gmail tasks, and embracing uncertainty along the way.

I talked about the messy middle of rejections, learning through failures, the importance of consistency over perfection, saying no to avoid burnout, finding joy in the process (my take on “JOMO” — Joy of Missing Out), and how belief from others (like a professor who trusted me to teach Python) ignited my path before I believed in myself.

Stepping outside my tech comfort zone felt vulnerable, but it was rewarding to connect on a more human level. If you’re navigating your own journey, I hope it resonates. Watch it here: Aryan Irani | TEDxGEA Youth (Uploaded October 2025).

Product Launches: My First Google Workspace Add-ons

One of the biggest professional steps this year was shipping two add-ons to the Google Workspace Marketplace — my first publicly available products built for real users:

SmartCheckbox — A no-code tool that automates checkbox updates in Google Sheets based on custom rules. Ideal for task management, approval workflows, and dynamic trackers. It includes real-time refresh, audit logs, and an intuitive sidebar setup. Install it here.

Sheet Protector Pro — One-click sheet protection with smart features: protect formulas/ranges, easy undo, audit history, and controlled editor sharing. Built for teams who need secure collaboration without the hassle. Install it here.

Launching these taught me invaluable lessons about user experience, Marketplace guidelines, permissions, and iterative polishing. Seeing people install and use them has been incredibly rewarding.

Live Trainings: Getting Started with Google Apps Script

I also ran my comprehensive Mastering Google Apps Script live training program — taking participants from beginner concepts to building advanced automations across Google Workspace. Watching attendees gain confidence, script their own solutions, and apply them to real workflows was one of the most fulfilling parts of the year.

The program is still available for anyone looking to level up their Workspace automation skills: Mastering Google Apps Script — Aryan Irani.

Gemini for Google Workspace Fundamentals — O’Reilly

I’m also thrilled to share that I’ll be leading an upcoming Gemini for Google Workspace Fundamentals live training with O’Reilly on January 22, 2026. It’s a hands-on course covering how to leverage Gemini’s AI capabilities across Docs, Sheets, Gmail, and more to boost productivity. From writing effective prompts to automating workflows, I’m excited to help developers and professionals unlock Gemini’s potential. Learn more and register here.

Writing: A Strong Year of Deep Technical Content

My writing this year became more focused on production-ready solutions — especially building AI agents that don’t just respond, but take meaningful actions. I published consistently on Medium (largely through Google Cloud Community), with a clear progression: starting with core Workspace + Gemini automations, moving into Agent Development Kit (ADK) basics, then deep into dynamic agents with MCP Toolbox for Databases, and finally deployment and Workspace integration.

Google Workspace & Gemini Automations

Fetch BigQuery Data to Google Sheets using Google Apps Script (Feb)
Generate Speaker Notes in Google Slides using Gemini 2.0 Flash and Google Apps Script (Feb)
Turn Google Docs into AI-Powered Podcasts with Google Cloud (Feb)
How to Use Service Accounts with Google Apps Script (Mar)
Turn Google Docs Comments into Actionable Summaries with Gemini and Apps Script (Oct)
Automating Google Drive Labels with Google Apps Script: A Step-by-Step Guide (Dec)
Automating Google Drive Labels with Gemini and Apps Script (Dec)

Getting Started with ADK & Practical Agents

Your First ADK Agent: Building a Google Tasks To-Do Manager (Jun)
Build Your Own AI Google Calendar Assistant with Agent Development Kit (Sep)
MCP Toolbox for Databases Course Series (Connecting Agents to Live Data)
Build an AI That Connects to Your Database: MCP Toolbox for Databases Course (Jul)
The Data Gap | Connecting an Agent to a LIVE Database (Jul)
Build Your First AI Agent with ADK (Jul)
Build Your First MCP Server (Aug)
The Quick Start to Dynamic AI Agents (Aug)

Advanced Builds, FinOps, and Custom Tools

NotebookLM 2.0: From Research Tool to Creative Powerhouse (Sep)
Building a Custom MCP Server for Gemini CLI: A Hands-on Guide (Sep)
Exporting Your Google Cloud Billing Data to BigQuery (Sep)
Build a Google Cloud FinOps Assistant Agent with ADK & MCP Toolbox (Sep)
Build a GCP Cost Agent with ADK and MCP Toolbox for Databases (Sep)

October Surge: Workspace Integration & Deployment

Create an AI-Agent in Google Workspace: Step-by-Step with ADK & Vertex AI Agent Engine (Oct)
Deploy Your ADK Agent to Vertex AI Agent Engine: A Complete Tutorial (Oct)
Turn Google Docs Into an AI Agent Hub: Integrate ADK Agents in Google Workspace (Oct)

SmartCheckbox Launch & Fun Experiments

Getting Started with SmartCheckbox™: Install, Setup, and Your First Rule (Oct)
Hands-On Tutorial — Build a Content Approval Workflow with SmartCheckbox (Oct)
Integrating Zomato’s MCP Server into Gemini CLI: AI-Powered Food Ordering in Your Terminal (Oct) — A lighter, experimental piece that was genuinely fun to build.

The work I’ve been doing isn’t just content, it’s helping shape how teams and developers think about productivity, automation, and AI.

Product Collaborations & Developer Education

A meaningful part of my work this year involved collaborating with product teams in a way that closely resembled developer education and advocacy. My role was to explore their platforms hands-on and produce developer use cases, getting-started guides, tutorials, and documentation that simplified adoption.

This work helped bridge the gap between product capabilities and how developers and users actually experience them.

The Not-So-Perfect Side — And What I Learned

Not every moment in 2025 sparkled. At one point during the year, I lost a client I was writing content for. The work itself wasn’t the issue. The problem was communication.

I was traveling to another city for a community talk and didn’t communicate clearly about timelines. A small delay, combined with silence on my end, led to misaligned expectations. Eventually, the client decided to move on.

It wasn’t a dramatic failure — just a quiet reminder of something important:
technical skill and good intentions don’t replace clear, proactive communication.

Reflections: What 2025 Taught Me

Looking back with humility, this year was about consistent progress over perfection. A few grounded lessons that stand out:

Shipping real products (like the add-ons) creates momentum nothing else can — even if they start small.
Agentic AI shines when grounded in reliable data and clear actions; the MCP series reinforced how crucial live database connections are.

Teaching and presenting amplify impact — the live training and Mumbai Tech Week, Devfest, CCDs reminded me that sharing knowledge openly builds community and sharpens your own understanding.
Balance and resilience matter — graduating while maintaining a steady output wasn’t always easy, but celebrating small wins kept the momentum going.

I’m quietly proud of how far the work has come, but I also know there’s so much more to explore.

Looking Ahead to 2026

I’m excited to go deeper: more sophisticated multi-agent systems, production-grade deployments, expanded add-on features, and perhaps new courses or tools. The goal remains the same — build practical solutions that make Google Workspace and AI more accessible and powerful for everyone.

Thank you to every reader, installer, attendee, and community member who engaged this year — your feedback, questions, and encouragement make all of this worthwhile.

P.S. Past recaps for the tradition: 2024, 2023, 2022, 2021.

Automating Google Drive Labels with Google Apps Script: A Step-by-Step Guide

Aryan Irani — Tue, 16 Dec 2025 14:36:20 +0000

Welcome !
If you manage a Google Workspace environment, you already know that folders only get you so far. Eventually, you need metadata - Status, Department, Sensitivity, or custom fields like Invoice Amount.

Google Drive Labels solve this by turning Drive into a structured metadata system, not just a file store.

But there's a catch: users hate tagging files. If you rely on humans to manually open the details pane and select Invoice and type in a date, it won't happen.

To make Drive Labels actually useful, you need to automate them.
In this guide, we are going to write some Google Apps Script that interacts with the Drive Labels API and Drive API to programmatically fetch label definitions, identify the correct fields, and apply them to files with specific metadata.

Prerequisites

Before writing a single line of code, a bit of setup is required. The Drive Labels API is not enabled by default in Apps Script projects.

Google Workspace edition

You'll need an edition that supports Drive Labels (Business Standard, Business Plus, or Enterprise).

Admin setup

Make sure at least one label (for example, Invoice) is published in the Admin Console under: Security → Access and Data Control → Label Manager

Apps Script services

Open your Apps Script project, click the + next to Services, and enable:

Drive API
Drive Labels API

The scripts - what each function does

fetchAvailableLabels() - lists published labels and returns a map
fetchLabelFields(labelId) - reads a label's fields and their types
applyLabelToFile(fileId, labelId) - applies a label to a file (no field values).
applyLabelAndUpdateFields(fileId, labelId, fields) - applies a label and updates field values (types handled: text, integer, date, selection).
fullLabelAutomation(fileId) - example chain that demonstrates label suggestion + applying fields.

You can check out the code by clicking on the link given below.

https://github.com/aryanirani123/Google-Apps-Script/blob/master/DriveLabelsAutomation.js

Fetching all available Drive labels

We start with the fetchAvailableLabels() function. This is the discovery step - before we can apply any label, we first need to know which labels are actually available and visible to our account.

function fetchAvailableLabels() {
  try {
    const response = DriveLabels.Labels.list({ view: "LABEL_VIEW_FULL" });
    const labels = response.labels || [];
    if (labels.length === 0) {
      Logger.log("No labels found. Check Workspace admin for published labels.");
      return {};
    }

    const labelMap = {};
    labels.forEach(label => {
      if (label.properties?.title) {
        labelMap[label.properties.title] = label.id;
      }
    });

    Logger.log(`Fetched ${labels.length} labels: ${JSON.stringify(labelMap)}`);
    return labelMap;
  } catch (error) {
    Logger.log(`Error fetching labels: ${error.message}`);
    return {};
  }
}

Inside the function we call DriveLabels.Labels.list({ view: "LABEL_VIEW_FULL" }); that hits the Drive Labels API and returns all published labels that the current user is allowed to see. Using LABEL_VIEW_FULL ensures we get complete metadata instead of just surface-level information.

Next we safely extract the labels array from the response. If nothing is returned, we log a message suggesting the user to check whether the labels are published in the Admin Console.

We then loop through each label and build a simple object map that looks like this:

{
  "Invoice": "label-id-123",
  "Contract": "label-id-456"
}

This mapping is extremely useful because it lets us refer to the labels by human-readable titles instead of IDs for the rest of the workflow.

Finally, we log the results and return the map. If anything fails (permission issues, API errors, etc), the catch block logs the error and returns an empty object instead of crashing the script.

At this point, we now have a clean list of usable labels.

Fetching fields for a specific label

Once we know which label we're working with, the next step is to understand its field structure. That's what the fetchLabelFields(labelId) does.

function fetchLabelFields(labelId) {
  try {
    if (!labelId) {
      throw new Error("labelId is required. Run fetchAvailableLabels() first and copy an ID.");
    }

    const response = DriveLabels.Labels.list({ view: "LABEL_VIEW_FULL" });
    const labels = response.labels || [];
    if (labels.length === 0) {
      Logger.log("No labels found. Check Workspace admin for published labels.");
      return {};
    }

    const targetLabel = labels.find(label => label.id === labelId);
    if (!targetLabel) {
      Logger.log(`Label ID "${labelId}" not found in available labels. Run fetchAvailableLabels() to verify.`);
      return {};
    }

    const fields = targetLabel.fields || [];
    if (fields.length === 0) {
      Logger.log(`No fields found for label ${labelId}.`);
      return {};
    }

    const fieldMap = {};
    fields.forEach(field => {
      const displayName = field.properties?.displayName;
      if (displayName) {
        let type = 'text'; // Default
        if (field.integerOptions) type = 'integer';
        else if (field.dateOptions) type = 'date';
        else if (field.selectionOptions) type = 'selection';

        fieldMap[displayName] = {
          id: field.id,
          type: type
        };
      }
    });

    Logger.log(`Fetched ${fields.length} fields for label ${labelId}: ${JSON.stringify(fieldMap)}`);
    return fieldMap;
  } catch (error) {
    Logger.log(`Error fetching fields for label ${labelId}: ${error.message}`);
    return {};
  }
}

The function starts with a validation check. If no labelId is passed, it immediately throws an error. This prevents silent failures and makes debugging much easier.

Instead of calling a label-specific endpoint, the function safely reuses the full labels list and searches for the label using labels.find(label => label.id === labelId);

If the label isn't found, we log a clear message telling the user to verify the ID using fetchAvailableLabels().
Once the correct label is found, we extract its fields. Each field represents a piece of structured metadata such as:

Invoice Number
Invoice Date
Vendor Name
Status (dropdown/select)

We then loop through each field and store:

The field ID
The field type (text, integer, date, or selection)

This creates another human-friendly mapping that looks like:

{
  "Invoice Number": { id: "field-id-1", type: "text" },
  "Invoice Date": { id: "field-id-2", type: "date" }
}

This step is critical because Drive does not allow us to update fields using display names - only IDs work. This function bridges that gap.

Applying a label to a file

With label IDs in hand, we move on to the write operation: attaching a label to a file using applyLabelToFile(fileId, labelId) .

function applyLabelToFile(fileId, labelId) {
  try {
    if (!fileId || !labelId) {
      throw new Error("fileId and labelId are required.");
    }

    const request = {
      kind: "drive#modifyLabelsRequest",
      labelModifications: [
        {
          kind: "drive#labelModification",
          labelId: labelId,
          removeLabel: false
        }
      ]
    };

    const response = Drive.Files.modifyLabels(request, fileId);
    Logger.log(`Label ${labelId} applied to file ${fileId}: ${JSON.stringify(response.modifiedLabels)}`);
    return response.modifiedLabels || [];
  } catch (error) {
    Logger.log(`Error applying label ${labelId} to file ${fileId}: ${error.message}`);
    return [];
  }
}

This function begins by validating that both fileId and labelId are present. If either is missing, we immediately fail with a clear message.

We then build a modifyLabels request object. The key pieces here are:

labelId -> which label to apply
removeLabel: false -> explicitly tells Drive to attach the label (not remove it)

This request is sent using Drive.Files.modifyLabels(request, fileId); . If successful, the Drive API returns a list of modified labels, which we log and return. If anything goes wrong - permission, invalid IDs, or API errors. We catch it and return an empty array instead of breaking the flow.

At this point, the file will now visibly show the label inside Drive → File Details → Labels.

Applying a label and updating its fields

The applyLabelAndUpdateFields() function is the heart of this entire automation. Up until this point, we've only been discovering what labels and fields exist. This is the moment where metadata actually gets written back to the file in Google Drive.

function applyLabelAndUpdateFields(fileId, labelId, fields) {
  try {
    if (!fileId || !labelId || !fields || fields.length === 0) {
      throw new Error("fileId, labelId, and non-empty fields array are required.");
    }

    const fieldModifications = fields.map(field => {
      let fieldMod = {
        kind: "drive#labelFieldModification",
        fieldId: field.id
      };

      const value = field.value;
      if (!value) {
        Logger.log(`Skipping field ${field.id}: No value provided.`);
        return null;
      }

      switch (field.type) {
        case 'selection':
          fieldMod.setSelectionValues = [value];
          break;
        case 'integer':
          const intVal = parseInt(value);
          if (!isNaN(intVal)) {
            fieldMod.setIntegerValues = [intVal.toString()];
          } else {
            Logger.log(`Invalid integer for field ${field.id}: ${value}`);
            return null;
          }
          break;
        case 'date':
          const date = new Date(value);
          if (!isNaN(date.getTime())) {
            const isoDate = date.toISOString().split('T')[0];
            fieldMod.setDateValues = [isoDate];
          } else {
            Logger.log(`Invalid date for field ${field.id}: ${value}`);
            return null;
          }
          break;
        case 'text':
        default:
          fieldMod.setTextValues = [value];
          break;
      }

      return fieldMod;
    }).filter(mod => mod !== null);

    if (fieldModifications.length === 0) {
      Logger.log('No valid field modifications; applying label only.');
      return applyLabelToFile(fileId, labelId);
    }

    const request = {
      kind: "drive#modifyLabelsRequest",
      labelModifications: [
        {
          kind: "drive#labelModification",
          labelId: labelId,
          fieldModifications: fieldModifications,
          removeLabel: false
        }
      ]
    };

    const response = Drive.Files.modifyLabels(request, fileId);
    Logger.log(`Label ${labelId} and fields applied to file ${fileId}: ${JSON.stringify(response.modifiedLabels)}`);
    return response.modifiedLabels || [];
  } catch (error) {
    Logger.log(`Error applying label and fields to file ${fileId}: ${error.message}`);
    return [];
  }
}

This function takes three inputs:

fileId → the Drive file we want to update
labelId → the label we want to apply
fields → an array of field definitions with values

Each field is expected to be passed in this simple format:

{
  id: "field-id",
  type: "text",
  value: "Some value"
}

The function starts with a strict validation check. If any of these three inputs are missing - the file ID, the label ID, or a non-empty fields array - we immediately throw an error. This prevents silent failures where the script looks like it ran but didn't actually apply anything.

Next, the function transforms the human-friendly fields array into a Drive API–compatible request structure. This is done by iterating over each field and dynamically constructing a labelFieldModification object.

At this stage, the script does something very important: it does not assume that every field value is valid. If a field is missing a value, that field is skipped entirely rather than breaking the update for all fields. This makes the system resilient in real-world automation scenarios where extracted data might be partially incomplete.

For every field, we first construct a base object:

{
  kind: "drive#labelFieldModification",
  fieldId: field.id
}

At this point, we've told Drive which field we want to modify, but not how.

Next, we check if a value is actually present. If the value is missing or empty, we log a message and skip that field entirely. This is important because sending empty field updates can cause API errors or overwrite existing values accidentally.

After that, the function switches behaviour based on the field's type:

Text fields: These are the simplest. We attach the value using:

setTextValues: [value]

The API always expects values as arrays, even if there's only one value.

Integer fields: We first run parseInt(value) to verify that the value is actually numeric. If it's not a valid number, we log an error and skip the field. If it is valid, we convert it to a string and attach it using:

setIntegerValues: ["123"]

Date fields: Dates are trickier because the API only accepts them in strict YYYY-MM-DD format. We solve this by:

Creating a JavaScript Date object
Converting it to ISO format
Dropping the time portion using:

date.toISOString().split("T")[0]

This guarantees the format Drive expects.
Selection (dropdown) fields: These use:

setSelectionValues: [value]

Note on selection fields
In real production systems, selection (dropdown) fields require option IDs - not display values. This demo assumes a direct mapping for simplicity. In the Gemini-powered automation covered next, option IDs are resolved dynamically.

If at any point a field fails validation - invalid date, non-numeric integer, missing value - that field is excluded from the request entirely. This ensures that one bad field never breaks the entire automation.

After processing all fields, we run a cleanup step using:

.filter(mod => mod !== null)

This removes any skipped or invalid field updates and leaves us with only clean, valid modifications.

Next comes a very important safety check: If no valid field modifications remain, we don't try to update fields at all.

Instead, we gracefully fall back to:

applyLabelToFile(fileId, labelId)

This guarantees that the label still gets applied even if field data is missing.

If valid fields do exist, we build the final modifyLabels request. This request bundles both actions into one atomic update:

Applying the label
Updating all valid fields

This is done in a single API call using:

Drive.Files.modifyLabels(request, fileId);

From Drive's perspective, this happens as one clean transaction instead of multiple partial updates.

Finally, the API response is logged and returned so we can inspect what actually changed. If anything fails - permission issues, API limits, or malformed requests - the catch block logs the error and safely returns an empty array instead of crashing the full workflow.

Full automation: chaining everything together

Up to this point, every function we've written has been doing one focused job - fetching labels, fetching fields, applying a label, or updating fields. The fullLabelAutomation(fileId) function is where all of those pieces finally come together into a single, end-to-end automation pipeline.

Think of this function as the orchestration layer. It doesn't introduce any new low-level API logic. Instead, it coordinates all the building blocks we already created and runs them in the right order.

The function starts by logging the file ID being processed. This may seem minor, but it's extremely useful when you're running batch jobs or automations on multiple files and need traceability in your execution logs.

The very first real step is calling:

const labelMap = fetchAvailableLabels();

This ensures that every run starts with a fresh snapshot of currently published and visible labels. We're not hardcoding label IDs anywhere in this workflow, which is important because label configurations can change over time in the Admin Console.

Immediately after that, we verify that at least one label was found. If not, the script exits cleanly with a helpful message. This avoids unnecessary API calls when the environment itself isn't ready.

Next comes the label suggestion step:

const suggestedLabel = "Invoice";

Right now this is hardcoded for demo purposes, but this is the exact point where you would normally plug in:

Text extraction from the document
Regex-based classification
Or an AI model for document categorization

What matters here is that we treat the suggested label as just another input and still validate it against what actually exists in Drive. We don't blindly trust the suggestion. We look it up in the labelMap, and if it doesn't exist, we log all available labels and safely exit. This kind of validation is critical in production systems.

Once a valid label is identified, we move on to schema discovery:

const fieldMap = fetchLabelFields(labelId);

At this stage, the script dynamically learns what fields exist on the selected label and what types they are. This allows the automation to adapt even if the label schema changes later - for example, if a new field is added in the Admin Console.

If no fields are found, the script doesn't fail. Instead, it gracefully falls back to applying only the label using applyLabelToFile(). This ensures that even minimal labels without metadata fields still work with the automation.

If fields do exist, we then build the structured fields array. This is where raw business data gets mapped to Drive metadata.

In our demo, this is done using mock values like:

Invoice Number
Invoice Date
Vendor Name

Each field entry is constructed using the dynamically fetched field ID and type, combined with the value you want to store. The end result is a clean, API-ready representation of your metadata.

This is also the exact point where you would plug in:

OCR output from PDFs
Extracted text from Google Docs
Parsed values from emails or forms
Or structured data returned by an AI model

Once the fields array is prepared, everything is handed off to the core execution function:

applyLabelAndUpdateFields(fileId, labelId, fields);

This single call applies the label and writes all valid field values in one atomic operation. From Drive's perspective, the file moves instantly from unlabeled to fully enriched with structured metadata.

Adding a Clean Entry Point with runDemo()

Instead of directly calling fullLabelAutomation(fileId) at the bottom of the script, we now wrap it inside a simple launcher function:

function runDemo() {
  // Replace this with your actual File ID
  const myFileId = "your_file_id"; 

  fullLabelAutomation(myFileId);
}

This small addition significantly improves how the automation is executed and tested.

It gives us a clean entry point for the entire workflow. You can now simply select runDemo from the function dropdown and click Run-without touching the core logic every time.

More importantly, this mirrors how real-world systems behave. In production, fullLabelAutomation() would typically be triggered by:

A Drive folder upload trigger
A time-based batch job
A UI button inside an Add-on
Or a webhook or API call

In short, runDemo() cleanly separates execution control from automation logic, which is exactly how scalable Drive automation systems should be structured.

Once this function completes successfully, you can open the file in Google Drive, click on File details → Labels, and see the label and populated metadata live.

What we have built here is a robust labeling engine. It solves the hardest part of the Drive Labels API: translating human-readable names (like Invoice) into the cryptic IDs that Google requires.

Because we separated the logic into distinct steps - Fetch, Map, Build, Apply - this script is highly resilient. If you change a field name in the Admin Console, you only have to update your mapping logic, not the entire payload structure.

Recap: What We've Built So Far

At this point in the walkthrough, we've quietly assembled a complete Google Drive Labels automation pipeline.

We started by dynamically discovering which labels exist in the workspace instead of hardcoding anything. Then we learned how to inspect a label's schema at runtime and understand what fields it contains and what types those fields expect. From there, we moved into actually applying labels to files and finally into enriching those labels with structured field values.

Individually, each function does one small, focused job. But together, they form something much more powerful: a reusable metadata engine for Google Drive.

By the time we reached the full automation function, everything clicked into place:

Label discovery
Schema discovery
Validation
Field mapping
Atomic application of labels and values

The result is a system where files don't just get tagged - they get structured, searchable metadata that Drive can actually understand and act on. This is the foundation for any serious document automation strategy.

How This Becomes Real Automation (Beyond a Demo)

Right now, we've been running this using a manual function trigger with a single test file. That's perfect for learning and debugging - but the real power of this setup shows up when you connect it to actual workflows.

In a production environment, this same pipeline can be triggered automatically when:

A new file is uploaded to a specific Drive folder
An invoice gets dropped into an Accounts folder
A contract is generated from a form submission
A shared drive receives new documents from vendors
A scheduled batch process scans unlabelled files every night

At that point, there is no manual step left. Files flow into Drive, your automation picks them up, and labels + structured fields get applied in the background without anyone needing to open the document.

And the best part is - all of this runs on top of tools most teams already have: Google Drive, Google Apps Script, and Workspace APIs.

Conclusion

If there's one key takeaway from this walkthrough, it's this: Google Drive Labels are not just visual tags - they're a powerful metadata platform hiding in plain sight.

With Google Apps Script, you now have full programmatic control over discovering labels, understanding their schemas, and enriching files with structured, queryable metadata. Once this foundation is in place, Drive stops being just a storage system and starts behaving like an intelligent document platform.

In the next part, we'll take this further by introducing fully automatic, Gemini-powered labeling, where documents are analyzed and classified without any manual input.

https://github.com/aryanirani123/Google-Apps-Script/blob/master/DriveLabelsAutomation.js

Feel free to reach out if you have any issues/feedback at aryanirani123@gmail.com.

Integrating Zomato’s MCP Server into Gemini CLI: AI-Powered Food Ordering in Your Terminal

Aryan Irani — Thu, 30 Oct 2025 05:11:46 +0000

Hey folks! If you’re like me, you love blending AI with everyday tasks — like ordering dinner without leaving your terminal. Zomato just dropped a shiny new Model Context Protocol (MCP) server on October 22, 2025, turning their food delivery magic into AI-friendly tools. This means you can discover restaurants, browse menus, build carts and place orders.

MCP? It’s an open standard (kicked off by Anthropic in late 2024) that lets AI agents like Gemini connect to external services seamlessly. Think of it as a universal plug for tools and APIs.

If you want to learn more about building an integrating an MCP server into Gemini CLI, check out tutorial below.

Building a Custom MCP Server for Gemini CLI: A Hands-on guide | by Aryan Irani | Google Cloud - Community | Sep, 2025 | Medium

Aryan Irani ・ Sep 9, 2025 ・
Medium

In this quick guide, we’ll integrate Zomato’s MCP server into Gemini CLI — Google’s open-source AI agent for your terminal (launched mid-2025). We’ll cover setup, config, and some fun interactions. Let’s get you ordering pizza with prompts in under 10 minutes!

What is the Zomato mcp-server-manifest?

Zomato’s mcp-server-manifest is an implementation of the Model Context Protocol (MCP) that exposes Zomato’s services as a tool for AI assistants. This allows you to conversationally interact with Zomato to discover restaurants, browse their menus, create a cart, and place an order. The server utilizes OAuth for secure authentication.

Prerequisites

Before we begin, ensure you have the following:

Gemini CLI installed: If you haven’t already, you can install it by running the following command in your terminal:

npm install -g @google/gemini-cli

To learn more about Gemini CLI, check out the detailed tutorial series given below.

Gemini CLI Tutorial Series. Welcome to the Gemini CLI Tutorial… | by Romin Irani | Google Cloud - Community | Medium

Romin Irani ・ Oct 10, 2025 ・
Medium

A Zomato Account: You will need your Zomato account credentials to authenticate and place orders.

Integrating Zomato with Gemini CLI: A Step-by-Step Guide

The key to this integration lies in configuring the Zomato MCP server within the Gemini CLI’s settings. Here’s how to do it:

Step 1: Locate your Gemini CLI settings file

The Gemini CLI configuration is stored in a JSON file located in your home directory. You can find it at ~/.gemini/settings.json.

code ~/.gemini

Step 2: Add the Zomato MCP Server Configuration

Open the settings.json file in your favorite text editor. You will need to add a new entry to the mcpServers object. This object contains the configurations for all the external tools you want to integrate with Gemini CLI.

    "mcpServers": {
      "zomato-mcp": {
        "command": "npx",
        "args": [
          "mcp-remote",
          "https://mcp-server.zomato.com/mcp"
        ]
      }

  },

Check out the official Github repository for the MCP server.

Zomato / mcp-server-manifest

Zomato MCP Server

An mcp server for your food ordering needs.

Disclaimer : This is only for testing purposes and Zomato disclaims any and all liabilities that may arise due to erroneous / non-functionality of the MCP integration.

Supported Features

🔎 Restaurant Discovery - Find nearby restaurants based on your location and preferences.
📒 Menu Browsing - Browse through detailed menus with prices, descriptions, and ratings.
🛒 Cart Creation - Add items to your cart and customize orders with ease.
🥗 Food Ordering - Place orders seamlessly with order tracking support.
💳 QR code payment - Complete secure payments using QR code integration.

Installation Guide

⚠️ OAuth Redirect URI Warning: Currently, we have only whitelisted the following redirect URIs for OAuth authentication. Please reach out to us to enable your client:

claude://claude.ai/settings/connectors

https://chatgpt.com/connector_platform_oauth_redirect

http://localhost

http://127.0.0.1

https://claude.ai/api/mcp/auth_callback

https://insiders.vscode.dev/redirect

https://oauth.pstmn.io/v1/callback

https://vscode.dev/redirect

Install in VsCode

One Click Installation

Manual Installation

Add this…

View on GitHub

Explanation of the configuration:

zomato: This is a user-defined name for the MCP server. You can choose any name you like.

command: npx **: This specifies the command to execute to start the MCP server. In this case, we are using npx, which is a package runner tool that comes with npm.
**args: […]: This is an array of arguments to be passed to the command.
mcp-server: This is the name of the package that will run the MCP server.
https://github.com/Zomato/mcp-server-manifest: This is the URL to the Zomato mcp-server-manifest on GitHub.

Step 3: Save and Restart Gemini CLI

Save the settings.json file and restart your Gemini CLI. If it’s already running, you can exit and relaunch it.

Step 4: Verify the Integration

Once Gemini CLI restarts, it will automatically connect to the Zomato MCP server. The first time you try to access it requires authentication , you will be prompted to log in to your Zomato account through a secure OAuth flow. Once done, you will be redirected back to your terminal.

To verify that the integration is successful, you can use the /mcp command in the Gemini CLI:

/mcp

This command will list all the configured MCP servers. You should see zomato in the list of connected servers.

Interacting with Zomato through Gemini CLI

Now for the fun part! You can start interacting with Zomato using natural language queries directly in your Gemini CLI. Here are a few examples to get you started:

To find restaurants: Find me some biryani restaurants near me.
To see the menu of a restaurant: Show me the menu for Restaurant Name.
To add items to your cart: Add one chicken biryani to my cart.
To view your cart: Show my cart.
To place an order: Place this order.

Check out the demo given below for verification and interaction with the Zomato MCP Server using Gemini CLI.

A Powerful Combination for a Seamless Workflow

The integration of the Zomato mcp-server with Gemini CLI is a fantastic example of how the command line is evolving into a more interactive and powerful tool. This seamless connection allows developers and command-line enthusiasts to stay within their preferred environment while accessing essential real-world services. So, the next time you’re deep in your coding workflow and hunger strikes, you know you’re just a command away from your next meal.

Getting Started with SmartCheckbox™: Install, Setup, and your First Rule

Aryan Irani — Tue, 28 Oct 2025 07:29:04 +0000

If you've ever spent more time fighting Google Sheets than actually working in it, you're not alone. Checkboxes are a staple in task trackers, inventories, and reports — but default ones either stay static or override your changes like an overzealous intern.

Enter SmartCheckbox™, a free Google Workspace add-on that makes checkboxes smart: they auto-update based on your data, but respect your manual tweaks. No more "Why did it flip back?!" moments.

This guide walks you through installation, your first setup, and running a simple rule. By the end, you'll have a live task tracker. Let's get started — no coding required.

Step 1: Installing SmartCheckbox

1.Open Google Sheets: Head to sheets.google.com and open (or create) a spreadsheet.
2.Access Extensions: Click Extensions in the top menu → Add-ons → Get add-ons.
3.Search & Install: Type "SmartCheckbox" in the search bar. Click the add-on card → Install. Grant permissions (it only accesses your active sheet).

4.Verify: Refresh your sheet. Go to Extensions → SmartCheckbox → Open Sidebar. A clean panel appears on the right.

Pro Tip: If you're on a work account, check with your admin — but it's read-only on your sheets, no data leaves Google.

Step 2: Your First Setup – The Basics

The sidebar has four sections: Setup, Conditions, Options, Status.

Start simple.

Setup (Target & Range):

Target Column: Click the dropdown → Select a header (e.g., "Completed?") or type a letter (e.g., "F"). This is where checkboxes live.
Row Range: Enter start (e.g., 2) and end (e.g., 10). Skips headers.

Conditions (The Magic):

1.Click + Add Condition.
2.Column: Pick "Status" (dropdown).
3.Operator: Select == (equals).
Value: Type Done (no quotes needed).
Combiner: Leave as "AND" for now.

Options (Polish It):

Custom True: Yes (instead of TRUE).
Custom False: No.
Auto-Refresh: Toggle on (updates on edits).

Apply: Hit Apply & Save. Watch checkboxes appear — and auto-check where "Status" is "Done".

Action,Result
Look at Row 3 → Status = Done, Completed? auto-fills with a checked box and shows Yes
Row 1, 2, 4 → Status ≠ Done,All show unchecked and No

Step 3: Test Your First Rule

Now that your rule is saved, let’s see it in action. Now change Row 1 Status → Done
The checkbox in the Completed? column auto-checks → Yes

What You Just Learned

Auto-updates happen instantly when data matches your rule.
Manual clicks are final — SmartCheckbox never overrides them.
Custom labels (Yes/No) make your sheet readable at a glance.

You now have a fully functional, self-maintaining task tracker.
Try adding a new row (e.g., Task ID 5, Status = "Done") — watch the checkbox appear and auto-check!

Try it now → Install SmartCheckbox
Live Demo → https://smartcheckbox.store/

What's Next?
You've got basics down. Next guide: Hands-on Tutorial with real-world use-case.

Check it out -> https://dev.to/aryanirani123/hands-on-tutorial-build-a-content-approval-workflow-with-smartcheckbox-1mc4

Hands-On Tutorial – Build a Content Approval Workflow with SmartCheckbox

Aryan Irani — Tue, 28 Oct 2025 07:27:17 +0000

You’re a content team. Blog drafts, social posts, video scripts — all live in Google Sheets.

Every week:

Writer marks “Ready for Review”
Editor checks a box → “Approved”
Someone emails the team: “Is this live?”
Then someone accidentally unchecks it → chaos

SmartCheckbox kills the chaos.

In this hands-on tutorial, you’ll build a Content Approval Workflow that:

Auto-approves when all 3 steps are complete
Lets editors manually override (e.g., “Reject”)
Logs every change in an Audit Log
Uses custom labels: Approved,Draft

No scripts. No formulas. No more “Did we approve this?”
Let’s build it — step by step.

Step 1: Set Up Your Content Calendar Sheet

Create a new Google Sheet → Name it: Content Approval Workflow

Note:
C, D, E = Yes/No dropdowns (Data → Data validation → List: Yes,No)
F (Status) = Optional text field for team notes

Step 2: Configure SmartCheckbox – AND Logic Rule

Open SmartCheckbox Sidebar → Extensions > SmartCheckbox > Open Sidebar

Set Target & Range: Click the dropdown → Select a header (e.g., "Approved?") or type a letter (e.g., "F"). This is where checkboxes live.

Row Range: Enter start (e.g., 2) and end (e.g., 10). Skips headers.

*Conditions Tab: * 3-Step AND Logic → Click + Add Condition → 3 times

#	Column	Operator	Value
1	Draft Complete?	==	Yes
2	Editor Review?	==	Yes
3	Designer OK?	==	Yes

Combiner: All must be true (AND)

*Options Tab(Polish It) *

Save & Apply
Click Apply & Save → Watch Column G update:

Step 3: Test the Workflow – Real Team Simulation

Let’s simulate a real content week.

Full Approval

Row 1 already has all Yes → Approved
Row 5: Set all values → Yes → G5 → Approved instantly
You can also see that it has logged this into the Audit-Log.

Conclusion: Your Content Workflow Is Live

You now have:

A self-policing approval system
No more email threads
Full audit trail
Manual control when needed

Try it now → Install SmartCheckbox
Live Demo → https://smartcheckbox.store/
Download Template → [Link]

Built with SmartCheckbox™ — Free forever.

Turn Google Docs Into an AI Agent Hub: Integrate ADK Agents in Google Workspace

Aryan Irani — Mon, 20 Oct 2025 12:41:31 +0000

Series Roadmap:

Part 1: Build Your First ADK Agent
Part 2: Deploy an ADK Agent to Vertex AI Agent Engine
Part 3: Integrate into Google Docs (You're here!)

Welcome back to the final part of our three-part tutorial series on building Google Workspace AI agents using the Agent Development Kit (ADK) and Vertex AI Agent Engine.

In the first two parts, we:
✅ Built an AI-powered Fact Verifier Agent using the ADK.
✅ Deployed it to Vertex AI Agent Engine, making it accessible via API.

Now in this third and final part, we'll connect everything together - bringing your deployed agent inside Google Docs. With a few lines of Apps Script, you'll transform a standard Google Doc into an AI-assisted editor that can analyze and fact-check content automatically using your deployed agent.

If you want a video version of the blog, check out the tutorial given below.

If your organization is looking to build custom Google Workspace Add-ons, integrate AI Agents with ADK, or develop agentic workflows using Gemini and Vertex AI, my team and I can help. We specialize in turning complex ideas into production-ready AI solutions for enterprise environments.
📩 Reach out to discuss your project - whether it's automating Workspace tools, enhancing data intelligence, or designing agent-driven workflows tailored to your needs.

Step1: Set Up Your Google Docs Environment

Start by opening a new or existing Google Document. From the menu, go to Extensions -> Apps Script to open the editor. We'll use this space to connect to the deployed ADK Agent. The Google Doc we are using for this tutorial contains the following contents:

Step2: Add the Integration Code

You'll need two files in your Apps Script project for this setup:

AIVertex.gs – Handles all communication with Vertex AI and the ADK Agent.
Code.gs – Controls the Google Docs interface, menus, and document actions.

Let's go through each one.

File 1: AIVertex.gs

This file handles everything related to your deployed agent - making authenticated API calls to both Vertex AI Agent Engine (for reasoning) and Gemini models (for output formatting).

const LOCATION = PropertiesService.getScriptProperties().getProperty('LOCATION');
const GEMINI_MODEL_ID = PropertiesService.getScriptProperties().getProperty('GEMINI_MODEL_ID');
const REASONING_ENGINE_ID = PropertiesService.getScriptProperties().getProperty('REASONING_ENGINE_ID');
const SERVICE_ACCOUNT_KEY = PropertiesService.getScriptProperties().getProperty('SERVICE_ACCOUNT_KEY');

const credentials = credentialsForVertexAI();

/**
 * @param {string} statement The statement to fact-check.
 */
function requestLlmAuditorAdkAiAgent(statement) {
  return UrlFetchApp.fetch(
    `https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${credentials.projectId}/locations/${LOCATION}/reasoningEngines/${REASONING_ENGINE_ID}:streamQuery?alt=sse`,
    {
      method: 'post',
      headers: { 'Authorization': `Bearer ${credentials.accessToken}` },
      contentType: 'application/json',
      muteHttpExceptions: true,
      payload: JSON.stringify({
        "class_method": "async_stream_query",
        "input": {
          "user_id": "google_sheets_custom_function_fact_check",
          "message": statement,
        }
      })
    }
  ).getContentText();
}

/**
 * @param {string} prompt The Gemini prompt to use.
 */
function requestOutputFormatting(prompt) {
  const response = UrlFetchApp.fetch(
    `https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${credentials.projectId}/locations/${LOCATION}/publishers/google/models/${GEMINI_MODEL_ID}:generateContent`,
    {
      method: 'post',
      headers: { 'Authorization': `Bearer ${credentials.accessToken}` },
      contentType: 'application/json',
      muteHttpExceptions: true,
      payload: JSON.stringify({
        "contents": [{
          "role": "user",
          "parts": [{ "text": prompt }]
        }],
        "generationConfig": { "temperature": 0.1, "maxOutputTokens": 2048 },
        "safetySettings": [
          {
            "category": "HARM_CATEGORY_HARASSMENT",
            "threshold": "BLOCK_NONE"
          },
          {
            "category": "HARM_CATEGORY_HATE_SPEECH",
            "threshold": "BLOCK_NONE"
          },
          {
            "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
            "threshold": "BLOCK_NONE"
          },
          {
            "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
            "threshold": "BLOCK_NONE"
          }
        ]
      })
    }
  );
  return JSON.parse(response).candidates[0].content.parts[0].text
}

/**
 * Gets credentials required to call Vertex API using a Service Account.
 * Requires use of Service Account Key stored with project.
 * 
 * @return {!Object} Containing the Google Cloud project ID and the access token.
 */
function credentialsForVertexAI() {
  const credentials = SERVICE_ACCOUNT_KEY;
  if (!credentials) {
    throw new Error("service_account_key script property must be set.");
  }

  const parsedCredentials = JSON.parse(credentials);

  const service = OAuth2.createService("Vertex")
    .setTokenUrl('https://oauth2.googleapis.com/token')
    .setPrivateKey(parsedCredentials['private_key'])
    .setIssuer(parsedCredentials['client_email'])
    .setPropertyStore(PropertiesService.getScriptProperties())
    .setScope("https://www.googleapis.com/auth/cloud-platform");
  return {
    projectId: parsedCredentials['project_id'],
    accessToken: service.getAccessToken(),
  }
}

What this file does

Authenticates securely to Vertex AI using a Service Account key. Calls your deployed ADK Agent to analyze or fact-check the document text.
Uses Gemini for smart response formatting - making the results human-readable.

File 2: Code.gs

This file connects your Docs UI with the ADK logic above. It lets you trigger the audit directly from a custom Docs menu.

/**
 * Adds a custom menu in Google Docs to run the AI Audit directly.
 */
function onOpen() {
  DocumentApp.getUi()
    .createMenu('AI Audit Tools')
    .addItem('Run AI Audit', 'runAuditAndInsert')
    .addToUi();
}

/**
 * Returns the entire text content of the document.
 */
function getDocumentText() {
  const doc = DocumentApp.getActiveDocument();
  const body = doc.getBody();
  let text = body.getText();
  return text.trim();
}

/**
 * Runs the AI Audit and inserts the result as text at the end of the document.
 */
function runAuditAndInsert() {
  const docText = getDocumentText();
  const result = runAudit(docText);

  if (result) {
    const doc = DocumentApp.getActiveDocument();
    const body = doc.getBody();
    // Append the audit result as a new paragraph at the end of the document
    body.appendParagraph('AI Audit Result: ' + result);
  }
}

/**
 * Runs the AI Audit using ADK Agent and Gemini formatting.
 */
function runAudit(docText) {
  console.log('[INFO] Starting AI audit process...');
  if (!docText) {
    console.log('[WARN] No text in document.');
    return '⚠️ The document is empty. Please add some text to audit.';
  }

  // Check for excessive document length to avoid token limits
  if (docText.length > 10000) {
    console.log('[WARN] Document too long.');
    return '⚠️ Document exceeds 10,000 characters. Please shorten the text.';
  }

  console.log('[STEP] Sending text to ADK Agent...');
  const rawAudit = requestLlmAuditorAdkAiAgent(docText);

  // Check if rawAudit is an error message
  if (rawAudit.startsWith('ERROR:')) {
    console.error('[ERROR] ADK Agent returned error:', rawAudit);
    return rawAudit;
  }

  console.log('[STEP] Formatting AI response...');
  let formatted;
  try {
    formatted = requestOutputFormatting(
      `Here is a fact-checking result: ${rawAudit}.
       Summarize it. Keep the main verdict and reasoning. Remove markdown and make it concise.`
    );
  } catch (error) {
    console.error('[ERROR] Formatting failed:', error.toString());
    return `ERROR: Failed to format audit result - ${error.toString()}`;
  }

  console.log('[SUCCESS] Audit completed successfully.');
  console.log('[RESULT] Final Output:', formatted);
  return formatted;
}

What this file does

Adds a custom menu in Google Docs called AI Audit Tools.
Grabs your document text and sends it to your ADK Agent for analysis.
Displays the AI-generated audit results back into the document.

Step 3: Add Script Properties

To connect your script to your deployed resources, go to:
Project Settings → Script Properties → Add Script Property

Add the following to your Script Properties
LOCATION: The region of your Vertex AI deployment us-central1 GEMINI_MODEL_ID: Gemini model to use gemini-2.5-flash-lite REASONING_ENGINE_ID: The deployed ADK Agent ID 1234567890 SERVICE_ACCOUNT_KEY: JSON key for the Service Account { "type": "service_account", ... }

Click Save script properties.

Step 4: Add the OAuth2 Library

Our Apps Script project needs the OAuth2 library for authenticating API calls.
To add it:

Go to Services → Libraries
Click Add a Library
Enter the Script ID:

1B7FSrk5Zi6L1rS6Qm6C9q8Zs6z3jQm5iBv6-1iQ0gWA-2

Step 5: Test Your AI Agent in Google Docs

1.In the Apps Script editor, run the onOpen() function once. This will add a new AI Audit Tools menu in Google Docs.
2.Return to your Doc and click AI Audit Tools → Run AI Audit.

3.The script will send your document's text to the deployed ADK Agent for fact-checking.
4.The AI Audit Result will appear automatically at the end of your document.

Wrapping Up

You've now deployed your AI Agent, connected it to Google Docs, and seen it in action - analyzing, reasoning, and summarizing right where your content lives. What we've built here isn't just a standalone demo. It's the foundation for intelligent, agent-driven collaboration inside Google Workspace.

By combining ADK's reasoning capabilities with Gemini's generative models, we've effectively turned Google Docs into a living, thinking assistant - one that can read, audit, and refine your text with context.

But this is only the beginning. The same blueprint extends naturally across Sheets, Slides, Drive, and Gmail - anywhere you want AI to work with you, not just for you. Imagine agents that:

Audit financial data and flag inconsistencies in Sheets,
Auto-generate pitch decks and summaries in Slides,
Label and organize documents intelligently in Drive,
Or even draft and fact-check emails directly in Gmail.

This demonstration lays the groundwork for building agentic workflows that integrate seamlessly into your daily Workspace tools - turning static documents into dynamic AI collaborators.

You've just taken the first step toward the future of AI-native productivity - where every file, message, and meeting can think, reason, and evolve with you.

If you're ready to bring this level of intelligence into your own Workspace tools, we'd love to collaborate.

Agentic Workflows inside Google Workspace: Build a Google Docs Agent with ADK

Aryan Irani — Mon, 20 Oct 2025 12:41:28 +0000

Welcome !

Google Workspace is where work happens. From drafting reports in Docs to crunching data in Sheets and collaborating in Gmail and Meet - it's the daily home for millions of teams. It's where ideas start, decisions are documented, and collaboration happens in real time.

Now imagine if your Docs, Sheets, and Gmail weren't just tools, but collaborators.

Thanks to Google's Agent Development Kit (ADK) and Vertex AI's Agent Engine, that's no longer just an idea. These frameworks let you build intelligent agents, deploy them at scale, and integrate them seamlessly into your Google Workspace tools - enabling a new era of agentic productivity.

In this three-part tutorial series, we'll explore exactly how to do that.
Series Roadmap:
- Part 1: Build Your First ADK Agent (You're here!)
- Part 2: Deploy an ADK Agent to Vertex AI Agent Engine
- Part 3: Integrate into Google Docs

Let's get started and bring intelligent, agentic workflows to the tools you already use every day.

This tutorial builds upon ideas introduced in Google's official Fact-Check sample for Apps Script. If you're looking for a quick overview of the official implementation, that's a great place to start.

If you want a video version of the blog, check out the tutorial given below.

How It Works

Building the ADK-Agent

Let'a create the ADK agent - AI based Auditor that fact checks text, inspired by Google's Fact-Check custom function sample. Unlike the sample's single-step approach, our agent uses multi-step reasoning to extract claims, verify them with google_search, and output structured JSON.

Step 1: Set Up Your Project Environment

First, prepare your development environment to use the Google Agent Development Kit (ADK). Create a project, install dependencies, and authenticate with Google Cloud.

1.Create a folder and navigate to it:

mkdir workspace-agent
cd workspace-agent

2.Create & activate virtual environment:

`python -m venv .venv
source .venv/bin/activate`

3.Install Google ADK:

`pip install google-adk`

4.Authenticate with Google Cloud for local testing:

`gcloud auth application-default login`

Check out the link given below for information on how to get started with Google Cloud SDK.

Quickstart: Install the Google Cloud CLI | Google Cloud SDK | Google Cloud Documentation

Learn how to install Google Cloud CLI and run a few core gcloud CLI c ommands.

docs.cloud.google.com

Step 2: Design the Agent's Logic

Now that we have our environment setup, we will now write the agent's code in agent.py . An ADK agent has three main components: a model, tools and instruction set to define its behaviour. Our AI-Auditor agent extracts factual claims from text, verifies them with Google Search, and returns a JSON report.

You can work with the out the agent code by checking out the link given below.

aryanirani123 / ADKAGENTGAPS

ADKAGENTGAPS

View on GitHub

from google.adk.agents import Agent
from google.adk.tools import google_search

We start off by setting up our initial python script with the necessary imports.

root_agent = Agent(
    name='ai_auditor',
    model='gemini-2.0-flash-001',
    description="Fact-checks statements from a document and provides citations.",
    instruction="""
You are an AI Auditor specialized in factual verification and evidence-based reasoning.
Your goal is to analyze text from a Google Doc, identify verifiable factual claims, and produce a concise, source-backed audit report.

### 🔍 TASK FLOW

1. **Extract Claims**
   - Analyze the input text and identify factual claims that can be objectively verified.
   - A factual claim is any statement that can be proven true or false with external evidence.
   - Skip opinions, vague generalizations, or speculative language.
   - List each claim as a string in a JSON array.

2. **Verify Claims**
   - For each extracted claim:
     - Use the `google_search` tool to find relevant, credible results.
     - Evaluate at least the top 3 relevant URLs to determine the claim's accuracy.
     - Cross-check multiple sources when possible to ensure confidence.

3. **Classify Findings**
   - For each claim, determine one of the following verdicts:
     - ✅ **True:** Supported by multiple reputable sources.
     - ⚠️ **Misleading / Partially True:** Contains partially correct or context-dependent information.
     - ❌ **False:** Contradicted by credible evidence.
     - ❓ **Unverifiable:** Insufficient information to confirm or deny.
   - Provide a **confidence score (0–100)** reflecting the strength of evidence.

4. **Record Evidence**
   - For each claim, include:
     - The **verdict**
     - **Reasoning summary** (1–2 sentences)
     - **List of citation URLs** used for verification

5. **Summarize Results**
   - Compile a final report including:
     - Total number of claims analyzed
     - Distribution of verdicts (True / False / Misleading / Unverifiable)
     - Brief overall conclusion (e.g., "Most claims are accurate but some lack supporting evidence.")

### 🧾 OUTPUT FORMAT

Return your final response in structured JSON format as follows:

{
  "claims": [
    {
      "claim": "...",
      "verdict": "True | False | Misleading | Unverifiable",
      "confidence": 0-100,
      "reasoning": "...",
      "sources": ["https://...", "https://..."]
    }
  ],
  "summary": {
    "total_claims": X,
    "verdict_breakdown": {
      "True": X,
      "False": X,
      "Misleading": X,
      "Unverifiable": X
    },
    "overall_summary": "..."
  }
}

### 🧠 ADDITIONAL INSTRUCTIONS
- Always prefer authoritative domains (.gov, .edu, .org, or major media).
- Avoid low-quality or user-generated content as primary sources.
- Be concise, accurate, and transparent about uncertainty.
    """,
    tools=[google_search],  # Only use the search tool
)

We then define the AI agent by giving it a name, followed by the model, description and a very detailed instruction set. The instruction set it the most important part that defines how exactly the agent should think and operate. This structure mirrors how professional fact-checkers work - turning the AI into an autonomous auditing pipeline.

Once done with this agent declaration, we move to giving the agent access to real-world information via the Google Search tool. Instead of relying on pre-trained data, the agent can perform live searches, evaluate results, and provide up-to-date citations.

That's what makes this system agentic - the model doesn't just generate answers, it takes action (using tools) to verify information.

Step 3: Test the Agent Locally

Before deploying the agent, we must test the agent locally to ensure it works. You can either generate sample scripts for testing to very the agent with sample input and verify the output, or you can test the agent using adk web command.

Our first interaction is fundamental: understanding what the agent can actually do. This tests the agent's ability to summarize its description and instruction_text.

The agent provides a concise summary of its abilities, drawing from its description and instruction set.

We then provide it two statements and it successfully audits the contents and give me back a well structure JSON response.

Under the hood:

The google_search tool fetches relevant pages from the web.
The Gemini 2.0 Flash model parses those snippets and classifies truthfulness.
The ADK handles reasoning orchestration and ensures step-by-step logic is followed.

This local test phase helps validate your agent's workflow before you deploy it on Vertex AI Agent Engine, where it can be connected to Google Workspace tools like Docs or Sheets.

Conclusion and Teaser

Congratulations ! You've built an AI Auditor Agent that fact-checks text with google_search, producing structured JSON responses. This pattern - defining a model, tool and instruction - can power any task, from verifying doc claims to analysing sheet data. By automating manual tasks and leveraging credible sources, you have unlocked smarter productivity.

Try it now: Run your agent with a fun input like The moon is made of cheese and check out the JSON response returned by the agent.

In Part 2, we'll deploy the agent to Vertex AI Agent Engine, making it cloud powered and scalable for production use. Stay tuned, check out the Github repo for all the code.

https://github.com/aryanirani123/Agent-Development-Kit

Feel free to reach out if you have any issues/feedback at aryanirani123@gmail.com.