MCP and Apache Iceberg

Model Context Protocol (MCP) and Apache Iceberg

The Model Context Protocol (MCP) is an open standard (originally introduced by Anthropic) that defines a uniform interface for connecting AI agents and LLMs to external tools and data sources. MCP servers expose capabilities as “tools” that LLMs can call natively — enabling AI agents to interact with APIs, databases, file systems, and data platforms without custom integration code for each model.

Apache Iceberg + MCP is a powerful combination: an MCP server for Iceberg exposes lakehouse catalog discovery, table schema inspection, and SQL query execution as LLM-callable tools. This gives any MCP-compatible AI agent (Claude, GPT-4o, Gemini, Llama, and others) direct access to governed Iceberg lakehouse data.

Why MCP + Iceberg Matters

The traditional AI-to-data integration pattern requires custom code for every model and every data source. MCP standardizes this:

• Any MCP-compatible LLM can call Iceberg tools without model-specific integration code.
• Tool definitions (schemas, descriptions) guide the LLM on when and how to call each Iceberg capability.
• Governed access: The MCP server authenticates with the Iceberg catalog (via the REST API) and enforces access control before returning data.

Core Iceberg MCP Tools

A well-designed Iceberg MCP server exposes tools such as:

list_namespaces

Lists all available namespaces (databases/schemas) in the catalog. The LLM uses this to discover what data domains are available.

list_tables

Lists all tables within a namespace. Returns table names and optional descriptions.

describe_table

Returns the full schema of a table: column names, data types, descriptions, and partition spec. The LLM uses this to understand what data is available and how to query it correctly.

query_iceberg

Executes a SQL query against the Iceberg catalog and returns results. This is the primary data access tool.

get_table_snapshots

Returns the snapshot history for a table — enabling the LLM to implement time travel queries or understand when data was last updated.

get_recent_rows

Returns a sample of recent rows from a table — useful for the LLM to understand data formats and values before writing a complex query.

Example MCP Server (Python / PyIceberg)

from mcp.server import Server
from mcp.types import Tool, TextContent
from pyiceberg.catalog import load_catalog
import json

app = Server("iceberg-mcp")
catalog = load_catalog("my_catalog", **{
    "type": "rest",
    "uri": "https://my-catalog.example.com",
    "credential": "client-id:client-secret",
})

@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="list_tables",
            description="List all Iceberg tables in a namespace",
            inputSchema={
                "type": "object",
                "properties": {
                    "namespace": {"type": "string", "description": "Database/namespace name"}
                },
                "required": ["namespace"]
            }
        ),
        Tool(
            name="describe_table",
            description="Get the schema and properties of an Iceberg table",
            inputSchema={
                "type": "object",
                "properties": {
                    "namespace": {"type": "string"},
                    "table": {"type": "string"}
                },
                "required": ["namespace", "table"]
            }
        ),
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "list_tables":
        tables = catalog.list_tables(arguments["namespace"])
        return [TextContent(type="text", text=json.dumps([str(t) for t in tables]))]

    elif name == "describe_table":
        table = catalog.load_table(f"{arguments['namespace']}.{arguments['table']}")
        schema_str = str(table.schema())
        return [TextContent(type="text", text=schema_str)]

MCP + Dremio: The Agentic Lakehouse Pattern

Dremio’s Agentic Lakehouse is designed to serve as the data backend for AI agent workflows. Dremio’s AI Semantic Layer (virtual datasets, column descriptions, pre-defined metrics) provides the context that MCP tools return to LLMs — making AI-generated queries more accurate and trustworthy.

A Dremio MCP server pattern:

1. LLM calls list_namespaces → Dremio returns available business domains.
2. LLM calls describe_table with a selected table → Dremio returns schema + semantic descriptions.
3. LLM generates SQL grounded in the semantic context.
4. LLM calls query_iceberg → Dremio executes against Iceberg, returns results.
5. LLM synthesizes a natural-language answer.

MCP Clients and Compatibility

MCP is supported by:

• Claude (Anthropic): Native MCP support in the Claude API.
• GitHub Copilot / VS Code: MCP extension support.
• LangChain / LangGraph: MCP tool wrapping.
• AutoGen (Microsoft): MCP tool integration.
• Continue.dev: Local AI assistant with MCP support.

The MCP ecosystem is rapidly expanding. Any new model or agent framework that adopts MCP can immediately leverage Iceberg MCP servers — making Iceberg data available to the entire AI tooling ecosystem without per-model integration work.

Security Considerations

Iceberg MCP servers should:

• Authenticate with the catalog using service account credentials, not user credentials.
• Scope catalog access to only the namespaces/tables the AI agent should see.
• Use the catalog’s credential vending to get object-storage-scoped access for data reads.
• Log all tool calls for audit.
• Limit query complexity (timeout, row limits) to prevent resource abuse.