Forem: Aman Choudhary

The Quiet Revolution at Google Cloud Next '26: Your Database Can Talk to Your AI Agent — No Bridge Required published

Aman Choudhary — Tue, 28 Apr 2026 20:47:48 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Everyone at Google Cloud Next '26 is talking about Gemini Enterprise Agent Platform. The flashy keynote demo, the "era of the agent is here" declaration, the snowboarder analyzing his own tricks with AI. I get it. It's a great story.
But buried in the 260-announcement list is something that, for developers building real AI applications, might matter more day-to-day: Google Cloud just made it trivially easy to connect AI agents directly to your production databases via fully managed MCP servers.
No proxy. No server to host. No auth plumbing to debug at 2 AM.
Let me explain why this is a bigger deal than it sounds.

First, The Problem This Solves

If you've tried building an AI agent that operates on real data — not sample JSON, but actual operational databases — you know the pain. The agent needs to read user records, check inventory, query transaction history. And to do that, you need to:

Stand up an MCP server (or run one locally)
Handle authentication — API keys? OAuth? IAM? Good luck wiring it all together
Manage connection pooling so your agent doesn't accidentally nuke your database with connections
Keep the whole thing running, monitored, and scaled

Model Context Protocol (MCP), the open standard created by Anthropic, solves the interface problem beautifully — it gives AI models a standardized way to talk to tools and data sources. But the infrastructure problem was still on you.
That's what Google Cloud just solved.

What Was Announced
At Next '26, Google Cloud announced managed, remote MCP servers that are now generally available for:

: AlloyDB (PostgreSQL-compatible)
: Cloud SQL
: Spanner
: Firestore
: Bigtable

And in preview for Memorystore, Database Migration Service, Datastream, Database Center, and more.
There's also a brand new Developer Knowledge MCP server — which connects your IDE directly to Google's documentation, so your coding agent can answer questions and troubleshoot with live, relevant context rather than hallucinating from training data.
The setup is almost shockingly simple:

bash#

Enable the Spanner MCP endpoint — one command
gcloud beta services mcp enable spanner.googleapis.com --project=${PROJECT_ID}

That's it. No server to deploy. The MCP endpoint is live. Then in your agent or IDE config, you point to it:

json{
"mcpServers": {
"spanner": {
"url": "https://spanner.googleapis.com/mcp",
"authType": "oauth"
}
}
}

And now your agent can query your Spanner database in natural language — from Gemini CLI, Claude, ChatGPT, or any MCP-compliant client.

Why the Security Model Actually Impresses Me

My first instinct when I see "connect your AI agent to your production database" is to reach for the fire extinguisher. But Google's implementation here is thoughtful.

Authentication is handled entirely through IAM — no shared API keys floating around, no connection strings hardcoded anywhere. Agents can only access the specific tables or views the IAM policy explicitly authorizes. Every query is logged through Google Cloud's standard observability stack. Audit trails are automatic.

This means you can create a dedicated service account for your agent, grant it read-only access to exactly the tables it needs, and revoke it instantly if something goes wrong. That's the kind of security posture that makes it realistic to actually deploy this in production.

The Spanner + MCP Angle Is Particularly Interesting

Spanner's managed MCP server isn't just for SQL queries. Because Spanner now has multi-model capabilities — relational, graph, vector search, full-text — the MCP integration surfaces all of those to your agent through natural language.

Imagine querying a fraud detection graph:

"Find all accounts that received transfers from account 12345 within the last 48 hours, and check if any of them share a phone number with a flagged account."

That's a multi-hop graph traversal combined with a relational join. With the Spanner MCP server, your agent generates the SQL+GQL automatically and executes it — no manual query writing.

Google even published a codelab walking through exactly this fraud detection use case. It's worth working through if you want to see the natural-language-to-graph-query pipeline in action.

The Open Source Side: MCP Toolbox 1.0

Alongside the managed servers, Google also released MCP Toolbox for Databases v1.0 — the stable GA of their open-source MCP server that supports 40+ databases, with contributions from 10 vendors. This includes not just Google's databases but also Neo4j, PostgreSQL, MySQL, SQLite, and more.

So the story here is two-tiered:

Managed MCP ServersMCP Toolbox

1.Infrastructure Zero — Google manages it Self-hosted

2.Database support GCP portfolio 40+ including non-GCP

3.Auth -- IAM (built-in) Configurable

4.Best for -- GCP-native teams Hybrid / multi-cloud

Both are genuinely useful for different teams, and they're complementary rather than competing.

My Honest Take
The marketing around agents tends to focus on what the AI can think and decide. But agents are only as useful as what they can act on. Most enterprise value lives in operational databases — not in PDFs or chat histories. The bottleneck for practical agent deployment isn't model capability. It's data access.

What Google announced here directly attacks that bottleneck.

The criticism I'd level: this is still fairly tightly coupled to Google Cloud's own database portfolio for the managed tier. If your production database is RDS PostgreSQL, Aurora, or Cosmos DB, you're on the open source path — which means you're back to managing infrastructure yourself. That's a real limitation for a lot of teams.

And the "natural language to SQL" reliability question is always there. For analytical queries on well-defined schemas, it works remarkably well. For complex joins across poorly documented legacy schemas? Test carefully before letting an agent loose on production.

Still — the direction is right. The security model is right. And the zero-infrastructure pitch for GCP databases is genuinely compelling for teams already in the ecosystem. If your data lives in Spanner, AlloyDB, or Firestore, there's no reason not to try this today.

Getting Started Right Now
The fastest path to experimenting:

Enable Spanner API in a Google Cloud project (free trial credits work):
bash
gcloud services enable spanner.googleapis.com
Enable the MCP endpoint:
bash
gcloud beta services mcp enable spanner.googleapis.com --project=${PROJECT_ID}
Install Gemini CLI:
bash
npm install -g @google/gemini-cli
Configure the Spanner extension and start querying your database in natural language.
Full walkthrough: Managed MCP Servers announcement blog · Spanner MCP Codelab

The agentic era needs agents that can actually do things. Connecting them to production data — securely, reliably, without standing up a custom server — is table stakes for that future. Google Cloud just made it significantly easier to get there.
That's worth paying attention to, even if it didn't get the keynote slot.

This is a submission for the Built with Google Gemini: Writing Challenge*

Aman Choudhary — Sun, 01 Mar 2026 14:00:58 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

Every great project starts with a spark, but the best developers know that the learning doesn't end when the deadline hits. My recent journey as a builder has been defined by two distinct projects that pushed my boundaries: a solo deep-dive into AI security, and a collaborative team build focused on developer productivity.

Here is a look back at what I built, the roadblocks encountered, and where the code is taking me next.

What I Built with Google Gemini
Project 1: Hiding in Plain Sight (Multimodal Steganography)
My first recent dive into Gemini was building a Python-based multimodal steganography application. Standard steganography conceals data within the least significant bits of an image, but if an attacker knows the algorithm, the secret is compromised. I wanted to build a system where the AI itself acts as the cryptographic key.

By integrating Gemini’s multimodal capabilities, the app requires the user to pass the "cover image" to the model. Gemini analyzes the visual context—identifying objects, mood, and specific details—to generate a dynamic, context-aware key. To retrieve the hidden message, the system requires not just the altered image, but Gemini's exact interpretation of it.

Project 2: Copilot CoLab (VS Code Extension)
While AI is incredible for security, it is equally powerful for workflow orchestration. Most recently, I teamed up with Nabil and Bhumi to build Copilot CoLab, a real-time team collaboration extension for VS Code. Developers lose countless hours context-switching between their IDE, Slack, and Jira. We brought tasks, chat, and presence directly into the editor.

As the frontend lead (while also contributing to the backend), I built the interface that ties these features together. We integrated Gemini to act as an embedded project manager. By pinging @gemini in the team chat, the model can automatically generate a full Work Breakdown Structure (WBS) for a new feature or perform AI-powered bulk task assignments to team members based on the repository's context.

Demo
You can check out the source code for both projects here. (Tip: I highly recommend embedding a quick 30-second Loom video or a few high-quality screenshots of the CoLab UI and the Steganography terminal output right here before you publish!)

Multimodal Steganography: https://github.com/Aman0choudhary/Project-1

Copilot CoLab: https://github.com/n4bi10p/copilot-colab

What I Learned
Between juggling my responsibilities as a college Cloud Lead and pushing through late-night study sessions for OS and PPS exams, these projects forced a massive evolution in how I write software.

Technical Breadth: The steganography app required a deep dive into Python's byte-level file manipulation. Copilot CoLab was a completely different beast: it required mastering the VS Code Webview API, bridging frontend states with extension host commands, and keeping everything synced in real-time using Supabase.

The Shift from Solo to Lead: Leading the frontend for a team meant I couldn't just build in a silo. I had to clearly communicate UI constraints to the backend, document my logic, and iterate based on Nabil and Bhumi's feedback. It taught me that code readability and clear communication are just as important as the logic itself.

The Macro vs. Micro Perspective: Building the steganography app required thinking small—literally down to the least significant bit of a single pixel. Building Copilot CoLab required thinking big—about human behavior and how teams actually communicate. Great architecture requires respecting both ends of that spectrum.

Google Gemini Feedback
The Good:
The Google AI Studio interface is phenomenal for rapid prototyping. Being able to drag and drop images and tweak my prompts for the steganography app before writing a single line of Python saved me hours of API debugging. For Copilot CoLab, the speed of the gemini-1.5-flash model was a massive win; it parsed project contexts and assigned tasks incredibly fast, making the @gemini chat feel like a truly real-time teammate.

The Friction (The Bad and the Ugly):
The biggest hurdle was forcing a generative model to act deterministically. Getting Gemini to output the exact same key format every single time for the security app—or perfectly formatted JSON for Copilot CoLab's bulk task assignment—required heavy prompt engineering. In the early stages, the model would sometimes over-explain (e.g., adding conversational fluff or wrapping outputs in markdown blocks), which completely broke our parsers. We had to learn how to aggressively constrain the prompts and implement strict JSON parsing on our end to filter out the noise.

Looking Forward
Working on these tools showed me how powerful AI can be when applied to real-time human connection and secure verification. Currently, I'm conceptualizing a hyperlocal social discovery mobile app for students and professionals in Pune, focusing on matching people based on shared interests. I am already brainstorming how to implement Gemini into the backend of this new app—perhaps using multimodal logic to verify student IDs or dynamically match users based on their portfolios.

The hackathons might be over, but the builder's momentum is just getting started.

Steganography App (Artful whisper)

Aman Choudhary — Sun, 14 Sep 2025 11:11:38 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

Demo

Multimodal features

ArtfulWhisper is fundamentally multimodal, creating a seamless flow between text and image data to deliver its unique functionality.

Text-to-Image Generation: The primary multimodal feature is taking a user's text prompt and transforming it into a rich, complex image using the Imagen 3 model. This is the creative heart of the app.

2.Fusing Text within an Image:The application then takes a second text input (the secret message) and algorithmically embeds it directly into the pixel data of the newly generated image. This goes beyond simple input-output; it's about fusing one modality (text) invisibly inside another (image).

The user experience is about power. It enhances it by giving the user a sense of control and secrecy that a simple image-and-text app could never provide. The magic isn't in seeing the two modalities work together; it's in knowing that one is invisibly controlling the other. It's a demonstration of how multimodal AI can be used for more than just cute chatbots and summary tools. It can be used to keep secrets.