Business Intelligence

Data Studio returns as new home for Data Cloud assets

Fri, 10 Apr 2026 16:00:00 +0000

In today's data-rich environment, organizations possess vast amounts of information. Yet, bridging the gap between that data and the users who need to make daily, informed decisions remains a challenge. Users need a single place to curate and analyze their data from the many different sources that impact their business each day.

We are sharing the next step in our mission to solve this challenge and reintroducing a beloved and familiar name, Data Studio (formerly Looker Studio).

In addition to its powerful data visualization capabilities, Data Studio is playing a significant role in the AI era serving Google Data Cloud content. With Data Studio, you have a single place to browse and interact with a variety of Google data sources and assets — from Data Studio reports, to BigQuery conversational agents, to data apps built in Colab notebooks.

Data Studio: reports, data apps, and conversational agents in one place

Extending our vision for analytics in the AI era

Since bringing Data Studio to the Google Cloud family five years ago, customers have continued to innovate with Data Studio as a place to visualize and share their data assets. Meanwhile, as AI becomes a critical component of practically every business, we’ve heard from our customers that they need a single place to save, organize and browse their data assets.

As part of this reintroduction, with Looker as our enterprise business intelligence platform, we are evolving Data Studio to complement the Looker platform, independently. As we have redesigned Data Studio, Looker has also recently seen significant investments in its self-service and visualization offerings, including agentic capabilities for use cases that demand trusted, governed data powered by a central semantic model.

We believe the new Data Studio is the ideal choice for personal data exploration — a place to craft ad-hoc reports, and quickly visualize data across Google’s ecosystem, from BigQuery to Google Sheets and Ads. This strategic differentiation ensures customers have the right tool for the right job.

Two flavors: Data Studio and Data Studio Pro

The new Data Studio experience is available in two editions.

Data Studio continues to offer powerful, no-cost individual analysis and visualization, serving as the on-ramp for creating and sharing ad-hoc reports, transforming data to an interactive dashboard in minutes.
Data Studio Pro is designed for scaling teams and organizations that need more agility and control, including AI features and deep integration with Google Cloud for enterprise-grade security, management, and compliance capabilities. Pro licenses can be purchased directly from the Google Cloud console or the Google Workspace Admin Console.

Upgrading to the new Data Studio should be largely transparent for the many users who count on this product in their daily work. All existing reports, data sources, assets and users will be transitioned to the new experience with no action on your part. Learn more about what’s coming to Data Studio and our vision for Data Cloud and Analytics at Google Cloud Next ‘26 later this month.

Introducing Looker self-service Explores for faster ad-hoc analysis

Mon, 06 Apr 2026 16:00:00 +0000

By design, Looker is the enterprise semantic platform which ensures that every data set meets a high standard of accuracy by acting as a single source of truth and providing long-term consistency of your metrics. Today, we are introducing a complement to this governed framework: self-service Explores, to accelerate high-velocity, ad-hoc analysis. Self-service Explores allows you to bring your own data directly into the Looker semantic layer, providing instant access to insights while maintaining the integrity of your existing governed data ecosystem.

Data teams often find themselves caught between two worlds. On one side, there’s the trusted, governed world of modern BI, where every metric is defined and every row is verified. Then there’s the agile, anything goes nature of spreadsheets and CSV files where you can get answers in seconds but run the risk of ending up in a siloed data vacuum.

Self-service Explores bring the value of modern, governed BI to the experimentation self-starting capability of spreadsheets, allowing anyone with the right permissions to turn a flat file into a fully functional Looker Explore in seconds. You can also import from Cloud from Google Drive and quickly transform Google Sheets data into conversational analytics. No code, no waiting — just insights.

You can drag and drop a comma separated or spreadsheet file (.csv, .xls, or .xlsx) or pull directly from Google Sheets, and Looker automatically creates an Explore. Behind the scenes, these files are securely stored in your own BigQuery instance, ensuring your data remains within your controlled infrastructure.

From importing a CSV to a self-service Explore in seconds

Key capabilities to power your analysis

With Looker self-service Explores, you gain:

Instant file uploads: Use a simple drag-and-drop interface to ingest local files for one-off analyses or testing a hypothesis before committing it to a permanent model.
Connect directly to Google Sheets: Easily import data via Google Sheets either via Oauth or by specifying the Google Sheets URL and sharing the document.
Merge queries (BigQuery): You can now combine your uploaded local files with standard, modeled Looker data, allowing you to enrich official company metrics with external data points to find new correlations. We’ve also added enhanced merge queries capabilities so you can perform merges on unlimited data as long as the data is on the same BigQuery connection.
Re-upload and refresh: You can easily re-import or update files within existing self-service Explores to keep your ad-hoc dashboards current.

Exploration through conversation, with red-tape free governance

Business intelligence in the agentic era has created new opportunities for business and data leaders throughout your organization to engage with their information faster and more intuitively, without significant technical demand. Self-service Explores bring support for conversational analytics, enabling you to ask questions in natural language about your uploaded data and get immediate answers, outlined visually, with grounding in Looker’s semantic layer. Users can chat with their data to drill down deeper, gaining more insights with follow-up questions and refinement.

Additionally, self-service Explores are built with admin controls at the forefront. Admins have full visibility and monitoring capabilities, with clear distinctions between ad-hoc data and modeled data. This gives users the freedom to explore, while maintaining the integrity of your core business logic. Self-service Explores give you the agility of a spreadsheet with the scale and security of BigQuery. It’s about spending less time waiting for a data model and more time actually using your data. Get started today.

Conversational Analytics now available for Looker Embedded environments

Mon, 06 Apr 2026 16:00:00 +0000

Looker Embedded analytics are at the heart of many next-generation data products, enabling monetization with live metrics and customizable user experiences. In the AI era, users expect apps to be highly interactive and conversational, and for data to be contextual, accessible and intuitive. Today, we are delivering conversational analytics in Looker Embedded environments with the Conversational Analytics API, now generally available, extending the natural language experience users have grown to expect from Looker to more surfaces, limited only by customers’ imagination.

Leading the shift to composable and agentic BI

Organizations are building integrated data experiences that meet users where they work. This is happening alongside the rise of agentic IDEs, where developers use AI agents to plan, code, and execute complex engineering tasks. Leveraging Looker’s embedded architecture within these environments incurs many benefits:

Differentiated agent experiences: Build high demand, unique conversational experiences that set your products apart.
Accelerated data monetization and developer extensibility: Turn raw data into sophisticated embedded products, transforming data assets into high-margin revenue streams.
AI-readiness in the IDE: Build with agentic IDEs with confidence, using Looker’s semantic layer to reduce hallucinations and maximize speed-to-market.

Conversational Analytics generally available for embedded users

Building on Looker’s existing embedded framework and governed semantic layer, you can now integrate Gemini-powered natural language querying and AI recommendations via a low-code iframe implementation or our extensible SDKs. This makes it easier to ship production-ready, conversational AI within any application.

With native support for querying multiple Looker Explores, a built-in code interpreter, and customizable theming, you can now provide a private-labeled, high-reasoning agent experience alongside your core features, bridging the gap between complex data models and intuitive user discovery.

Embed Conversational Analytics in Looker anywhere in your application using an iframe

Conversational Analytics now available from the Looker API

With our Conversational Analytics APIs, you can now build conversational experiences backed by Looker Explores directly within your customer-facing applications. By leveraging the Looker API, you can create multi-turn conversational workflows that offer AI-powered recommendations, while also verifying and explaining the underlying SQL query. The Looker API turns to the Looker SDK for user authentication and management, making it easy to integrate agentic conversations anywhere in your app.

Building a custom UI with Conversational Analytics in Looker API endpoints

Data exploration is a conversation away

The shift from static and inflexible dashboards to AI-driven exploration is transforming how businesses deliver value to their customers, empowering them to do more. Grounding these new conversational capabilities in Looker’s semantic layer means the insight accuracy you’ve always relied on from Looker is now available in third party applications, so you can know the insights are verifiable.

Whether you use the embedded iframe option or the Looker SDK, you can now build data experiences that don't just show information, but engage users in a dialogue. To start building conversational experiences in your own products with Looker Embedded, check out the documentation and best practices guide.

What’s new with Google Data Cloud

Thu, 02 Apr 2026 16:00:00 +0000

March 23 - March 27

We showed you how you can scale your reads with Cloud SQL autoscaling read pools. This feature allows you to provision multiple read replicas that are accessible via a single read endpoint and to dynamically adjust your read capability based on real-time application needs.
Our customers are leveraging the full power of Conversational Analytics and Looker to drive major business and technical breakthroughs in the AI era. Companies like Telenor, Pet Circle, Fluent Commerce, Lighthouse Intelligence, Wego, and ROLLER are turning data into insights and actions, grounded by Looker’s semantic layer.

March 16 - March 20

We introduced an enhanced Gemini assistant in BigQuery Studio, transforming the agent from a code assistant into a fully context-aware analytics partner.

February 23 - February 27

We introduced managed and remote MCP support for Google Cloud databases, including AlloyDB, Spanner, Cloud SQL, Bigtable and Firestore, to power the next generation of agents. This announcement extends the ability for AI models to plan, build, and solve complex problems, connecting to the database tools our customers leverage daily as the backbone of their work environment.
We outlined how you can build a conversational agent in BigQuery using the Conversational Analytics API to help you build context-aware agents that can understand natural language, query your BigQuery data, and deliver answers in text, tables, and visual charts.

February 16 - February 20

Our customers are leveraging the full power of Looker to drive major business and technical breakthroughs. Companies like Arrive, Audika, Carousell, Framebridge, GumGum, Intel, Overdose Digital, Ocean Network Express, Subskribe and Promevo are leveraging Looker’s newest AI-driven capabilities, including Conversational Analytics, to transform data to insights and actions, and empower their entire organization with a single source of truth, powered by Looker’s semantic layer.

February 2 - February 6

Join us on March 4 for our webinar, Win Your AI Strategy with Cloud SQL Enterprise Plus, to learn how to power your generative AI workloads with 3x higher performance and 99.99% availability. Register today to discover how to build a scalable, enterprise-grade foundation for your most demanding AI applications.

January 26 - January 30

We introduced Conversational Analytics in BigQuery, which allows users to analyze data using natural language. Conversational Analytics in BigQuery is an intelligent agent that generates, executes and visualizes answers grounded in your business context directly in BigQuery Studio, making data insights for data professionals more conversational.
We outlined how data products have become the foundation for AI agents, providing the context needed to make autonomous agents reliable and trusted for real business use, backed by organized business logic and semantic understanding.
We highlighted how you can supercharge data analytics workflows, and outlined Google Cloud’s AI agent offerings for data engineering, data science, and development tools, so you can integrate agentic workflows in your applications, empower your teams and speed discovery.

January 19 - January 23

We have fundamentally reimagined Firestore with pipeline operations for Enterprise edition. Experience a powerful new engine featuring over a hundred new query features, index-less queries, new index types, and observability tooling to improve query performance. Seamlessly migrate using built-in tools and leverage Firestore’s existing differentiated serverless foundation, virtually unlimited scale, and industry-leading SLA. Join a community of 600K developers to craft expressive applications that maximize the benefits of rich queryability, real-time listen queries, robust offline caching, and cutting-edge AI-assistive coding integrations.
Introducing Google Cloud SQL on MSSQLTips: We are highlighting a new technical guide published on MSSQLTips titled "Introducing Google Cloud SQL." This article serves as an essential resource for SQL Server administrators and developers exploring Google Cloud's fully managed database service. It provides a detailed overview of Cloud SQL capabilities, including high availability, security integration, and the seamless transition of on-premises SQL Server workloads to the cloud, making it an ideal resource for those planning their migration strategy.
We are excited to announce the Public Preview of Microsoft Entra ID (formerly Azure Active Directory) integration with Cloud SQL for SQL Server. Designed to tackle the challenge of identity sprawl in multi-cloud environments, this integration allows organizations to govern database access using their existing Microsoft identity infrastructure. Key benefits include centralized identity management, enhanced security features like Multi-Factor Authentication (MFA), and simplified user administration through direct group mapping. This feature is available for SQL Server 2022 and supports both public and private IP configurations.

January 12 - January 16

Google-built JDBC Driver for BigQuery is now available in Preview
We are excited to announce the launch of the new, Google-built JDBC driver for BigQuery. This new open-source driver provides a direct, high-performance connection for Java applications to BigQuery and is developed entirely in-house by Google. Download a new driver and connect your Java application to BigQuery.
Troubleshoot Airflow tasks instantly with Gemini Cloud Assist investigations: Cloud Composer just got smarter. We are excited to announce that Gemini Cloud Assist investigations are now available directly within Cloud Composer 3. Instead of manually sifting through raw logs, you can now simply click "Investigate" on a failed Airflow task. Gemini analyzes logs and task metadata to identify failure patterns—such as resource exhaustion or timeouts—and provides actionable recommendations driven by Gemini Cloud Assist to resolve the issue. This integration shifts the debugging experience from manual toil to automated root cause analysis, significantly reducing the time required to restore your pipelines. Learn more about AI-assisted troubleshooting.

New in Looker: self-service Explores, tabbed dashboards, and custom themes

Fri, 19 Dec 2025 17:00:00 +0000

Data teams seem to be constantly balancing the need for governed, trusted metrics with business needs for agility and ad-hoc analysis. To help bridge the gap between managed reporting and rapid data exploration, we are introducing several new features in Looker, to expand users’ self-service capabilities. These updates allow individuals to analyze local data alongside governed models, organize complex dashboards more effectively, and align the look and feel of their analytics with corporate branding, all within the Looker platform.

Analyze ad-hoc data with Looker self-service Explores

Valuable data often exists outside of the primary database — whether in budget spreadsheets, sales lists, or ad-hoc research files. With self-service Explores, now in Preview, users can upload CSV and spreadsheet-based data using a drag-and-drop interface directly within Looker.

This feature allows users to combine local files with fully modeled Looker data to test new theories and enrich insights. Once uploaded, users can visually add new measures and dimensions to their self-service Explores, customize them, and share the results via dashboards and Looks.

Uploading a CSV file and creating a new self-service Explore in just a few clicks

To maintain governance, administrators retain oversight regarding which files are uploaded to the Looker instance and who has permission to perform uploads. Additionally, we have introduced a new content certification flow, which makes it easier to signal which content is the vetted, trusted source of truth, ensuring users can distinguish between ad-hoc experiments and certified data.

Certifying a self-service Explore

Upload data and content certification are available in Public Preview as of Looker 25.20.

Deliver clearer, cohesive data stories with tabbed dashboards

The new tabbed dashboard feature helps dashboard editors organize complex information into logical narratives, moving away from dense, single-page views. Editors can now streamline content creation with controls for adding, renaming, and reordering tabs.

For the viewer, the experience is designed to be seamless. Filters automatically pass values across the entire dashboard, while each tab displays only the filters relevant to the current view, reducing visual clutter. Users can share unique URLs for specific tabs and schedule or download the comprehensive multi-tab dashboard as a single PDF document.

Navigating between tabs on a multi-tab dashboard

This feature is currently available in preview.

Apply custom styling to dashboards

Matching internal dashboards to company branding can help create a familiar data experience and increase user engagement. We are announcing the Public Preview of internal dashboard theming, which allows creators to apply custom changes to tile styles, colors, fonts, and formatting directly to dashboards consumed inside the Looker application.

Applying custom theming for internal dashboards

With this feature, you can save, share, and apply pre-configured themes to ensure consistency. Users with permission to manage internal themes can create new templates for existing dashboards or select a default theme to apply across the entire instance.

You can enable Internal dashboard theming today on the Admin > Labs page.

Enabling the preview for internal dashboard theming

Get started

These new self-service capabilities in Looker are designed to help you and all users in your organization get more value out of your data by improving presentation flexibility and quality. Try self-service Explores and internal dashboard themes for yourself today and let us know your feedback.

How to connect Looker to Gemini Enterprise in minutes, with MCP Toolbox and ADK

Fri, 12 Dec 2025 17:00:00 +0000

We can all agree that the quality of AI-driven answers relies on the consistency of the underlying data. But AI models, while powerful, lack business context out of the box. As more organizations ask questions of their data using natural language, it is increasingly important to unify business measures and dimensions, ensure consistency company-wide. If you want trustworthy AI, what you need is a semantic layer that acts as the single source of truth for business metrics.

But how do you make that data accessible and actionable for your end users? Building off the recent introduction of Looker’s Model Context Protocol (MCP) server, in this blog we take you through the process of creating an Agent Development Kit (ADK) agent that is connected to Looker via the MCP Toolbox for Databases and exposing it within Gemini Enterprise. Let’s get started.

Step 1 - Set up Looker Integration in MCP Toolbox

MCP Toolbox for Databases is a central open-source server that hosts and manages toolsets, enabling agentic applications to leverage Looker’s capabilities without working directly with the platform. Instead of managing tool logic and authentication themselves, agents act as MCP clients and request tools from the Toolbox. The MCP Toolbox handles all the underlying complexities, including secure connections to Looker, authentication and query execution.

The MCP Toolbox for Databases natively supports Looker’s pre-built toolset. To access these tools, follow the below steps:

Connect to Cloud Shell. Check that you're already authenticated, and that the project is set to your project ID using the following command:

code_block: <ListValue: [StructValue([('code', 'gcloud auth list'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce550>)])]>

Run the following command in Cloud Shell to confirm that the gcloud command knows about your project:

code_block: <ListValue: [StructValue([('code', 'gcloud config list project'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce5b0>)])]>

Create a folder named mcp-toolbox:

code_block: <ListValue: [StructValue([('code', 'mkdir mcp-toolbox'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce3a0>)])]>

Go to the mcp-toolbox folder via the command shown below:

code_block: <ListValue: [StructValue([('code', 'cd mcp-toolbox'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce1f0>)])]>

Install the binary version of the MCP Toolbox for Databases via the script given below. This command is for Linux; if you run on Macintosh or Windows, ensure that you download the correct binary. Check out the releases page for your Operation System and Architecture and download the correct binary.

code_block: <ListValue: [StructValue([('code', 'export OS="linux/amd64" # one of linux/amd64, darwin/arm64, darwin/amd64, or windows/amd64\r\ncurl -O https://storage.googleapis.com/genai-toolbox/v0.12.0/$OS/toolbox\r\nchmod +x toolbox'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abced30>)])]>

Deploy Toolbox to Cloud Run

Next, you’ll need to run MCP Toolbox. The simplest way to do that is on Cloud Run, Google Cloud’s fully managed container application platform. Here’s how:

code_block: <ListValue: [StructValue([('code', 'export PROJECT_ID="YOUR_GOOGLE_CLOUD_PROJECT_ID"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abcea90>)])]>

Enable relevant APIs if needed:

code_block: <ListValue: [StructValue([('code', 'gcloud services enable run.googleapis.com \\\r\n cloudbuild.googleapis.com \\\r\n artifactregistry.googleapis.com \\\r\n iam.googleapis.com \\\r\n secretmanager.googleapis.com'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce400>)])]>

Create a service account and assign necessary roles:

code_block: <ListValue: [StructValue([('code', 'gcloud iam service-accounts create toolbox-identity\r\n\r\ngcloud projects add-iam-policy-binding $PROJECT_ID \\\r\n --member serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com \\\r\n --role roles/secretmanager.secretAccessor\r\n\r\ngcloud projects add-iam-policy-binding $PROJECT_ID \\\r\n --member serviceAccount:toolbox-identity@$PROJECT_ID.iam.gserviceaccount.com \\\r\n --role roles/cloudsql.client'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce4c0>)])]>

For information on getting your client id and secret, read the documentation.

Create a deploy.env file:

code_block: <ListValue: [StructValue([('code', 'LOOKER_BASE_URL="YOUR_LOOKER_URL"\r\nLOOKER_CLIENT_ID="YOUR_CLIENT_ID"\r\nLOOKER_CLIENT_SECRET="YOUR_CLIENT_SECRET"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abcebb0>)])]>

Export the toolbox config into an image variable:

code_block: <ListValue: [StructValue([('code', 'export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce430>)])]>

Deploy MCP Toolbox to Cloud Run:

code_block: <ListValue: [StructValue([('code', 'gcloud run deploy toolbox \\\r\n --image $IMAGE \\\r\n --env-vars-file=deploy.env \\\r\n --service-account toolbox-identity \\\r\n --region us-central1 \\\r\n --args="--prebuilt=looker","--address=0.0.0.0","--port=8080"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce640>)])]>

The Cloud Run will ask if you want Unauthenticated, select No.

Allow Unauthenticated: N

Step 2: Deploy ADK Agent to Agent Engine

Next, you need to configure Agent Development Kit (ADK), a flexible and modular framework for developing and deploying AI agents. ADK was designed to make agent development feel more like software development, to make it easier for developers to create, deploy, and orchestrate agentic architectures that range from simple tasks to complex workflows. And while ADK is optimized for Gemini and the Google ecosystem, it’s also model-agnostic, deployment-agnostic, and is built for compatibility with other frameworks.

Vertex AI Agent Engine, a part of the Vertex AI Platform, is a set of services that enables developers to deploy, manage, and scale AI agents in production. Agent Engine handles the infrastructure to scale agents in production so you can focus on creating applications.

Open a new terminal tab in Cloud Shell and create a folder named my-agents as follows. You also need to navigate to the my-agents folder.

code_block: <ListValue: [StructValue([('code', 'mkdir my-agents\r\ncd my-agents'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce8e0>)])]>

Now, create a virtual Python environment using venv:

code_block: <ListValue: [StructValue([('code', 'python -m venv .venv'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce0d0>)])]>

Activate the virtual environment:

code_block: <ListValue: [StructValue([('code', 'source .venv/bin/activate'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce880>)])]>

Install the ADK and the MCP Toolbox for Databases packages along with langchain dependency:

code_block: <ListValue: [StructValue([('code', 'pip install google-adk toolbox-core'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce580>)])]>

Creating your first Agent Application

Now you’re ready to use adk to create a scaffolding, including folders, environment and basic files, for our Looker Agent Application via the adk create command with an app name looker_app:

code_block: <ListValue: [StructValue([('code', 'adk create looker_app'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abced60>)])]>

Follow the steps and select the following:

Gemini model for choosing a model for the root agent
Vertex AI for the backend
Your default Google Project Id and region

code_block: <ListValue: [StructValue([('code', 'Choose a model for the root agent:\r\n1. gemini-2.5-flash-001\r\n2. Other models (fill later)\r\nChoose model (1, 2): 1\r\n\r\n\r\n1. Google AI\r\n2. Vertex AI\r\nChoose a backend (1, 2): 2\r\n\r\nEnter Google Cloud project ID [your_current_project_id]:\r\nEnter Google Cloud region [us-central1]:\r\n\r\nAgent created in /home/romin/looker-app:\r\n- .env\r\n- __init__.py\r\n- agent.py'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce790>)])]>

Observe the folder in which a default template and required files for the Agent have been created.

First up is the .env file:

code_block: <ListValue: [StructValue([('code', 'GOOGLE_GENAI_USE_VERTEXAI=1\r\nGOOGLE_CLOUD_PROJECT=YOUR_GOOGLE_PROJECT_ID\r\nGOOGLE_CLOUD_LOCATION=YOUR_GOOGLE_PROJECT_REGION'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce7f0>)])]>

The values indicate that you will be using Gemini via Vertex AI along with the respective values for the Google Cloud Project Id and location.

Then you have the __init__.py file that marks the folder as a module and has a single statement that imports the agent from the agent.py file:

code_block: <ListValue: [StructValue([('code', 'from . import agent'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce760>)])]>

Finally, take a look at the agent.py file. The contents can be edited to similar to the example below:

Insert the Cloud Run URL highlighted here (. not the one with the project number in the url).

code_block: <ListValue: [StructValue([('code', 'import os\r\nfrom google.adk.agents import LlmAgent\r\nfrom google.adk.planners.built_in_planner import BuiltInPlanner\r\nfrom google.adk.tools.mcp_tool.mcp_toolset import MCPToolset\r\nfrom google.adk.tools.mcp_tool.mcp_session_manager import SseConnectionParams, StreamableHTTPConnectionParams\r\nfrom google.genai.types import ThinkingConfig\r\nfrom google.auth import compute_engine\r\nimport google.auth.transport.requests\r\nimport google.oauth2.id_token\r\n\r\n# Replace this URL with the correct endpoint for your MCP server.\r\nMCP_SERVER_URL = "YOUR_CLOUD_RUN_URL/mcp"\r\nif not MCP_SERVER_URL:\r\n raise ValueError("The MCP_SERVER_URL is not set.")\r\ndef get_id_token():\r\n """Get an ID token to authenticate with the MCP server."""\r\n target_url = MCP_SERVER_URL\r\n audience = target_url.split(\'/mcp\')[0]\r\n auth_req = google.auth.transport.requests.Request()\r\n id_token = google.oauth2.id_token.fetch_id_token(auth_req, audience)\r\n # Get the ID token.\r\n return id_token\r\n\r\n\r\nroot_agent = LlmAgent(\r\n model=\'gemini-2.5-flash\',\r\n name=\'looker_agent\',\r\n description=\'Agent to answer questions about Looker data.\',\r\n instruction=(\r\n \'You are a helpful agent who can answer user questions about Looker data the user has access to. Use the tools to answer the question. If you are unsure on what model to use, try defaulting to thelook and if you are also unsure on the explore, try order_items if using thelook model\'\r\n ),\r\nplanner=BuiltInPlanner(\r\nthinking_config=ThinkingConfig(include_thoughts=False, thinking_budget=0)\r\n),\r\ntools=[\r\nMCPToolset(\r\nconnection_params=StreamableHTTPConnectionParams(\r\nurl=MCP_SERVER_URL,\r\nheaders={\r\n"Authorization": f"Bearer {get_id_token()}",\r\n}\r\n),\r\nerrlog=None,\r\n# Load all tools from the MCP server at the given URL\r\ntool_filter=None,\r\n)\r\n],\r\n)'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abcedf0>)])]>

Create a Cloud Storage bucket if necessary:

code_block: <ListValue: [StructValue([('code', 'gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce850>)])]>

Ensure you are in the my-agents directory. Update the BUCKET_NAME with the Cloud Storage bucket you want to use:

code_block: <ListValue: [StructValue([('code', 'export PROJECT_ID="YOUR_GOOGLE_CLOUD_PROJECT_ID"\r\nadk deploy agent_engine --project $PROJECT_ID --region us-central1 --staging_bucket gs://BUCKET_NAME --display_name "looker-agent1" looker_app'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abcee20>)])]>

NOTE: Ensure you grant the Cloud Run Invoker role to the default Agent Engine Service Account (i.e., service-PROJECT_NUMBER@gcp-sa-aiplatform-re.iam.gserviceaccount.com)

Step 3: Connect to Gemini Enterprise

Now it’s time to create a Gemini Enterprise app (instructions here).

Run the below command with the GCP Project Number, Reasoning Engine resource name output from the ‘deploy agent_engine’ command above, and your Gemini Enterprise Agent ID from the Gemini Enterprise Apps interface:

code_block: <ListValue: [StructValue([('code', 'export PROJECT_NUMBER="YOUR_PROJECT_NUMBER"\r\nexport REASONING_ENGINE="projects/XXXXX/locations/us-central1/reasoningEngines/XXXXX"\r\nexport DISPLAY_NAME="Looker Agent"\r\nexport DESCRIPTION="Looker\'s MCP Capability."\r\nexport TOOL_DESCRIPTION="Looker\'s Query Engine is used to answer Ecommerce questions."\r\nexport AS_APP="YOUR_GEMENI_ENTERPRISE_AGENT_ID"\r\n\r\ncurl -X POST \\\r\n -H "Authorization: Bearer $(gcloud auth print-access-token)" \\\r\n -H "Content-Type: application/json" \\\r\n -H "X-Goog-User-Project: ${PROJECT_NUMBER}" \\\r\nhttps://discoveryengine.googleapis.com/v1alpha/projects/${PROJECT_NUMBER}/locations/global/collections/default_collection/engines/${AS_APP}/assistants/default_assistant/agents \\\r\n -d \'{\r\n "displayName": "\'"${DISPLAY_NAME}"\'",\r\n "description": "\'"${DESCRIPTION}"\'",\r\n "adk_agent_definition": {\r\n "tool_settings": {\r\n "tool_description": "\'"${TOOL_DESCRIPTION}"\'"\r\n },\r\n "provisioned_reasoning_engine": {\r\n "reasoning_engine":\r\n "\'"${REASONING_ENGINE}"\'"\r\n }\r\n }\r\n }\''), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f491abce970>)])]>

Your Looker data will now be available within your Gemini Enterprise app.

If you don’t have access to this feature, contact your Google Cloud account team.

Querying business data made easier

Connecting Looker's semantic layer to Vertex AI Agent services by way of the ADK and MCP Toolbox is a big win for data accessibility. By exposing your trusted Looker models and Explores in Gemini Enterprise, you empower end-users to query complex business data using natural language. This integration closes the gap between data insights and immediate action, ensuring that your organization's semantic layer is not just a source of passive reports, but an active, conversational, and decision-driving asset.

To get started, connect to the MCP Toolbox for Databases on GitHub and set up Looker integration.

Looker and Looker Conversational Analytics extensions available in the Gemini CLI

Fri, 21 Nov 2025 17:00:00 +0000

The ability to easily access and understand data is essential for modern businesses. The Gemini command line interface (CLI) is an open-source AI agent that provides access to Gemini directly in your terminal, enabling you to interact with Google’s latest AI models directly from the interface you know best. With the release of Looker and Looker Conversational Analytics extensions, available now, you can interact with your Looker data and dashboards from the command line, streamlining your workflows and making data more accessible.

These new extensions for the Gemini CLI simplify your ability to ask complex questions of your data, generate insightful reports, and create new dashboards without leaving your terminal, opening up new possibilities for data exploration and analysis from the applications you use every day.

Getting started

Getting started with the new Looker extensions for the Gemini CLI is straightforward. Here’s how you install and configure them:

1. Install the Gemini CLI:

If you haven't already, you'll need to install the Gemini CLI. You can do so via npm:

code_block: <ListValue: [StructValue([('code', 'npm install -g @google/gemini-cli'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f492335f400>)])]>

2. Install the Looker extension:

To install the Looker extension, use the following command:

code_block: <ListValue: [StructValue([('code', 'gemini extensions install \r\nhttps://github.com/gemini-cli-extensions/looker'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f492335f640>)])]>

3. Install the Looker Conversational Analytics extension:

To install the Looker Conversational Analytics extension, use this command:

code_block: <ListValue: [StructValue([('code', 'gemini extensions install \r\nhttps://github.com/gemini-cli-extensions/looker-conversational-analytics'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7f492335f1c0>)])]>

4. Configure Your Looker connection:

After installation, you’ll need to configure the extensions to connect to your Looker instance. You’ll need a Looker Client ID and Client Secret, which can be obtained by following the instructions in the Looker API authentication documentation. If you don't have access to the Admin pages of the Looker system, ask your administrator to get the ID and Secret for you.

Then set the following environment variables before starting the Gemini CLI. These variables can also be loaded from a .env file.

LOOKER_BASE_URL: The base URL of your Looker instance (e.g., https://looker.example.com). In some cases, you may need to add :19999 to the URL.
LOOKER_CLIENT_ID: The Looker API client ID
LOOKER_CLIENT_SECRET: The Looker API client secret
LOOKER_VERIFY_SSL: (Optional) Whether to verify SSL certificates. Defaults to true

For looker-conversational-analytics, you also need to provide application default credentials with the correct roles as well as a GCP project with the proper APIs enabled. See https://googleapis.github.io/genai-toolbox/resources/sources/looker/ for all the details. In addition, you need to define these environment variables:

LOOKER_PROJECT: The Google Cloud Project to use
LOOKER_LOCATION: The Google Cloud Location to use, such as us

Dive deeper

The release of these new extensions is a valuable milestone in our efforts to bring the full benefits of Gemini and Looker together for you. To help you get the most out of these new extensions, we've prepared relevant documentation within MCP Toolbox. These resources provide detailed information on all the available tools and functionality.

We welcome your feedback as we continue to innovate. Get started today and unlock the full potential of your data.

Talk with and trust your data using Looker’s Conversational Analytics, now GA

Thu, 13 Nov 2025 17:00:00 +0000

In a world of increasing data volume and demand, businesses are looking to make faster decisions and separate insight from noise. Today, we’re bringing Conversational Analytics to general availability in Looker, delivering natural language queries to everyone in your organization, removing BI bottlenecks. With Conversational Analytics, we’re transforming the way you get answers, cutting through stale dashboards and accelerating data discovery. Our goal: make analytics and AI as easy and scalable as performing a Google search, extending BI to the broader enterprise as you go from prompt to full data exploration in seconds.

Instant AI-powered insights with Conversational Analytics in Looker

We announced the preview of Conversational Analytics at Google Cloud Next in April. Since then, we’ve also extended the ability to leverage Google’s latest Gemini models with your own custom applications through the Conversational Analytics API, showcased productivity improvements that come from the convergence of AI and BI, and empowered today’s modern data analysts and developers to do more, faster.

Now, with Conversational Analytics, getting an answer from your data is as simple as chatting with your most knowledgeable colleague. By tapping into human conversation, Conversational Analytics relieves you from struggling with complex dashboard filters, obscure field names, or the need to write custom SQL.

"At YouTube, we're focused on helping creators succeed and bring their creativity to the world. We've been testing Conversational Analytics in Looker to give our partner managers instant, actionable data that lets them quickly guide creators and optimize creator support." - Thomas Seyller, Senior Director, Technology & Insights, YouTube Business

The general availability of Conversational Analytics combines the reasoning power of Gemini, new capabilities in Google’s agentic frameworks, and the trusted data modeling of the Looker platform. Together, these set the stage for the next chapter in self-service analytics, making reliable data insights accessible to the entire enterprise. Conversational Analytics agents can understand your questions and provide insightful answers to questions about your data.

New at general availability is the ability to analyze data across domains. You can ask questions that integrate insights from up to five distinct Looker Explores (pre-joined views), spanning multiple business areas. Additionally, you can share the agents you build with colleagues, giving them faster access to a single source of truth, speeding consensus, and driving uniform decisions.

You can build and share agents with colleagues to have a consistent data picture.

Built on a trusted, governed foundation

The power of Conversational Analytics isn't just in the conversation it enables; it's in the trust of the underlying data. Conversational Analytics is grounded in Looker’s semantic layer, which ensures that every metric, field, and calculation is centrally defined and consistent, acting as a crucial context engine for AI. As more of your colleagues rapidly use these expanded capabilities, you need to know the results they see and act on are accurate.

For analysts looking to explore data or everyday users receiving insights in the context of their business, Conversational Analytics also improves data self-service, minimizing technical friction that can create bottlenecks and leaves insights locked away.

You can now:

Ask anything, anytime: Get instant answers to simple questions like “Show me our website traffic last month for shoe sales,” leading to deeper questions and greater insights across business areas and domains.
Deepen the discovery: Move beyond the constraints of static dashboards and ask open-ended questions like, “Show me the trend of website traffic over the past six months and filter it by the California region.” The system intelligently generates the appropriate query and visualization instantly.
Extend enterprise BI: Connect your Looker models to your enterprise BI ecosystem, centralize and share agents, and create new dashboards, starting with a prompt. Built on top of Looker Explores, Conversational Analytics’ natural language interface usesLookML for fine tuning and output accuracy.
Pivot quickly: The conversational interface supports multi-turn questions, so you can iterate on your findings. Ask for total sales, then follow up with, "Now show me that as an area chart, broken down by payment method."
Gain full transparency: To build confidence and data literacy, the "How was this calculated?" feature provides a clear, natural language explanation of the underlying query that generated the results, so that you understand the source of your findings.

Empower the BI analyst and business user

Conversational Analytics is democratizing data for business teams, helping them govern the business’s data. At the same time, it’s also enhancing productivity and influence for data analysts and developers.

When business users can self-serve trusted data insights, data analysts see fewer interruptions and “ad-hoc” ticket requests, and can instead focus on high-impact work. Analysts can customize their client teams’ BI experiences by building Conversational Analytics agents that define common questions, filters, and style guidelines, so different teams can act on the same data in different ways.

Get ready to start talking

Conversational Analytics is available now for all Looker platform users. Your admin can enable it in your Looker instance today and you will discover how easy it is to move from simply asking “What?” to confidently determining “What’s next?” For more information, review the product documentation or watch this video tutorial.

Chat with your data from anywhere: Announcing Google’s Conversational Analytics API

Mon, 25 Aug 2025 16:00:00 +0000

Decision-makers, employees, and customers all need answers where they work: in the applications they use every day. In recent years, the rise of AI-powered BI has transformed our relationship with data, enabling us to ask questions in natural language and get answers fast. But even with support for natural language, the insights you receive are often confined to the data in your BI tool. At Google Cloud, our goal is to change this.

At Google Cloud Next 25, we introduced the Conversational Analytics API, which lets developers embed natural-language query functionality in custom applications, internal tools, or workflows, all backed by trusted data access and scalable, reliable data modeling. The API is already powering first-party Google Cloud conversational experiences including Looker and BigQuery data canvas, and is available for Google Cloud developers of all stripes to implement wherever their imagination takes them. Today we release the Conversational Analytics API in public preview. Start building with our documentation.

The Conversational Analytics API lets you build custom data experiences that provide data, chart, and text answers while leveraging Looker's trusted semantic model for accuracy or providing critical business and data context to agents in BigQuery. You can embed this functionality to create intuitive data experiences, enable complex analysis via natural language, and even orchestrate conversational analytics agents as ‘tools’ for an orchestrator agent using Agent Development Kit.

The Google Health Population app is being developed with the Conversational Analytics API

Getting to know the Conversational Analytics API

The Conversational Analytics API allows you to interact with your BigQuery or Looker data through chat, from anywhere. Embed side-panel chat next to your Looker dashboards, invoke agents in chat applications like Slack, customize your company’s web applications, or build multi-agent systems.

This API empowers your team to obtain answers precisely when and where they are needed, directly within their daily workflows. It achieves this by merging Google's advanced AI models and agentic capabilities with Looker's semantic layer and BigQuery's context engineering services. The result is natural language experiences that can be shared across your organization, making data-to-insight interaction seamless in your company's most frequently used applications.

aside_block: <ListValue: [StructValue([('title', '$300 in free credit to try Google Cloud data analytics'), ('body', <wagtail.rich_text.RichText object at 0x7f49430c3730>), ('btn_text', ''), ('href', ''), ('image', None)])]>

Building with Google’s Analytics and AI stack comes with significant benefits in accurate question answering:

Best-in-class AI for data analytics
An agentic architecture that enables the system to perceive its environment and take actions
Access to Looker’s powerful semantic layer for trustworthy answers
High-performance agent tools, including software functions, charts and APIs, supported by dedicated engineering teams
Python code interpreter for advanced analysis
Tune your agent’s knowledge with structured context and prompts

Flexibility to build the agentic applications that best suit your data needs:

Create, update, and share agents that let users chat with BigQuery or Looker data
Lower maintenance burden via stateful APIs for agent and conversation management
Full control of your user experience via our stateless chat API
Build multi-agent architectures by wrapping APIs with ADK and MCP
Help agents understand your business and data with AI-Assisted context engineering
Version control your agents, updating prompts without affecting production use

And the enterprise controls and security you expect from Google Cloud Platform:

Govern the use of agents using role based access controls
Trust your data is secure with data with row and column level access controls by default
Guard against expensive queries with built-in query limitations

When pairing Conversational Analytics API with Looker, Looker’s semantic layer reduces data errors in gen AI natural language queries by as much as two thirds, so that queries are sourced in truth.

Looker’s semantic layer ensures your conversational analytics are grounded in data truth.

An agentic architecture powered by Google AI

The Conversational Analytics API uses purpose-built models for querying and analyzing data to provide accurate answers, while its flexible agentic architecture lets you configure which capabilities the agent leverages to best provide users with answers to their questions.

Conversational Analytics leverages an agentic architecture to empower agent creators with the right tools.

As a developer, you can compose AI-powered agents with the following tools:

Text-to-SQL, trusted by customers using Gemini in BigQuery
Context retrieval, informed by personalized and organization usage
Looker's NL-to-Looker Query Engine, to leverage the analyst-curated semantic layer
Code Interpreter, for advanced analytics like forecasting and root-cause analysis
Charting, to create stunning visualizations and bring data to life
Insights, to explain answers in plain language

These generative AI tools are built upon Google’s latest Gemini models and fine-tuned for specific data analysis tasks to deliver high levels of accuracy. There’s also the Code Interpreter for Conversational Analytics, which provides computations ranging from cohort analysis to period-over-period calculations. Currently in preview, Code Interpreter turns you into a data scientist without having to learn advanced coding or statistical methods. Sign up for early access here.

Context retrieval and generation

A good data analyst isn’t just smart, but also deeply knowledgeable about your business and your data. To provide the same kind of value, a “chat with your data” experience should be just as knowledgeable. That’s why the Conversational Analytics API prioritizes gathering context about your data and queries.

Thanks to retrieval augmented generation (RAG), our Conversational Analytics agents know you and your data well enough to know that when you’re asking for sales in “New York” or “NYC,” you mean “New York City.” The API understands your question’s meaning to match it to the most relevant fields to query, and learns from your organization, recognizing that, for example, “revenue_final_calc” may be queried more frequently than “revenue_intermediate” in your BigQuery project, and adjusts accordingly. Finally, the API learns from your past interactions; it will remember that you queried about “customer lifetime value” in BigQuery Studio on Tuesday when you ask about it again on Friday.

Not all datasets have the context an agent needs to do its work. Column descriptions, business glossaries, and question-query pairs can all improve an agent’s accuracy, but they can be hard to create manually— especially if you have 1,000 tables in your business, each with 500 fields. To speed up the process of teaching your agent, we are including AI-assisted context, using Gemini to suggest metadata that might be useful for your agent to know, while letting you approve or reject changes.

Low maintenance burden

The Conversational Analytics API gives you access to the latest data agent tools from Google Cloud, so you can focus on building your business, not building more agents. You benefit from Google’s continued advancements in generative AI for coding and data analysis.

When you create an agent, we protect your data with Google’s security, best practices, and role-based access controls. Once you share your Looker or BigQuery agent, it can be used across Google Cloud products, such as Agent Development Kit, and in your own applications.

The Conversational Analytics API lets you interact with your data anywhere.

API powered chats from anywhere

With agents consumable via API, you can surface insights anywhere decision makers need them—whether it’s when speaking with a customer over a support ticket, via a tablet when you’re in the field, or in your messaging apps.

The Conversational Analytics API is designed to bring benefits to all users, whether they be business users, data analysts building agents, or software developers. With Conversational Agents, when a user asks a question, answers are delivered rapidly alongside the agent’s thinking process, to ensure the right approach to gaining insights is used. Individual updates allow your developers to control what a user sees — like answers and charts — and what you want to log for later auditing by analysts — like SQL and Python code.

To get started, you can use our documentation and API references for REST APIs and SDKs, as well as code examples in example Colab notebooks, streamlit application on GitHub, and typescript reference application.

Looker debuts MCP Server to broaden AI developer access to data

Fri, 08 Aug 2025 16:00:00 +0000

As companies integrate AI into their workflows, connecting new tools to their existing data while ensuring consistent security and accuracy becomes increasingly important. We’re introducing Looker Model Context Protocol (MCP) Server, an integration in the MCP Toolbox for Databases. This allows AI applications such as chatbots and custom agents to connect to trusted data from the environments AI developers use every day.

Looker already helps thousands of organizations to access, analyze, and act on a single, consistent, and governed view of their data through its robust semantic layer, connecting to hundreds of data sources such as BigQuery, AlloyDB, and Cloud SQL. With the launch of the Looker in MCP Toolbox, we are extending our leadership in trusted generative AI for BI by bringing this functionality to the emerging world of AI applications and agents.

MCP is an open standard technology that allows large language models (LLMs) and AI applications to access other products consistently and securely. Looker’s MCP Toolbox integration connects applications to the LLM along with structured metadata and specific request parameters. In addition, the MCP Server can expose unstructured natural language information about how the data source is called and what type of information it returns.

MCP essentially acts as a universal translator, enabling AI models to:

Discover and use tools dynamically: Rather than hardcoded integrations, AI agents can identify and interact with available capabilities in real-time.
Access relevant, up-to-date context: AI models can pull live, verified information directly from its source, significantly reducing hallucinations and improving response accuracy.
Ensure secure and governed data access: MCP provides a host-mediated security model, allowing fine-grained control over what data AI agents can access and how.

Accessing Looker from Gemini-CLI

Accessing Looker from Claude Desktop

Intelligent AI apps, meet intelligent data

The debut of Looker’s MCP Server, combined with its semantic layer, transforms the opportunity for data-driven AI. There is no need for AI to write SQL. The AI queries Looker’s semantic layer and Looker generates the correct, optimized SQL. Here’s what this means for your organization:

Trusted data for AI, on-demand: Looker's semantic layer ensures that all your business metrics and definitions are consistent and governed. With the Looker MCP Server, AI agents can now directly query this single source of truth, receiving accurate and reliable data-driven insights without the risk of misinterpretation or outdated information.
Enhanced security and data governance for AI: Looker’s MCP Toolbox integration inherits Looker's robust security model, allowing administrators to define precise access controls for AI agents. You can dictate which AI applications can access what data, at what granularity, and for what purpose, all within the familiar Looker environment. Sensitive data remains protected, and audit trails ensure compliance.
Accelerated AI application development: Developers building AI-powered applications that need to interact with enterprise data often face complex integration challenges. By exposing Looker's rich data models via a standardized MCP interface, AI developers can now easily connect their agents to a pre-defined, trusted data layer, reducing development time and effort.
Integration with the tools your AI developers use: Looker’s MCP Toolbox integration can be accessed today through any agent that supports MCP, including offerings such as Gemini’s Command Line Interface, Anthropic’s Claude Desktop, and Cursor.

Get started with Looker MCP Server

Looker’s MCP Server via MCP Toolbox continues Google Cloud’s commitment to making data truly useful and accessible, for all users, including the next generation of intelligent AI applications. We believe this release will empower organizations to unlock unprecedented value from their data through modern AI tools, driving smarter decisions and accelerating innovation across every facet of their business.

To get started with Looker MCP Server, check out our Quickstart guide on Github.

Announcing AI-first Colab notebook experience for Google Cloud

Wed, 06 Aug 2025 01:00:00 +0000

At Google I/O 2025, we announced a new, reimagined AI-first Colab with agentic capabilities, making it a true coding partner that understands your current code, actions, intentions, and goals. Today, we are excited to bring these capabilities to Google Cloud BigQuery and Vertex AI via the Colab Enterprise notebook. Designed to simplify and transform data science and analytics workflows for organizations, the new capabilities in the Colab Enterprise notebook can:

Automate end-to-end data science workflows through the built-in Data Science Agent (DSA), which creates multi-step plans, generating and executing code, reasons about the results, and presents its findings.
Generate, explain and transform code, as well as explain errors and fix them automatically. It can also provide code assistance while you type.
Create visualizations from simple prompts.

Let’s take a closer look.

Simplify workflows with Data Science Agent

Data science can be complex, iterative, and time-consuming. You must first translate your business problem into a machine learning task, identify and clean raw data, transform it, train a model, evaluate it and then repeat the loop to optimize it. This requires skill and time. The Data Science Agent (DSA) in Colab accelerates data science development with agentic capabilities that facilitate data exploration, transformation and ML modeling.

You start with a simple prompt such as “Train a model to predict ‘income bracket’ from table bigquery-public-data.ml_datasets.census_adult_income“ in the notebook chat. The Data Science Agent then generates a detailed plan covering all aspects of data science modeling from data loading, exploration, cleaning, visualization, feature engineering, data splitting, model training/optimization and evaluation.

You can accept, cancel, or modify this plan. The generated code is executed on the Colab runtime. If the agent makes an error it can autocorrect and generate new code rectifying it. You maintain full control, approving each step and can make manual edits if desired. This iterative approach ensures transparency and trust.

The agent also has full contextual awareness of your notebook, understanding existing code, outputs, and variables to provide tailored code for each step of the plan, allowing you to also make iterative changes to your existing code.

Data Science Agent helps simplify workflows

Once you are satisfied with the notebook you’ve co-developed with AI, you can then schedule it for automated runs, or use it in a multi-step DAG with BigQuery Pipelines.

Multi-cell code generation for anything you want to do with data

AI-first Colab Enterprise notebooks also support code generation for a wide range of tasks and follow the same interaction pattern as the Data Science Agent mentioned above. For example, using the chat interface you can prompt to:

Generate code for arbitrary Python-based data transformation, visualization, analytics (e.g., run a causal analysis).
Manage Colab environment (e.g., install new libraries).
Generate code for interacting with other Google Cloud services (e.g., manage a function deployment to Cloud Run).

The human-in-the-loop interaction design allows for approval, changes and editing of the generated code.

Code generation using the chat interface

You can also transform your existing code. Simply describe a change in natural language (e.g., "add error handling to this data loading function" or "refactor this monolithic function into smaller, more modular parts") and the agent will identify and modify the relevant code for you.

Easy visualizations

The Python visualization ecosystem is rich with many choices such as Matplotlib, Seaborn, Plotly etc. While these already work well in Colab notebooks, using these libraries requires writing boilerplate code and high familiarity with the library to get a chart with good fit and finish.

AI-First Colab Notebooks excel in generating Python code for such visualizations. Simply start with a prompt like "Generate a chart displaying..." referencing your data source which can be a BigQuery table, a local Dataframe in Colab or even an uploaded file. Next just approve and run the code to have the visualization generated for you. To modify the visualization, for example, change axis to log axis or change color of a chart, simply prompt for the incremental changes and the agent will adjust the code to your needs.

Generate Python code for easy visualizations

Explaining and fixing errors

Colab has an built-in error explanation and fixing flow. If your AI generated or user authored code cell runs into an error, you can click the ‘Explain Error’ shortcut which opens the notebook chat, which explains the error and generates the remediation code in diff view for approval.

Explain and fix errors

Fast and intelligent code completion

Code completion in Colab Enterprise offers implicit suggestions as you type, accelerating your workflow by reducing keystrokes. Accept suggestions with a tab or modify them.

Code completion in Colab Enterprise

Get started today

The AI-first Colab Enterprise with its Data Science Agent is transforming how data professionals work. Across BigQuery and Vertex AI, the Colab Enterprise experience is seamless and the notebooks created are interoperable, regardless of where they are created.

To access Colab Enterprise:

BigQuery: Navigate to Google Cloud Console > BigQuery > Notebook
Vertex AI: Navigate to Google Cloud Console > Vertex AI > Colab Enterprise.

The AI-first notebook experience with Data Science Agent is currently available in US and Asia regions in Preview and will be rolled out to other Google Cloud regions in the coming days.

If you have a feature request, a question on availability in your region or feedback, reach us at vertex-notebooks-previews-external@google.com or fill out this form.

How to tap into natural language AI services using the Conversational Analytics API

Wed, 09 Jul 2025 18:00:00 +0000

AI is making it easier than ever to get clear, reliable answers from your data. With intelligent tools like the Conversational Analytics API, powered by Gemini, you no longer need intricate systems to get insights.

The Conversational Analytics API lets you use everyday language to ask questions of your data in BigQuery or Looker, with more sources to come. This brings powerful business intelligence to your entire organization through the apps you already use, like Slack. Developers can also build custom data agents that understand your business and provide answers where they're needed.

Now in preview, this API transforms unstructured conversation and structured data into actionable insights, accessible through natural language. You can create custom data agents, map business terms, and define calculations to empower your users and analysts.

aside_block: <ListValue: [StructValue([('title', 'Try Google Cloud for free'), ('body', <wagtail.rich_text.RichText object at 0x7f494312edf0>), ('btn_text', 'Get started for free'), ('href', 'https://console.cloud.google.com/freetrial?redirectPath=/welcome'), ('image', None)])]>

Conversational Analytics API’s intelligent toolkit

The Conversational Analytics API integrates multiple AI-powered tools to process user requests, including Natural Language to Query (NL2Query) and a Python code interpreter for generating responses. A critical context retrieval tool is also utilized to ensure the API's answers are accurate and relevant by incorporating details about your specific datasets.

Let's take a peek under the hood:

The engine that powers the Conversational Analytics API

Context retrieval: The key to unlocking relevant answers

For intelligent conversational data interactions, leveraging the context retrieval tool is essential. For BigQuery, the tool meticulously pulls schema information, detailed column, table descriptions from Dataplex. When interacting with Looker, it accesses the LookML model, retrieving field definitions, labels, and defined measures. This deep, accurate understanding of your data's structure, relationships, and inherent business logic is critical as it enables the agent to become an expert in your data landscape. This ensures every response is firmly grounded, highly relevant, and ultimately, a trusted answer for your business, providing reliable and trusted answers.

NL2Query engine: Turning questions into queries

At the core of the Conversational Analytics API lies a robust NL2Query engine, designed to support both BigQuery and Looker data sources. This engine translates user-provided natural language questions into semantically equivalent and syntactically correct queries appropriate for the specified data source.

For instance, a user could pose a question such as, "What is the average sales value per order item broken down by payment method?" and the engine would process this to generate and execute the necessary query, providing a precise answer without requiring the user to write any SQL. The NL2Query engine's capability includes handling ambiguity and inferring the customer’s intent from natural language input, ensuring accurate mapping to the underlying dataset structure.

NL2Query transforms natural language to data queries

Python code interpreter: Unleash advanced analytics

Building upon basic query capabilities, the code interpreter functionality within the Conversational Analytics API leverages Python to facilitate advanced analytical tasks. This allows the API to generate and execute Python code for complex calculations and statistical analyses, going beyond what standard query languages can achieve. Users can address intricate scenarios that would be difficult or impossible with SQL alone, accessing sophisticated analyses like statistical modeling and data transformations through Python libraries, all via a conversational interface without needing direct Python coding.

For instance, a user could request to “Calculate churn rate by customer segment, and show me the distribution.” In response, the code interpreter would automatically generate and execute the necessary Python code to perform this analysis and deliver insightful visualizations and statistics.

Code interpreter simplifies data science, leveraging Python code for complex calculations

If you are Interested in testing out the code interpreter tool, currently in preview. Learn more here.

Intelligent visualization engine for data stories that pop

Data in its raw form can often be challenging to interpret. The visualization engine within the Conversational Analytics API addresses this by transforming the results of your queries into compelling visual representations. This capability streamlines the data visualization process, providing benefits such as instant chart generation without the manual steps of selecting data, labeling axes, or choosing chart types and colors. The result is the transformation of numerical data into visually engaging and easily digestible insights that effectively highlight hidden patterns and trends.

For example, a user could request to "Plot total orders by month," and the system would instantly generate a relevant visualization, such as a line chart, effectively illustrating sales performance over time, ready for sharing and analysis.

Gemini powers smart visualizations to quickly illustrate your data

Start having intelligent conversations with your data

Stop struggling with data complexity. Request a demo today or turn on Conversational Analytics in Looker to begin chatting with your data. You can even bring Conversational Analytics to your own application with this API. Get started in minutes with our quickstart application here.

Chat with confidence: Unpacking security in Looker Conversational Analytics

Mon, 07 Jul 2025 16:00:00 +0000

The landscape of business intelligence is evolving rapidly, with users expecting greater self-service and natural language capabilities, powered by AI. Looker’s Conversational Analytics empowers everyone in your organization to access the wealth of information within your data. Select the data you wish to explore, ask questions in natural language, as you would a colleague, and quickly receive insightful answers and visualizations that are grounded in truth, thanks to Looker’s semantic layer. This intuitive approach lowers the technical barriers to data analysis and fosters a more data-driven culture across your teams.

How does this work? At its core, Conversational Analytics understands the intent behind your questions. Enhanced by Gemini models, the process involves interpreting your natural language query, generating the appropriate data retrieval logic, and presenting the results in an easy-to-understand format, often as a visualization. This process benefits from Looker’s semantic model, which simplifies complex data with predefined business metrics, so that Gemini’s AI is grounded in a reliable and consistent understanding of your data.

Prioritizing privacy in Gemini

The rise of powerful generative AI models like Gemini brings incredible opportunities for innovation and efficiency. But you need a responsible and secure approach to data. When users use AI tools, questions about data privacy and security are top of mind. How are prompts and data used? Are they stored? Are they used to train the model?

At Google Cloud, the privacy of your data is a fundamental priority when you use Gemini models, and we designed our data governance practices to give you control and peace of mind. Specifically:

Your prompts and outputs are safe

Google Cloud does not train models on your prompts or your company's data.

Conversational Analytics only uses your data to answer your business questions — making data queries, creating charts and summarizations, and providing answers. We store agent metadata, such as special instructions, to improve the quality of the agent’s answers, and so you can use the same agent in multiple chat sessions. We also store chat conversations so you can pick up where you left off. Both are protected via IAM and not shared with anyone outside your organization without permission.

aside_block: <ListValue: [StructValue([('title', 'Try Google Cloud for free'), ('body', <wagtail.rich_text.RichText object at 0x7f49386c0340>), ('btn_text', 'Get started for free'), ('href', 'https://console.cloud.google.com/freetrial?redirectPath=/welcome'), ('image', None)])]>

Your data isn’t used to train our models

The data processing workflow in Conversational Analytics involves multiple steps:

The agent sees the user's question, identifies the specific context needed to answer it, and uses tools to retrieve useful context like sample data and column descriptions.
Using business and data context and the user question, the agent generates and executes a query to retrieve the data. The data is returned, and the resulting data table is generated.
Previously gathered information can then be used to create visualizations, text explanations, or suggested follow-up questions. Through this process, the system keeps track of the user's question, the data samples, and the query results, to help formulate a final answer.
When the user asks a new question, such as a follow-up, the previous context of the conversation helps the agent understand the user’s new intent.

Enhancing trust and security in Conversational Analytics

To give you the confidence to rely on Conversational Analytics, we follow a comprehensive set of best practices within Google Cloud:

Leverage Looker’s semantic layer: By grounding Conversational Analytics in Looker’s semantic model, we ensure that the AI model operates on a trusted and consistent understanding of your business metrics. This not only improves the accuracy of insights but also leverages Looker’s established governance framework.
Secure data connectivity: Conversational Analytics connects to Google Cloud services like BigQuery, which have their own robust security measures and access controls. This helps ensure that your underlying data remains protected.
Use data encryption: Data transmitted to Gemini for processing is encrypted in-transit, safeguarding it from unauthorized access. Agent metadata and conversation history are also encrypted.
Continuously monitor and improve: Our teams continuously monitor the performance and security of Conversational Analytics and Gemini in Google Cloud.

Role-based access controls

In addition, Looker provides a robust role-based access control (RBAC) framework that Conversational Analytics leverages to offer granular control over who can interact with specific data. When a Looker user initiates a chat with data, Looker Conversational Analytics respects their established Looker permissions. This means they can only converse with Looker Explores to which they already have access. For instance, while the user might have permission to view two Looker Explores, an administrator could restrict conversational capabilities to only one. As conversational agents become more prevalent, the user will only be able to use those agents to which they have been granted access. Agent creators also have the ability to configure the capabilities of Conversational Analytics agents, for example limiting the user to viewing charts while restricting advanced functionalities like forecasting.

Innovate with confidence

We designed Gemini to be a powerful partner for your business, helping you create, analyze, and automate with Google’s most capable AI models. We’re committed to providing you this capability without compromising your data’s security or privacy, or training on your prompts or data. By not storing your prompts, data, and model outputs or using them for training, you can leverage the full potential of generative AI with confidence, knowing your data remains under your control.

By following these security principles and leveraging Google Cloud’s robust infrastructure, Conversational Analytics offers a powerful, insightful experience that is also secure and trustworthy. By making data insights accessible to everyone securely, you can unlock new levels of innovation and productivity in your organization. Enable Conversational Analytics in Looker today, and start chatting with your data with confidence.

Looker developers gain speed and accuracy with debut of Continuous Integration

Mon, 23 Jun 2025 17:00:00 +0000

With more than a thousand connected data sources available out-of-the-box and an untold number of custom tools, developers rely on Looker’s cloud-first, open-source-friendly model to create new data interpretations and experiences. Today, we are taking a page from modern software engineering principles with our launch of Continuous Integration for Looker, which will help speed up development and help developers take Looker to new places.

As a developer, you rely on your connections to be stable, your data to be true, and for your code to run the same way every time. And when it doesn’t, you don’t want to spend a long time figuring out why the build broke, or hear from users who can’t access their own tools.

Continuous Integration for Looker helps streamline your code development workflows, boost the end-user experience, and give you the confidence you need to deploy changes faster. With Continuous Integration, when you write LookML code, your dashboards remain intact and your Looker content is protected from database changes. This helps to catch data inconsistencies before your users do, and provides access to powerful development validation capabilities directly in your Looker environment.

With Continuous Integration, you can automatically unify changes to data pipelines, models, reports, and dashboards, so that your business intelligence (BI) assets are consistently accurate and reliable.

Continuous Integration in Looker checks your downstream dependencies for accuracy and speeds up development.

Developers benefit from tools that help them maintain code quality, ensure reliability, and manage content effectively. As Looker becomes broadly adopted in an organization, with more users creating new dashboards and reports and connecting Looker to an increasing number of data sources, the potential for data and content errors can increase. Continuous Integration proactively tests new code before it is pushed to production, helping to ensure a strong user experience and success.

Specifically, Continuous Integration in Looker offers:

Early error detection and improved data quality: Minimize unexpected errors in production. Looker’s new Continuous Integration features help LookML developers catch issues before new code changes are deployed, for higher data quality.
Validators that:

Flag upstream SQL changes that may break Looker dimension and measure definitions.
Identify dashboards and Looks that reference outdated LookML definitions.
Validate LookML for errors and antipatterns as a part of other validations.

Enhanced developer efficiency: Streamline your workflows and integrate Continuous Integration pipelines, for a more efficient development and code review process that automatically checks code quality and dependencies, so you can focus on delivering impactful data experiences.
Increased confidence in deployments: Deploy with confidence, knowing your projects have been thoroughly tested, and confident that your LookML code, SQL queries, and dashboards are robust and reliable.

Continuous Integration flags development issues early.

Manage Continuous Integration directly within Looker

Looker now lets you manage your continuous integration test suites, runs, and admin configurations within a single, integrated UI. With it, you can

Easily monitor the status of your Continuous Integration runs and manage your test suites directly in Looker.
Leverage powerful validators to ensure accuracy and efficiency of your SQL queries, LookML code, and content.
Trigger Continuous Integration runs manually or automatically via pull requests or schedules whenever you need them, for control over your testing process.

In today's fast-paced data environment, speed, accuracy and trust are crucial. Continuous Integration in Looker helps your data team promote developmental best practices, reduce risk of introducing errors in production, and increase your organization’s confidence in its data. The result is a consistently dependable Looker experience for all users, including those in line-of-business, increasing reliability across all use cases. Continuous Integration in Looker is now available in preview. Explore its capabilities and see how it can transform your Looker development workflows. For more information, check our product documentation to learn how to enable and configure Continuous Integration for your projects.

Google is a Leader in the 2025 Gartner® Magic Quadrant™ for Analytics and Business Intelligence Platforms

Wed, 18 Jun 2025 15:30:00 +0000

We are pleased to share that Gartner® has named Google a Leader in the 2025 Magic Quadrant™ for Analytics and Business Intelligence, for the second consecutive year. We believe this validates our strategy of delivering a comprehensive BI platform for self-service and governed environments that’s accessible to entire organizations through natural language, and backed by trusted data enabled by a semantic modeling layer.

Download the complimentary 2025 Gartner Magic Quadrant for Analytics and Business Intelligence Platforms.

Generative AI has redefined what a business intelligence platform can offer. In the past year, we introduced Conversational Analytics, a new way for people in all parts of your organization to talk with their data and get answers, using simple, natural language, while also delivering many AI-powered capabilities to the Looker platform, including slide generation, formula creation and more. We also set the stage for AI agents grounded in truth with Looker’s trusted metrics, expanded our semantic layer to new third-party providers, introduced Looker reports for Google-easy dashboarding, and debuted continuous integration to help developers build and test faster.

The goal: infusing trusted data into a company’s every workflow and decision.

The generative AI revolution in BI

The deep integration of Google's foundational Gemini models into the Looker platform has ushered in a new era of AI-powered business intelligence, making data exploration and analysis more accessible and insightful than ever before.

The AI-powered capabilities that we introduced in the past year are fundamentally changing how users interact with their data:

Conversational Analytics: Users can now ask complex questions of their data in natural language and instantly receive intelligent, visualized answers. This empowers business users to self-serve their data needs without writing a single line of code, freeing up data teams to focus on more strategic initiatives.
Code Interpreter in Conversational Analytics translates your natural-language questions into Python code, and executes that code to provide advanced analysis and visualizations. This helps with more complex scenarios, such as “what if” questions, period-over-period growth analysis and more.
AI-powered development: Every action in the Looker platform is powered by Google’s Gemini models, accelerating all of your BI actions, from writing and debugging LookML, developing robust and reliable data models, to building new reports and slides.
Automated slide generation and formula creation: With Google’s latest Gemini models, Looker re-envisions the way you create and share information in the AI age. You can create Google Slides presentations with insightful chart summaries in seconds, or tap into the formula assistant to build calculated fields that leverage metrics and dimensions based on your own unique data.

Looker agents, leveraging the Conversational Analytics API, will soon be available in Agentspace, providing a central repository for discovery and access so they are simple to deploy and manage.

Google-easy data storytelling with Looker reports

Building on our commitment to flexible and powerful data visualization, we introduced a new, more intuitive Looker reports experience. This reimagined reporting capability provides a beautiful and collaborative canvas for data exploration and storytelling, complete with:

Enhanced visualization capabilities: New chart types and customization options give users more control over how they present their data to tell compelling narratives.
Simplified, collaborative workflows: The new reporting interface makes it easier than ever to build, share, and collaborate on reports, fostering a more inclusive data culture.
Responsive canvas: Reports are now more responsive, for a smooth viewing experience across screen sizes for devices ranging from desktops, to tablets, to mobile.

Empowering developers and embedded experiences

At Looker, we know the only limitations on developer creativity are those you set on yourself. That is, unless tools get in the way. With that in mind, we continue to invest heavily in the developer experience.

Our new Conversational Analytics API allows you to embed natural-language querying directly into your applications and workflows, unlocking a new level of interactivity and user engagement for embedded analytics experiences. When applied in combination with Looker Embedded and the emerging Model Context Protocol (MCP) standard, developers can now build and design custom conversational agents for BI for their own applications and innovations.

Agentspace will serve as a centralized hub for managing and sharing Looker agents, enhancing discoverability and simplifying deployment. With this approach, teams can quickly leverage AI-powered insights and share agents across teams, promoting a more data-driven culture. And with the Agent Development Kit announced at Google Cloud Next ‘25, Google is providing a rich model and tooling ecosystem designed for multi-agent capabilities.

Code Interpreter in Conversational Analytics enables users to perform advanced analysis that historically has required specialized knowledge of advanced coding or statistical methods. Code Interpreter excels at questions that go beyond the scope of the standard BI query, such as "What were the key drivers of sales in my data?" or "What were our quarterly sales in 2023 and 2024, and what was the quarter-over-quarter growth?". Also, we know that in the world of AI-powered data, an answer holds little value if you can’t verify how it was generated. That's why Code Interpreter shows its work. For every answer it produces, you can expand a "How is this calculated?" section to see the exact Python code that was run, ensuring it's not a black box.

We also know developers need to trust that their applications and dashboards are accurate and will build properly every time. To enhance the reliability and speed of LookML development, the Spectacles.dev team joined Google Cloud, and is working hard to deliver powerful continuous integration (CI) and automated testing capabilities to the Looker platform, helping to ensure data quality and consistency at scale.

Bringing trust to every gen-AI-powered business

In the AI era, data drives your business, your apps and your decisions. You need your data to be accurate and consistent, but that hasn’t always been the case with traditional tools. In this new world, trusted definitions managed by a semantic layer are a must-have, backed by unique information about your business. It is not enough to have reports and dashboards be available or simply delightful — they must take full advantage of data agents for specific use cases, or be embedded in third-party apps that your organization uses every day.

The combination of Looker's powerful semantic model with Google's leading AI capabilities delivers a new foundation for business intelligence — one that is more intelligent, intuitive, and impactful than ever before. Our own testing shows that by building with Looker’s semantic layer, data errors in gen AI natural language queries are reduced by as much as two thirds. Data consistency and quality are top priorities for modern organizations. We are building for this moment.

To download the full 2025 Gartner Magic Quadrant for Analytics and Business Intelligence Platforms report, click here, and for more information on Looker see here.

^{2025 Gartner Magic Quadrant for Analytics and Business Intelligence Platforms - Anirudh Ganeshan, Edgar Macari, Jamie O'Brien, Kurt Schlegel, Christopher Long, June 16, 2025}

^{GARTNER is a registered trademark and service mark of Gartner, Inc. and/or its affiliates in the U.S. and internationally, and MAGIC QUADRANT is a registered trademark of Gartner, Inc. and/or its affiliates and are used herein with permission. All rights reserved.}

^{Gartner does not endorse any vendor, product or service depicted in its research publications, and does not advise technology users to select only those vendors with the highest ratings or other designation. Gartner research publications consist of the opinions of Gartner’s research organization and should not be construed as statements of fact. Gartner disclaims all warranties, expressed or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose.}

^{This graphic was published by Gartner, Inc. as part of a larger research document and should be evaluated in the context of the entire document. The Gartner document is available upon request from Google.}

How Looker’s semantic layer enables trusted AI for business intelligence

Wed, 07 May 2025 16:00:00 +0000

In the AI era, where data fuels intelligent applications and drives business decisions, demand for accurate and consistent data insights has never been higher. However, the complexity and sheer volume of data coupled with the diversity of tools and teams can lead to misunderstandings and inaccuracies. That's why trusted definitions managed by a semantic layer become indispensable. Armed with unique information about your business, with standardized references, the semantic layer provides a business-friendly and consistent interpretation of your data, so that your AI initiatives and analytical endeavors are built on a foundation of truth and can drive reliable outcomes.

Looker’s semantic layer acts as a single source of truth for business metrics and dimensions, helping to ensure that your organization and tools are leveraging consistent and well-defined terms. By doing so, the semantic layer offers a foundation for generative AI tools to interpret business logic, not simply raw data, meaning answers are accurate, thanks to critical signals that map to business language and user intent, reducing ambiguity. LookML (Looker Modeling Language) helps you create the semantic model that empowers your organization to define the structure of your data and its logic, and abstracts complexity, easily connecting your users to the information they need.

A semantic layer is particularly important in the context of gen AI. When applied directly to ungoverned data, gen AI can produce impressive, but fundamentally inaccurate and inconsistent results. It sometimes miscalculates important variables, improperly groups data, or misinterprets definitions, including when writing complex SQL. The result can be misguided strategy and missed revenue opportunities.

In any data-driven organization, trustworthy business information is non-negotiable. Our own internal testing has shown that Looker’s semantic layer reduces data errors in gen AI natural language queries by as much as two thirds. According to a recent report by Enterprise Strategy Group, ensuring data quality and consistency proved to be the top challenge for organizations’ analytics and business intelligence platform. Looker provides a single source of truth, ensuring data accuracy and delivering trusted business logic for the entire organization and all connected applications.

aside_block: <ListValue: [StructValue([('title', 'Try Google Cloud for free'), ('body', <wagtail.rich_text.RichText object at 0x7f4945151850>), ('btn_text', 'Get started for free'), ('href', 'https://console.cloud.google.com/freetrial?redirectPath=/welcome'), ('image', None)])]>

The foundation of trustworthy Gen AI

To truly trust gen AI, it needs to be anchored to a robust semantic layer, which acts as your organization's data intelligence engine, providing a centralized, governed framework that defines your core business concepts and helping to ensure a single, consistent source of truth.

The semantic layer is essential to deliver on the promise of trustworthy gen AI for BI, offering:

Trust: Reduce gen AI "hallucinations" by grounding AI responses in governed, consistently defined data.
Deep business context: AI and data agents should know your business as well as your analysts do. You can empower those agents with an understanding of your business language, metrics, and relationships to accurately interpret user queries and deliver relevant answers.
Governance: Enforce your existing data security and compliance policies within the gen AI environment, protecting sensitive information and providing auditable data access.
Organizational alignment: Deliver data consistency across your entire organization, so every user, report and AI-driven insight are using the same definitions and terms and referring to them the same way.

LookML improves accuracy and reduces large language model guesswork

The semantic layer advantage in the gen AI era

LookML, Looker’s semantic modeling language, is architected for the cloud and offers a number of critical values for fully integrating gen AI in BI:

Centralized definitions: Experts can define metrics, dimensions, and join relationships once, to be re-used across all Looker Agents, chats and users, ensuring consistent answers that get everyone on the same page.
Deterministic advanced calculations: Ideal for complex mathematical or logistical operations, Looker eliminates randomness and provides predictable and repeatable outcomes. Additionally, our dimensionalized measures capability aggregates values so you can perform operations on them as a group, letting you perform complex actions quickly and simply.
Software engineering best practices: With continuous integration and version control, Looker ensures code changes are frequently tested and tracked, keeping production applications running smoothly.
Time-based analysis: Built-in dimension groups allow for time-based and duration-based calculations.
Deeper data drills: Drill fields allow users to explore data in detail through exploration of a single data point. Data agents can tap into this capability and assist users to dive deeper into different slices of data.

With the foundation of a semantic layer, rather than asking an LLM to write SQL code against raw tables with ambiguous field names (e.g., order.sales_sku_price_US), the LLM is empowered to do what it excels at: searching through clearly defined business objects within LookML (e.g., Orders > Total Revenue). These objects can include metadata and human-friendly descriptions (e.g., "The sum of transaction amounts or total sales price"). This is critical when business users speak in the language of business — “show me revenue” — versus the language of data — ”show me sum of sales (price), not quantity.” LookML bridges the data source and what a decision-maker cares about, so an LLM can better identify the correct fields, filters, and sorts and turn data agents into intelligent ad-hoc analysts.

LookML offers you a well-structured library catalog for your data, enabling an AI agent to find relevant information and summaries, so it can accurately answer your question. Looker then handles the task of actually retrieving that information from the right place.

The coming together of AI and BI promises intelligent, trustworthy and conversational insights. Looker's semantic layer empowers our customers to gain benefit from these innovations in all the surfaces where they engage with their data. We will continue to expand support for a wide variety of data sources, enrich agent intelligence, and add functionality to conversational analytics to make data interaction as intuitive and powerful as a conversation with your most trusted business advisor.

To gain the full benefits of Looker’s semantic layer and Conversation Analytics, get started here. To learn more about the Conversational Analytics API, see our recent update from Google Cloud Next, or sign up here for preview access.

How Conversational Analytics helps users make the most of their data

Tue, 29 Apr 2025 16:00:00 +0000

At Google Cloud Next 25, we expanded the availability of Gemini in Looker, including Conversational Analytics, to all Looker platform users, redefining how line-of-business employees can rapidly gain access to trusted data-driven insights through natural language. Due to the complexity inherent in traditional business intelligence products, which require steep learning curves or advanced SQL knowledge, many potential users who could benefit from BI tools simply don’t. But with the convergence of AI and BI, the opportunity to ask questions and chat with your data using natural language breaks down the barriers that have long stood in the way.

Conversational Analytics from Looker is designed to make BI more simple and approachable, democratizing data access, enabling users to ask data-related queries in plain, everyday language, and go beyond static dashboards that often don’t answer all potential questions. In response, users receive accurate and relevant answers derived from Looker Explores or BigQuery tables, without needing to know SQL or specific data tools.

For data analysts, this means fewer support tickets and interruptions, so they can focus on higher priority work, Business users can now take on their own data queries themselves and get answers, empowering trusted self-service by , putting the controls in the hands of users who need the answers most. Now, instead of struggling with field names and date formats, users can simply ask questions like: "What were our top-performing products last quarter?" or say "Show me the trend of website traffic over the past six months." Additionally, when using Conversational Analytics with Looker Explores, users can be sure tables are consistently joined and metrics are calculated the same way every time.

With Conversational Analytics, ask questions of your data and get AI-driven insights.

Conversational Analytics in Looker is designed to be simple, helpful, and easy to use, offering:

Trusted, consistent results: Conversational Analytics only uses fields defined by your data experts in LookML. Once the fields are selected, they are deterministically translated to SQL by Looker, the same way every time.
Transparency with "How was this calculated?": This feature provides a clear, natural language explanation of the underlying query that generated the results, presented in easy-to-understand bullet points.
A deeper dive with follow-up questions: Just like a natural conversation, users can ask follow-up questions to explore the data further. For example, users can ask to filter a result to a specific region, to change the timeframe of the date filter, or to switch from bar graph to an area chart. Conversational Analytics allows for seamless iteration and deeper exploration of the data.
Hidden insights with Gemini: Once the initial query results are displayed, users can click the "Insights" button to ask Gemini to analyze the data results and generate additional insights about patterns and trends they might have otherwise missed.

aside_block: <ListValue: [StructValue([('title', 'Try Google Cloud for free'), ('body', <wagtail.rich_text.RichText object at 0x7f4941e6a610>), ('btn_text', 'Get started for free'), ('href', 'https://console.cloud.google.com/freetrial?redirectPath=/welcome'), ('image', None)])]>

Empowering data analysts and developers

With the release of Conversational Analytics, our goal is for it to benefit data analysts and developers on top of line-of–business teams. The Conversational Analytics agent lets data analysts provide crucial context and instructions to Gemini, enhancing its ability to answer business user questions effectively, and empowering analysts to map business jargon to specific fields, specify the best fields for filtering, and define custom calculations.

Analysts can further curate the experience by creating agents for specific use cases. When business users select an agent, they can feel confident that they are interacting with the right data source.

As announced at Next 25, the Conversational Analytics API will power Conversational Analytics across multiple first-party Google Cloud experiences and third-party products, including customer applications, chat apps, Agentspace, and BigQuery, bringing the benefits of natural language queries to your data to the applications where you work every day. Later this year we'll also bring Conversational Analytics into Looker Dashboards, allowing users to chat with their data in that familiar interface, whether inside Looker or embedded in other applications.Also, if you’re interested in solving even more complex problems while chatting with your data, you can try our new Code Interpreter (available in preview), which uses Python rather than SQL to perform advanced analysis like cohort analysis and forecasting. With the Conversational Analytics Code Interpreter, you can tackle data science tasks without learning advanced coding or statistical methods. Sign up for access here.

Expanding the reach of AI for BI

Looker Conversational Analytics is a step forward in making BI accessible to a wider audience. By removing the technical barriers and providing an intuitive, conversational interface, Looker is empowering more business users to leverage data in their daily routines. With Conversational Analytics available directly in Looker, organizations can now make data-driven insights a reality for everyone. Start using Conversational Analytics today in your Looker instance.

AI and BI converge: A deep dive into Gemini in Looker

Tue, 15 Apr 2025 16:30:00 +0000

Driven by generative AI innovations, the Business Intelligence (BI) landscape is undergoing significant transformation, as businesses look to bring data insights to their organization in new and intuitive ways, lowering traditional barriers that have often kept discoveries out of the hands of the broader organization.

We’re spearheading this trend with Gemini in Looker, which builds upon Looker’s history as a cloud-first BI tool underpinned by a semantic layer that aligns data and that changes how users interact with it: with intelligent, AI-powered BI powered by Google’s latest AI models. The convergence of AI and BI stands to democratize data insights across organizations, moving beyond traditional methods to make data exploration more intuitive and accessible.

Gemini in Looker lowers technical barriers to accessing information, enhancing collaboration, and accelerating the process of turning raw data into actionable insights. As we announced at Google Cloud Next 25, we are expanding access to Gemini in Looker, making it now available to all Looker platform users. In this post, we discuss its key features, underlying architecture, and its transformative potential for both data analysts and business users.

aside_block: <ListValue: [StructValue([('title', '$300 in free credit to try Google Cloud data analytics'), ('body', <wagtail.rich_text.RichText object at 0x7f4923392460>), ('btn_text', 'Start building for free'), ('href', 'http://console.cloud.google.com/freetrial?redirectPath=/bigquery/'), ('image', None)])]>

Using AI to enhance productivity and efficiency

We designed Gemini in Looker with a clear objective: to improve productivity for analysts and business users with AI. Gemini in Looker makes it easier to prepare data and semantic models for BI, and simplifies building dashboard visualizations and reports. Additionally, Gemini in Looker can help business users’ efficiency by improving their data literacy and fluency, enabling them to tell data stories in their presentations, and use natural language to go beyond the dashboard to get answers to their questions. The result is analysts can do their jobs faster and business users can tell data stories and get answers.

Gemini in Looker does this through a suite of gen-AI-powered capabilities that make analytics tasks and workflows easier:

Looker Conversational Analytics allows users to ask questions about their data in natural language, gaining instant, highly visual answers powered by AI and grounded in Looker's semantic model. Data exploration is now as simple as chatting with your team’s data expert.

Talk to your data the same way you talk to your data analyst, only faster.

Automatic Slide Generation exports Looker reports to Google Slides, as well as AI-generated summaries of charts and their key insights, to automate creating presentations. With Automatic Slide Generation, presentations stay current and relevant, as the slides are directly connected to the underlying reports, so that the data they present is always up-to-date.

Rapidly transform your reports into live presentations you can share.

Formula Assistant simplifies the creation of calculated fields for ad-hoc analysis by allowing analysts to describe the desired calculation in natural language. The formula is automatically generated using AI, saving time and effort for analysts and report builders.

LookML Assistant simplifies LookML code creation by letting users describe what they are looking to build in natural language and automatically creating the corresponding LookML measures and dimensions. This helps streamline the process of creating and maintaining governed data.
Advanced Visualization Assistant creates customized data visualizations that users describe with natural language, while. Gemini in Looker creates the necessary JSON code configurations.

The semantic layer: The foundation of AI accuracy

A critical component of Looker's AI architecture is the LookML semantic modeling layer, which in conjunction with LLMs like Gemini, provides the necessary context for the LLM to comprehend the data, and helps ensure centralized metric definitions, preventing inconsistencies that can derail AI models. Without a semantic layer, AI answers may be inaccurate, leading to unreliable results, lack of adoption, and wasted effort. Looker’s semantic model enables data governance integration, maintaining compliance and trust with existing controls, and evolves with your business, iteratively updating data sets and measures so that AI answers are accurate. According to our own internal tests, Looker’s semantic layer reduces data errors in gen AI natural language queries by as much as two thirds.

How Google protects your data and privacy

You can use Gemini in Looker knowing that your data is protected. Gemini prioritizes data privacy, and does not store customer prompts and outputs without permission. Critically, customer data, including prompts and generated output, is never used to train Google's generative AI models.

Looker's agentic AI architecture powers intelligent BI

Announced at Next 25, the Looker Conversational Analytics API serves as the agentic backend for Looker AI. It answers questions using a reasoning agent that uses multiple tools to answer analytical questions. It also uses conversation history to answer multi-turn questions and enable more efficient Looker queries, including the ability to open them in the Explore UI.

Looker's AI architecture is designed for accuracy and quality, taking a multi-pronged approach to gen AI quality:

Agentic reasoning
A semantic layer foundation
A dynamic knowledge graph that provides context for Retrieval Augmented Generation (RAG)
Fine-tuned models for SQL and Python generation

This robust architecture enables Looker to move beyond simply answering "What?" questions to addressing more complex queries like "How does this compare?" "Why?" "What will happen?" and ultimately, "What should we do?"

Looker’s AI and BI roadmap

With Looker, we’re committed to converging AI and BI, and are working on a number of new offerings including:

Code Interpreter for Conversational Analytics makes advanced analytics easy, enabling business users to perform complex tasks like forecasting and anomaly detection using natural language, without needing in-depth Python expertise. You can learn more about this new capability and sign up here for the Preview.
The Conversational Analytics API lets developers integrate Conversational Analytics across multiple experiences, including customer applications, chat apps, Agentspace, and BigQuery. Sign up here for preview access to the Conversational Analytics API.
Centralize and share your Looker agents with Agentspace, which offers centralized access, faster deployment, enhanced team collaboration, and secure governance.
Automated semantic model generation with Gemini helps democratize LookML creation, boost developer productivity, and unlock data insights with multi-modal inputs. Gemini leverages diverse input types like natural language descriptions, SQL queries, and database schemas.

Embracing BI’s AI-powered future

Gemini in Looker is a significant milestone in the AI/BI revolution. By integrating the power of Google's Gemini models with Looker’s robust data modeling and analytics capabilities, organizations can empower their analysts, enhance the productivity of their business users, and unlock deeper, more actionable insights from their data. Gemini in Looker is transforming how we understand and leverage data to make smarter, more informed decisions. The journey from asking "What?" to confidently determining "What next?" is now within reach, powered by Gemini in Looker. Learn more at https://cloud.google.com/looker, or click here to learn more about Gemini in Looker and how to enable it for your Looker deployment. You can also choose to enable Trusted Tester features to gain access to early features in development.

Looker adds AI-fueled visual, conversational data exploration, continuous integration

Thu, 10 Apr 2025 16:00:00 +0000

Today at Google Cloud Next ‘25, we're announcing a major step in making Looker the most powerful platform for data analysis and exploration,by enhancing it with powerful AI capabilities and a new reporting experience, all built on our trusted semantic model — the foundation for accurate, reliable insights in the AI era.

Starting today, all platform users can now leverage conversational analytics to analyze their data using natural language and Google's latest Gemini models. We're also debuting a brand-new reporting experience within Looker, designed for enhanced data storytelling and streamlined exploration. Both innovations are now available to all Looker-hosted customers.

Modern organizations require more than just accurate insights; they need AI to uncover hidden patterns, predict trends, and drive intelligent action. Gemini in Looker and the introduction of Looker reports makes business intelligence simpler and more accessible for everyone. This empowers users across the organization, reduces the burden on data teams, and frees analysts to focus on higher-impact work.

With Conversational Analytics, ask questions of your data and get AI-driven insights.

Looker's unique foundation is its semantic layer, which ensures everyone works from a single source of truth. Combined with Google's AI, Looker now delivers intelligent insights and automates analysis, accelerating data-driven decisions across your organization.

aside_block: <ListValue: [StructValue([('title', '$300 in free credit to try Google Cloud data analytics'), ('body', <wagtail.rich_text.RichText object at 0x7f49439b9820>), ('btn_text', 'Start building for free'), ('href', 'http://console.cloud.google.com/freetrial?redirectPath=/bigquery/'), ('image', None)])]>

Gemini in Looker now available to all platform users

At Google Cloud Next ’24, we introduced Gemini in Looker to bring intelligent AI-powered BI to everyone, featuring a suite of capabilities, or assistants, that let users ask questions of their data in natural language and simplify tasks and workflows like data modeling, and chart and presentation generation.

Since then, we’ve brought those features to life in preview, and we are now expanding their access to all platform users, given the product’s level of maturity and accuracy. These include Conversational Analytics, for gaining insights into your data through natural language queries; Visualization Assistant for custom visuals initiated by natural language, letting you easily configure charts and visualizations for dashboard creation; Formula Assistant for powerful on-the-fly calculated fields and instant ad-hoc analysis; Automated Slide Generation for impactful presentations with insightful and instant text summaries of your data; and LookML Code Assistant to simplify code creation, including guidance and suggestions to create dimensions, groups, measures and more.

Also available in preview is our Code Interpreter for Conversational Analytics, which enables business users to perform complex tasks and derive advanced analytics, including forecasting and anomaly detection using natural language without needing deep Python expertise. You can learn more about this new capability and sign up here.

With Automated Slide Generation, you can create colorful and informative slides from Looker reports

Conversational Analytics API

To bring the power of conversational analytics beyond the Looker interface, we are introducing the Conversational Analytics API. Developers can now embed natural language query capabilities directly into custom applications, internal tools, or workflows, backed by trusted data access and scalable, reliable data modeling that can adapt to evolving needs.

This API allows you to build custom BI agent experiences, leveraging Looker's trusted semantic model for accuracy and Google's advanced AI models (including NL2SQL, RAG, and VizGen). Developers can embed this functionality easily to create intuitive data experiences, enable complex analysis via natural language, and even share insights generated from these conversations within the Looker platform.(Sign up here for preview access to the Conversational Analytics API.)

Introducing Looker reports

Self-service analysis is key to empowering line-of-business users and fostering collaboration. Building on the success and user-friendliness of Looker Studio, we're bringing its powerful visualization and reporting capabilities directly into the core Looker platform with the introduction of Looker reports.

Looker reports are now available with Studio in Looker unification

Looker reports bring enhanced data storytelling, streamlined exploration, and broader data connectivity to users, including reports generated from native Looker content, direct connections to Microsoft Excel and Google Sheets data, first-party connectors and ad-hoc access to various data sources.

Creating compelling, interactive reports is now easier than ever. Looker reports features the intuitive drag-and-drop interface users love, granular design controls, a rich library of visualizations and templates, and real-time collaboration capabilities.

This new reporting environment lives alongside your existing Looker Dashboards and Explores within Looker's governed framework. Importantly, Looker Reports seamlessly integrates with Gemini in Looker, allowing you to leverage conversational analytics within this new reporting experience.

Faster, more reliable development with continuous integration

With Google Cloud’s acquisition of Spectacles.dev, we are enabling developers to automate testing and validation of SQL, LookML changes, leading to faster, more reliable development cycles. Robust CI/CD practices build data trust by ensuring the accuracy and consistency of your semantic model — crucial for dependable AI-powered BI.

Continuous integration in Looker lets developers build and test faster than ever.

These advancements – the expanded availability of Gemini in Looker, the new Conversational Analytics API, the introduction of Looker reports, and native Continuous Integration capabilities – represent a major leap forward in delivering a complete AI-for-BI platform. We're making it easier than ever to access trusted insights, leverage powerful AI, and foster a truly data-driven culture.

Join us at Google Cloud Next and be sure to watch our What’s new in Looker: AI for BI session on demand after the event to experience the future of BI with Looker, and discover how complete AI for BI can transform your data into a strategic advantage.

Looker now available in the AWS Marketplace, bringing AI for BI to multi-cloud environments

Mon, 16 Dec 2024 18:00:00 +0000

Looker, Google Cloud’s complete AI for BI platform, is now available on the AWS Marketplace, allowing AWS customers to benefit from Looker’s powerful analytics and reporting capabilities in their environment. As the next step in Looker’s commitment to an open multicloud strategy, this milestone simplifies procurement for businesses that use AWS cloud and databases such as Amazon Redshift, empowering them to quickly and easily integrate Looker’s rich AI-driven visualizations and insights into their existing infrastructure.

Today’s businesses leverage data as a competitive advantage — all the more so with the accelerating adoption of generative AI. To unlock the full potential of your data, you need a business intelligence platform that’s:

Built for self-service, so all employees can access and benefit from data
Delivers instantaneous AI-powered insights to any part of the organization
Backed by a semantic layer, helping ensure that decisions are based on the foundational truth underpinning your business

aside_block: <ListValue: [StructValue([('title', '$300 in free credit to try Google Cloud data analytics'), ('body', <wagtail.rich_text.RichText object at 0x7f494592b2b0>), ('btn_text', 'Start building for free'), ('href', 'http://console.cloud.google.com/freetrial?redirectPath=/bigquery/'), ('image', None)])]>

Looker is the engine that enables organizations to imagine new AI-powered capabilities and showcase their data insights in a highly visual and easily understandable way. With Gemini in Looker, including Conversational Analytics, you can have a natural language conversation with your data, and produce rich data visualizations with Studio in Looker. This complete AI-for-BI solution lets teams connect to multiple diverse data sources and create a unified view of their information, uncovering trends and embedding analytic-driven decision-making in applications and throughout the enterprise.

Your employees rely on the data and tools they use every day to be accurate and work as anticipated. With this update, Looker brings its pioneering semantic layer to AWS environments, delivering consistent, governed and trusted data definitions to the organization. This allows AI models to work against high-quality data, ensuring its insights are accurate and trustworthy.

Looker on the AWS Marketplace delivers:

Multicloud flexibility: Looker lets organizations leverage powerful AI-for-BI capabilities across multiple clouds, including AWS, helping them gain insights within their preferred environment, avoid vendor lock-in, and easily adapt to evolving cloud strategies as needs change.
Simplified procurement: You can streamline procurement and consolidate billing, maximizing AWS investments by purchasing Looker directly through the AWS Marketplace. This simplifies cloud investments so you can increase the value of your AWS environment.
Universal semantic layer for trustworthy data: Looker for the AWS Marketplace customers can now build a reliable, consistent foundation for AI-driven insights. Standardizing data definitions and governance across platforms minimizes data silos and enhances data accessibility, helping organizations to make smarter, accurate, data-driven decisions.
Access to Google AI-powered BI on AWS: Harness the power of Google Cloud's advanced AI capabilities within your existing AWS environment, including powerful machine learning, predictive analytics, and AI-driven insights including through natural language interactions driven by Conversational Analytics.

Looker is the BI engine for your AI-driven future. To experience the power of this multi-cloud BI solution, start with Looker on AWS Marketplace today, or learn more about Looker at cloud.google.com/looker.

Business Intelligence

Data Studio returns as new home for Data Cloud assets

Extending our vision for analytics in the AI era

Two flavors: Data Studio and Data Studio Pro

Introducing Looker self-service Explores for faster ad-hoc analysis

Key capabilities to power your analysis

Exploration through conversation, with red-tape free governance

Conversational Analytics now available for Looker Embedded environments

Leading the shift to composable and agentic BI

Conversational Analytics generally available for embedded users

Conversational Analytics now available from the Looker API

Data exploration is a conversation away

What’s new with Google Data Cloud

March 23 - March 27

March 16 - March 20

February 23 - February 27

February 16 - February 20

February 2 - February 6

January 26 - January 30

January 19 - January 23

January 12 - January 16

What’s new with Google Data Cloud - 2025

New in Looker: self-service Explores, tabbed dashboards, and custom themes

Analyze ad-hoc data with Looker self-service Explores

Deliver clearer, cohesive data stories with tabbed dashboards

Apply custom styling to dashboards

Get started

How to connect Looker to Gemini Enterprise in minutes, with MCP Toolbox and ADK

Step 1 - Set up Looker Integration in MCP Toolbox

Deploy Toolbox to Cloud Run

Step 2: Deploy ADK Agent to Agent Engine

Creating your first Agent Application

Step 3: Connect to Gemini Enterprise

Querying business data made easier

Looker and Looker Conversational Analytics extensions available in the Gemini CLI

Getting started

Dive deeper

Talk with and trust your data using Looker’s Conversational Analytics, now GA

Built on a trusted, governed foundation

Empower the BI analyst and business user

Get ready to start talking

Chat with your data from anywhere: Announcing Google’s Conversational Analytics API

Getting to know the Conversational Analytics API

An agentic architecture powered by Google AI

Context retrieval and generation

Low maintenance burden

API powered chats from anywhere

Looker debuts MCP Server to broaden AI developer access to data

Intelligent AI apps, meet intelligent data

Get started with Looker MCP Server

Announcing AI-first Colab notebook experience for Google Cloud

Simplify workflows with Data Science Agent

Multi-cell code generation for anything you want to do with data

Easy visualizations

Explaining and fixing errors

Fast and intelligent code completion

Get started today

How to tap into natural language AI services using the Conversational Analytics API

Conversational Analytics API’s intelligent toolkit

Context retrieval: The key to unlocking relevant answers

NL2Query engine: Turning questions into queries

Python code interpreter: Unleash advanced analytics

Intelligent visualization engine for data stories that pop

Start having intelligent conversations with your data

Chat with confidence: Unpacking security in Looker Conversational Analytics

Prioritizing privacy in Gemini

Enhancing trust and security in Conversational Analytics

Innovate with confidence

Looker developers gain speed and accuracy with debut of Continuous Integration

Manage Continuous Integration directly within Looker

Google is a Leader in the 2025 Gartner® Magic Quadrant™ for Analytics and Business Intelligence Platforms

The generative AI revolution in BI

Google-easy data storytelling with Looker reports

Empowering developers and embedded experiences

Bringing trust to every gen-AI-powered business

How Looker’s semantic layer enables trusted AI for business intelligence

The foundation of trustworthy Gen AI

The semantic layer advantage in the gen AI era

How Conversational Analytics helps users make the most of their data

Empowering data analysts and developers