Your Three Paths to Using AI With Dremio

Dremio offers three distinct integration points to the data in your lakehouse. This gives users the freedom to pick the interface, models, and tools that are right for them. Whether you're a business user, a seasoned data analyst, or a developer, we have an integration that will suit how you like to work.

The built-in AI Agent serves teams who want AI access without any configuration. The hosted MCP server connects the AI tools you're already using, like Claude or ChatGPT, directly to your Dremio data. And the newly launched Dremio developer CLI gives agents and engineers a structured, self-describing interface for autonomous execution. Each one solves a real problem for a different persona.

Read on to learn how each mode works, what it's best for, and which to choose if you're unsure.

The Built-in AI Agent: AI Access for Everyone, Right Inside Dremio Cloud

The easiest way to understand Dremio's built-in AI Agent is to think of it as a conversational interface that already knows your data. It sits inside Dremio Cloud, it's connected to your lakehouse catalog, and it understands the business context defined in your semantic layer. No installation required and no connection to configure. You ask a question in plain English and get an answer.

Underneath, the Agent translates your natural language question into a SQL query, runs it against your Dremio data, and returns a result. If you've defined what "active customer" means in the semantic layer, the Agent uses that definition rather than guessing. If your access controls say a particular user can't see salary data, the Agent respects that at query time through the Open Catalog's governance policies. Every question, generated query, and returned result is fully logged for compliance and monitoring.

The built-in Agent can do more than answer questions, though. It can search your catalog with natural language to find the right datasets before you even ask an analytical question, which is a game-changer for anyone inheriting a complex Dremio environment with hundreds of views. It can explain and optimise SQL statements, which makes it a useful tool for analysts who write queries but don't always understand why a particular one is slow. It can generate visualisations from query results, turning data into charts without any BI tool setup. And through Dremio's AI functions, it can query unstructured data: classify images, extract structured fields from PDFs, to answer questions that span document repositories and database tables in the same response.

You can configure which underlying model powers the Agent at the organisation level, choosing from Anthropic, OpenAI, or Google. Dremio's default model is included in your DCU costs. If you configure your own model, the inference charges go to your model provider rather than appearing in your Dremio bill. Either way, the governance framework, the semantic context, and the catalog integration are the same.

Who this is for: Business analysts, data practitioners, and anyone who needs answers from the lakehouse without writing SQL or configuring anything. Also valuable for technical users who want a fast interface for data discovery and query debugging alongside their normal Dremio workflows.

Concrete example: A marketing analyst wants to understand which customer segments drove the most revenue in Q1. They type the question into the Agent interface, which finds the right views, applies the semantic layer's definition of "revenue," filters to Q1, respects their row-level access permissions, and returns a table and a bar chart. The whole thing takes under a minute and the analyst never opens the SQL editor.

MCP: Connect the AI Tools You Already Use to Your Dremio Data

Not every team wants to run their AI workflows inside Dremio Cloud's interface. Many organisations have already standardised on an AI tool, whether that's Claude, ChatGPT, Gemini, or a custom-built agent. They don't want to switch interfaces; they want to extend the tools they already use with access to their enterprise data.

That's what Dremio's MCP integration is for. MCP (Model Context Protocol), developed by Anthropic and now supported across much of the AI ecosystem, is an open standard for how AI agents discover and call external tools. Think of it as the equivalent of a REST API standard, but designed specifically for AI agents rather than HTTP clients. Instead of every integration being a custom build, MCP gives agents a common way to find out what capabilities a system exposes and how to call them.

Dremio hosts an MCP server in Dremio Cloud, so you don't have to run your own. Connecting an MCP-enabled AI tool to your Dremio environment is a configuration step, not a full-blown engineering project. Once connected, the agent can call tools that Dremio exposes through the server: 

• RunSqlQuery to execute SQL directly against your cluster, 
• GetSchemaOfTable to retrieve schema information, column descriptions, and tags,
• RunSemanticSearch to let the agent explore your lakehouse metadata using natural language.

From the agent's perspective, Dremio becomes another capability it can reason over and call. The agent breaks down a user's question, decides it needs to look up a schema, calls GetSchemaOfTable, constructs a query, calls RunSqlQuery, gets the result, and incorporates it into its response. The user interacts with Claude or ChatGPT as usual; they just get answers that reference real, current data from the lakehouse rather than whatever the model was trained on. Governance still applies: the agent connects under a specific user's credentials, and all access controls configured in Open Catalog are enforced for every query the agent generates.

One-click integrations with Claude Desktop make the initial setup particularly fast for teams already in Anthropic's ecosystem. Gemini and ChatGPT can connect via the same MCP server with slightly more configuration, as can any custom agent that uses the MCP protocol.

Who this is for: AI and ML teams that have built workflows around a specific model and want to extend those workflows to query enterprise data. Data teams that want colleagues to use Claude or ChatGPT as their data interface without those users needing Dremio Cloud access. Organisations that have standardised on a particular AI vendor and don't want to maintain multiple AI interfaces.

Concrete example: An ML team at a financial services firm has built an internal agent using Claude that handles various research queries. They want it to pull live portfolio performance data from Dremio without a separate API integration. They connect Claude to Dremio via the MCP server, and the agent can now call RunSqlQuery against Dremio's federated data as part of its reasoning chain. The semantic layer tells the agent exactly what "portfolio return" means, governance controls ensure it only sees the accounts it's authorised for, and no-one had to write a custom data connector.

The Developer CLI: Autonomous Execution Without a Human in the Loop

MCP is a great fit when a person is in the conversation, approving actions and reading responses. The trust model is supervised: the agent proposes, the human decides. But not every AI workflow has a human watching. Pipelines run overnight. Cron jobs fire on schedule. Agents execute queries in parallel without anyone reviewing each step.

That's the gap the Dremio developer CLI fills. It's a purpose-built command-line tool for Dremio Cloud, designed from the ground up to be operated by AI agents just as comfortably as by engineers. Install it with pip install dremio-cli or uv tool install dremio-cli, point it at your Dremio project with a personal access token, and it's ready to use from any script, pipeline, or agent session.

The architecture detail that makes it genuinely agent-friendly is dremio describe. Run dremio describe query.run and the CLI returns a full JSON schema for that command: parameter names, types, required or optional status, enum values, and the underlying API endpoints. An agent doesn't need to read documentation or parse help text. It introspects the CLI at runtime, gets a machine-readable contract, and constructs valid commands from the schema alone. This is what Dremio's CTO calls Context Engineering applied to tooling: giving the agent the right information at the right moment, rather than hoping it learned the API from training data.

The --fields flag extends this efficiency to output. Instead of dumping a full job profile into the agent's context window, --fields job_id,job_state returns only what the agent needs. Across a long session with dozens of calls, that difference in output verbosity adds up. Every command defaults to structured JSON, so the agent can parse results without any text extraction.

The CLI covers 50+ operations across 13 command groups: queries, schema inspection, catalog browsing, reflection management, job monitoring, engine control, users, roles, grants, projects, wikis, tags, and full-text search. Input validation is built-in throughout. Catalog paths are checked for traversal attacks, SQL-interpolated values are validated before they reach the API, and all errors return a consistent JSON format rather than raw HTTP tracebacks. When an agent is constructing commands programmatically, this consistency really matters.

Who this is for: Data engineers and developers building automated pipelines that need Dremio access without a web UI. Teams running scheduled agent workflows, overnight data quality checks, or any process where the agent operates without a human approving each action. Developers who want to script against Dremio from their terminal or build Dremio operations into larger automation frameworks.

Concrete example: A sales team has a target accounts spreadsheet. They open Claude and ask it to upload the file and cross-reference it against their customer360 table in Dremio to identify which prospects are already customers and at what tier. Claude uses the CLI to introspect the target table's schema, uploads the spreadsheet, constructs the join SQL, runs the query, and returns a formatted answer. The user never opened the Dremio console. Claude never had to read API documentation. The dremio describe command gave it everything it needed to construct valid operations from scratch, and the structured JSON output at each step gave it clean data to reason over.

What Makes All Three Work: The Semantic Layer, Governed Access, and Reflections

The three modes look different from the outside, but they share the same foundation. Every AI interaction with Dremio, whether through the built-in Agent, the hosted MCP server, or the developer CLI, benefits from the AI Semantic Layer and the governance framework in Open Catalog.

The semantic layer is what prevents AI agents from hallucinating or producing inconsistent answers. When an agent asks Dremio about "monthly recurring revenue," it gets the definition that the business has agreed on, not a guess based on whatever columns happen to have "revenue" in their names. Metrics, dimensions, joins, and business labels are defined once and applied consistently across every query, regardless of which AI surface submitted it.

Open Catalog ensures that governed access applies at query time, not just at login time. Row and column policies are evaluated on every query the agent generates, which means an AI agent cannot circumvent access controls by generating a clever SQL query. Users only see what they're authorised to see, and that applies to the AI acting on their behalf as well.

Reflections keep performance from degrading as AI query volume grows. An agent that fires dozens of analytical queries in the course of answering a single question needs the same sub-second response times that a BI dashboard requires. Dremio's query acceleration layer handles that without any per-query configuration.

If you want to see how agentic analytics works against your own data, a free Dremio Cloud environment at dremio.com/get-started gives you access to the built-in AI Agent from day one, with the MCP server and developer CLI available to extend further once you're ready to connect external tools or build autonomous pipelines.