JetBrains DataGrip 2026.2: AI Agents Meet Database Management with MCP Tools and Skills

DataGrip 2026.2: When AI Agents Learned to Talk to Databases

JetBrains has shipped DataGrip 2026.2, and the headline feature changes how AI coding agents interact with databases. The update introduces three AI agent skills — database-tools, database-connection-management, and database-text-to-sql — that let agents like Claude Code, Codex, and Junie directly explore schemas, run natural-language queries, and perform schema cleanup with dependency safety checks.

This isn't a chatbot bolted onto a database client. It's a set of MCP tools and agent skills that give AI agents first-class database capabilities through the tools they already use.

The Three Agent Skills

1. database-tools

The general-purpose database skill that lets agents interact with database objects. Agents can list tables, describe schemas, run queries, and inspect database state — all through natural language or structured tool calls.

2. database-connection-management

Create, configure, and manage data source connections directly from agent context. Agents can set up connections from a text description, a JDBC URL, or by importing connections from other tools. This eliminates the manual step of configuring database access before an agent can work with data.

3. database-text-to-sql

The natural-language-to-SQL skill. Agents leverage the schema structure they've already explored to convert human requests into accurate SQL queries. This is where the real power lies: an agent that understands your schema can write queries that a generic text-to-SQL tool would get wrong.

How It Works in Practice

Connection Setup

Agents can create data sources directly from a text description. Say "connect to my PostgreSQL analytics database at analytics.internal:5432" and the agent handles the rest — setting up the connection, testing it, and making it available for queries.

Talking to Your Schema

Once connected, agents can explore the database architecture using natural language. "What tables reference the users table?" "Show me the indexes on the orders table." "What's the relationship between products and inventory?" The agent queries the database metadata and returns structured answers.

Text-to-SQL

The agent converts natural language requests into SQL. Because it has access to the actual schema — not a generic schema approximation — it generates accurate queries that respect foreign key relationships, column types, and index availability.

Schema Cleanup

This is the most operationally interesting feature. Agents can detect out-of-place tables and perform dependency safety checks before running cleanup operations. Before dropping a table or renaming a column, the agent verifies that no other objects depend on it, preventing cascading failures.

Object Mentions

DataGrip introduces two new identifiers for targeting database objects from agent context:

• @dbObject — Reference specific database objects like tables, views, or procedures
• @fileName — Reference specific files in the project

These identifiers let agents work with precise database objects rather than ambiguous natural language references.

Why This Matters for AI Coding Agents

The Database Gap in AI Coding

AI coding agents have gotten remarkably good at writing application code, but databases remain a blind spot. Without direct database access, agents must rely on:

• Static schema dumps that may be outdated
• Developer-provided context that may be incomplete
• Generic SQL knowledge that doesn't account for specific schema design

DataGrip 2026.2 closes this gap by giving agents live, read-aware access to actual database schemas.

Schema-Aware Code Generation

When an agent generates code that interacts with a database — ORM models, migration scripts, API endpoints — having access to the actual schema means:

• Accurate type mapping — Column types are read from the database, not guessed
• Correct relationship modeling — Foreign keys and join tables are detected automatically
• Migration safety — Schema changes are validated against existing dependencies before execution

The MCP Advantage

Because DataGrip exposes its database capabilities through MCP tools, any agent that supports MCP can use them. This includes Claude Code, Codex, Junie, Cursor, and any other agent that implements the Model Context Protocol. The database capabilities are available wherever the agent runs.

Dependency Safety: The Unsung Hero

The schema cleanup feature with dependency safety checks deserves special attention. In production databases, dropping a table or altering a column can have cascading consequences:

• Views that reference the table break
• Stored procedures that use the column fail
• ETL pipelines that depend on the schema produce errors
• Application code that queries the table throws exceptions

DataGrip's agent skills detect these dependencies before making changes. The agent can:

1. Scan for dependent objects — views, procedures, triggers, foreign keys
2. Report the impact — "Dropping this table will break 3 views and 2 stored procedures"
3. Suggest alternatives — rename instead of drop, deprecate instead of delete
4. Execute safely — only proceed when no dependencies are at risk

This is the kind of operational safety that separates a useful database agent from a dangerous one.

How to Get Started

DataGrip 2026.2 is available now from JetBrains. The AI agent skills work with:

• Claude Code — via MCP tools integration
• Codex — via agent skill registration
• Junie — JetBrains' own AI agent, native integration
• Any MCP-compatible agent — through the standard MCP protocol

To activate the skills, enable the AI agent features in DataGrip's settings and configure your preferred agent's MCP endpoint. The skills are bundled with the IDE — no separate installation required.

The Bigger Picture: IDEs as Agent Infrastructure

DataGrip 2026.2 is part of a broader trend: IDEs evolving from code editors into agent infrastructure platforms. JetBrains is positioning its IDEs not just as tools for human developers, but as the runtime environment where AI agents operate.

This makes sense. IDEs already have:

• Deep knowledge of project structure
• Language servers for code intelligence
• Build and test tooling
• Version control integration

Adding database access through MCP tools completes the picture. An agent running inside DataGrip can now read code, understand the project structure, query the database, and make changes — all within a single, governed environment.

The future of AI coding agents isn't standalone tools that write code in isolation. It's agents embedded in rich development environments that understand the full context of what they're building. DataGrip 2026.2 is a strong step in that direction.

Frequently Asked Questions

What are AI agent skills in DataGrip 2026.2?

AI agent skills are bundled capabilities that let coding agents interact with databases directly. The three skills are database-tools (general database interaction), database-connection-management (setting up connections), and database-text-to-sql (natural language to SQL conversion).

Which AI agents work with DataGrip's database skills?

The skills work with Claude Code, Codex, Junie, and any other agent that supports the Model Context Protocol (MCP). No special configuration is needed beyond enabling the AI agent features.

Can the agent modify my database schema?

The agent can detect schema issues and suggest cleanup operations, but it includes dependency safety checks that prevent destructive changes. It will report impacted objects before making any modifications.

How does the text-to-SQL feature differ from generic tools?

DataGrip's text-to-SQL reads the actual database schema rather than relying on generic knowledge. This means it generates accurate queries that respect foreign key relationships, column types, and index availability.

Is this available in the free Community Edition?

No. DataGrip 2026.2 with AI agent skills is available in the paid DataGrip edition. However, the MCP tools can be used with any MCP-compatible agent.