MCP Connector

Explore and Govern Data Metadata

MCP server exposing Apache Gravitino's data catalog - tables, schemas, tags, models, and role management - via a curated, token-efficient tool set.

Works with gravitinofastmcp

91
Spark score
out of 100
Updated Jul 2025
Version 1.0.0
Models
universal

Add to Favorites

Why it matters

Connect to Gravitino to explore structured and unstructured data metadata. Manage data governance tasks like tagging, classification, and user role management.

Outcomes

What it gets done

01

Retrieve lists of catalogs, schemas, and tables.

02

Get detailed table and column information.

03

Associate tags with data entities.

04

Manage user roles and permissions.

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/vb-apache-gravitino-incubating | bash

Capabilities

Tools your agent gets

get_list_of_catalogs

Get list of catalogs

get_list_of_schemas

Get list of schemas

get_list_of_tables

Get paginated list of tables

get_table_by_fqn

Get detailed information about a specific table

get_table_columns_by_fqn

Get table column information

get_list_of_tags

Get all tags

associate_tag_to_entity

Attach a tag to a table or column

list_objects_by_tag

List objects associated with a specific tag

+6 tools

Overview

Apache Gravitino (incubating) MCP Server

An MCP server, built on FastMCP, that exposes a curated set of Apache Gravitino APIs for metadata operations: catalogs, schemas, tables, tags, models, and user-role management, with responses trimmed to stay within LLM token limits. Use it when an AI assistant needs to browse or govern a Gravitino-managed data catalog, look up table structure, tag and classify data, or manage roles, rather than calling Gravitino's full REST API directly.

What it does

An MCP server built on FastMCP that exposes a curated subset of Apache Gravitino's APIs for metadata operations, rather than the full API surface: catalogs, schemas, tables, tags, models, and user-role management. Each tool is deliberately scoped to return concise, relevant metadata instead of a raw API dump, so responses stay within LLM token limits while keeping the semantic meaning of the data intact.

When to use - and when NOT to

Use it when an AI assistant needs to explore or govern a Gravitino-managed data catalog - listing what catalogs, schemas, and tables exist, inspecting a specific table's columns, tagging entities for classification, checking which objects carry a given tag, or managing which users hold which roles. It is not a full Gravitino API client: the tool list is intentionally limited to a selected set of read and management operations, and any Gravitino capability outside that list is not reachable through this server. Tool exposure can also be narrowed further via GRAVITINO_ACTIVE_TOOLS, which defaults to activating everything (the wildcard value) but can be set to a specific method name, such as get_list_of_roles alone, to expose only that one tool - useful for handing an assistant read-only catalog access without also granting it role-management or tagging capabilities.

Capabilities

Table tools: get_list_of_catalogs, get_list_of_schemas, get_list_of_tables (paginated), get_table_by_fqn, get_table_columns_by_fqn. Tag tools: get_list_of_tags, associate_tag_to_entity (attach a tag to a table or column), list_objects_by_tag. User role tools: get_list_of_roles, get_list_of_users, grant_role_to_user, revoke_role_from_user. Model tools: get_list_of_models, get_list_of_model_versions_by_fqn. Authentication is either a Gravitino JWT token (GRAVITINO_JWT_TOKEN) or basic username and password (GRAVITINO_USERNAME, GRAVITINO_PASSWORD), alongside the always-required GRAVITINO_URI (the base URL of the Gravitino server) and GRAVITINO_METALAKE, which names the metalake to operate against and defaults to metalake_demo if unset.

How to install

Requires uv and Python 3.10+.

git clone git@github.com:datastrato/mcp-server-gravitino.git
cd mcp-server-gravitino
uv venv
source .venv/bin/activate
uv install

Run it with:

uv \
--directory /path/to/mcp-gravitino \
run \
--with fastmcp \
--with httpx \
--with mcp-server-gravitino \
python -m mcp_server_gravitino.server

The --with flags add fastmcp, httpx, and the local mcp-server-gravitino module to the uv-managed runtime without altering the project's own dependencies, and python -m mcp_server_gravitino.server is the actual entry point being launched. Set GRAVITINO_URI, GRAVITINO_METALAKE, and either the JWT or basic-auth environment variables before launch, as shown in the Goose client's example configuration. The project is licensed under Apache License 2.0.

Who it's for

Data engineers and platform teams running Apache Gravitino who want an AI assistant to browse catalog structure, manage tags, or handle role assignments without granting it the full Gravitino API surface.

Source README

MCP Server for Apache Gravitino

Python Version

MCP server providing Gravitino APIs - A FastMCP integration for Apache Gravitino services.

Features

  • Seamless integration with FastMCP for Gravitino APIs
  • Simplified interface for metadata interaction
  • Supports metadata operations for catalogs, schemas, tables, models, users, tags, and user-role management

Installation

This project uses uv as the dependency and virtual environment management tool. Please ensure uv is installed on your system.

  1. Clone the repository:

    git clone git@github.com:datastrato/mcp-server-gravitino.git
    
  2. Navigate into the project directory:

    cd mcp-server-gravitino
    
  3. Create a virtual environment:

    uv venv
    
  4. Activate the virtual environment:

    source .venv/bin/activate
    
  5. Install dependencies:

    uv install
    

Configuration

Common Configuration

Regardless of the Authorization, the following environment variables need to be set:

GRAVITINO_METALAKE=<YOUR_METALAKE> # default: "metalake_demo"
GRAVITINO_URI=<YOUR_GRAVITINO_URI>
  • GRAVITINO_URI: The base URL of your Gravitino server.
  • GRAVITINO_METALAKE: The name of the metakube to use.

Authorization

mcp-server-gravitino supports both token-based and basic authentication methods. These mechanisms allow secure access to MCP tools and prompts and are suitable for integration with external systems.

Token Authentication

Set the following environment variables:

GRAVITINO_JWT_TOKEN=<YOUR_GRAVITINO_JWT_TOKEN>

GRAVITINO_JWT_TOKEN: The JWT token for authentication.

Basic Authentication

Alternatively, you can use basic authentication:

GRAVITINO_USERNAME=<YOUR_GRAVITINO_USERNAME>
GRAVITINO_PASSWORD=<YOUR_GRAVITINO_PASSWORD>
  • GRAVITINO_USERNAME: The username for Gravitino authentication.
  • GRAVITINO_PASSWORD: The corresponding password.

Tool Activation

Tool activation is currently based on method names (e.g., get_list_of_table). You can specify which tools to activate by setting the optional environment variable GRAVITINO_ACTIVE_TOOLS. The default value is *, which activates all tools. If just want to activate get_list_of_roles tool, you can set the environment variable as follows:

GRAVITINO_ACTIVE_TOOLS=get_list_of_roles

Usage

To launch the Gravitino MCP Server, run the following command:

uv \
--directory /path/to/mcp-gravitino \
run \
--with fastmcp \
--with httpx \
--with mcp-server-gravitino \
python -m mcp_server_gravitino.server

The meaning of each argument is as follows:

Argument Description
uv Launches the UV CLI tool
--directory /path/to/mcp-gravitino Specifies the working project directory with pyproject.toml
run Indicates that a command will be executed in the managed environment
--with fastmcp Adds fastmcp to the runtime environment without altering project deps
--with httpx Adds httpx dependency for async HTTP functionality
--with mcp-server-gravitino Adds the local module as a runtime dependency
python -m mcp_server_gravitino.server Starts the MCP server using the package's entry module

Goose Client Example

Example configuration to run the server using Goose:

{
  "mcpServers": {
    "Gravitino": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/user/workspace/mcp-server-gravitino",
        "run",
        "--with",
        "fastmcp",
        "--with",
        "httpx",
        "--with",
        "mcp-server-gravitino",
        "python",
        "-m",
        "mcp_server_gravitino.server"
      ],
      "env": {
        "GRAVITINO_URI": "http://localhost:8090",
        "GRAVITINO_USERNAME": "admin",
        "GRAVITINO_PASSWORD": "admin",
        "GRAVITINO_METALAKE": "metalake_demo"
      }
    }
  }
}

Tool List

mcp-server-gravitino does not expose all Gravitino APIs, but provides a selected set of optimized tools:

Table Tools

  • get_list_of_catalogs: Retrieve a list of catalogs
  • get_list_of_schemas: Retrieve a list of schemas
  • get_list_of_tables: Retrieve a paginated list of tables
  • get_table_by_fqn: Fetch detailed information for a specific table
  • get_table_columns_by_fqn: Retrieve column information for a table

Tag Tools

  • get_list_of_tags: Retrieve all tags
  • associate_tag_to_entity: Attach a tag to a table or column
  • list_objects_by_tag: List objects associated with a specific tag

User Role Tools

  • get_list_of_roles: Retrieve all roles
  • get_list_of_users: Retrieve all users
  • grant_role_to_user: Assign a role to a user
  • revoke_role_from_user: Revoke a user's role

Model Tools

  • get_list_of_models: Retrieve a list of models
  • get_list_of_model_versions_by_fqn: Get versions of a model by fully qualified name

Each tool is designed to return concise and relevant metadata to stay within LLM token limits while maintaining semantic integrity.

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.