Google's New API Turns Data Queries Into Conversations

Google just dropped a developer tool that might actually change how people interact with data—and I'm cautiously optimistic about it, which is saying something.

The Conversational Analytics API, part of Google's Gemini stack, lets developers embed natural language data exploration directly into their applications. Instead of building yet another dashboard with dropdown filters and predetermined visualizations, you can now let users just... ask questions. In plain English. And get actual answers.

David Tamaki Szajngarten from Google Cloud Tech explains it like this: "Ever wish you could just ask your data questions and get accurate answers right away? No SQL, no dashboard clicks. That's exactly what the conversational analytics API is built for."

Here's what makes this interesting: It's not just slapping ChatGPT on top of your database and hoping for the best.

What This Actually Does

The API is essentially the same engine powering conversational analytics inside Looker, Google's business intelligence platform. But instead of being locked into Looker's web interface, developers can call it from anywhere—their own apps, internal tools, whatever.

You create what Google calls a "data agent"—an AI that understands your specific database schema, business logic, and data connections. Users send natural language queries through the API, the agent translates them into SQL or LookML (Looker's modeling language), runs the query, and returns structured results.

The demo in the video shows a Python implementation that's genuinely straightforward. Clone the quickstart repo, send a chat message through the API, and the agent interprets the question, generates the appropriate BigQuery query, and returns both natural language explanations and structured data your app can work with.

The Control Problem (Solved, Maybe)

What separates this from "just another AI wrapper" is the level of control Google built in. The API supports system instructions and authored context, which means you can actually define how the agent behaves.

You can tell it to always filter on specific fields, provide example questions with their equivalent queries, define a glossary of business terms, and explain how tables should be joined based on schema relationships. This matters because generic AI models don't understand that "revenue" means something different to your finance team than it does to your sales team, or that certain data should never be joined without specific filters.

The API offers both stateful sessions and stateless chats. Stateful means the agent remembers conversation context—useful for follow-up questions. Stateless means each query is independent with dynamically generated context—better for one-off questions or when you want complete control over what context gets included each time.

There are also built-in access controls with predefined rules for creating, sharing, and chatting with data agents. Given how many companies have had "whoops, the AI exposed sensitive data" moments lately, this isn't optional—it's necessary.

The Integration Angle

Since it's just an API, you can combine it with other tools. The video mentions using it alongside the Gemini Live API for multi-turn, multi-source reasoning. You can connect it to the Looker MCP server or Google's Agent Development Kit (ADK) to link multiple agents together.

Apparently, if you've used the ADK's "ask data insights" tool, you've already been using this API without knowing it. Which is honestly how good developer tools should work—invisible until you need to customize them.

Szajngarten frames it this way: "This is the API to use when you want to go beyond static dashboards. You can stop guessing which filters to click and instead ask questions dynamically with the agent inferring how to structure the query."

What This Could Mean

The promise here is analytics that feels conversational while still running on secure, governed data. That's the pitch, anyway.

In practice, whether this works depends entirely on implementation. AI-powered data tools have a spotty track record—they either hallucinate answers that sound right but aren't, or they're so locked down with guardrails they become less useful than just writing SQL yourself.

Google's approach with system instructions and authored context suggests they're aware of these problems. By letting developers define exactly how the agent should behave and what context it should consider, they're trying to split the difference between flexibility and reliability.

The stateful versus stateless options are smart too. Different use cases need different approaches. A business analyst doing exploratory data analysis wants stateful conversations with follow-up questions. A customer-facing app showing quick stats needs stateless queries that don't accumulate context or risk exposing data across sessions.

The Actual Question

The real test isn't whether the API works as demonstrated—of course it does in a controlled demo. The question is whether it works reliably enough that developers will trust it in production applications where wrong answers have real consequences.

Dashboards survived this long not because they're fun to build or intuitive to use—they didn't—but because they're predictable. You know exactly what data you're getting and how it's filtered. Conversational interfaces trade that predictability for flexibility. Sometimes that's worth it. Sometimes it's not.

Google's betting that with enough developer control and the right architecture, the trade-off tips in favor of conversations. The SDKs are available now across multiple languages, with Python quickstart examples ready to clone and modify.

Whether this becomes the standard way people query data or just another API that sounded good in the demo—that depends on what developers actually build with it, and whether those things work reliably enough that people trust them more than the dashboard they already know how to use.

—Tyler Nakamura, Consumer Tech & Gadgets Correspondent