The OceanBase MCP Server enables secure interaction with OceanBase databases for AI assistants, providing structured database exploration and analysis. You can:
List available OceanBase tables - Retrieve a list of tables in the database
Read table contents - Access and view data within specific tables
Execute SQL queries - Perform SQL queries with proper error handling
Secure database access - Use environment variables for secure authentication and connection
Comprehensive logging - Monitor and log database operations for auditing and security
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@OceanBase MCP Server show me the top 10 customers by total orders"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that enables secure interaction with OceanBase databases. This server allows AI assistants to list tables, read data, and execute SQL queries through a controlled interface, making database exploration and analysis safer and more structured.
List available OceanBase tables as resources
Read table contents
Execute SQL queries with proper error handling
Secure database access through environment variables
Comprehensive logging
Related MCP server: Microsoft SQL Server MCP Server
pip install oceanbase-mcp-serverSet the following environment variables:
OB_HOST=localhost # Database host
OB_PORT=2881 # Optional: Database port (defaults to 2881 if not specified)
OB_USER=your_username
OB_PASSWORD=your_password
OB_DATABASE=your_databaseAdd this to your claude_desktop_config.json:
{
"mcpServers": {
"oceanbase": {
"command": "uv",
"args": [
"--directory",
"path/to/oceanbase_mcp_server",
"run",
"oceanbase_mcp_server"
],
"env": {
"OB_HOST": "localhost",
"OB_PORT": "2881",
"OB_USER": "your_username",
"OB_PASSWORD": "your_password",
"OB_DATABASE": "your_database"
}
}
}
}# Install dependencies
pip install -r requirements.txt
# Run the server
python -m oceanbase_mcp_server# Clone the repository
git clone https://github.com/yourusername/oceanbase_mcp_server.git
cd oceanbase_mcp_server
# Create virtual environment
python -m venv venv
source venv/bin/activate # or `venv\Scripts\activate` on Windows
# Install development dependencies
pip install -r requirements-dev.txt
# Run tests
pytestNever commit environment variables or credentials
Use a database user with minimal required permissions
Consider implementing query whitelisting for production use
Monitor and log all database operations
This MCP server requires database access to function. For security:
Create a dedicated OceanBase user with minimal permissions
Never use root credentials or administrative accounts
Restrict database access to only necessary operations
Enable logging for audit purposes
Regular security reviews of database access
See OceanBase Security Configuration Guide for detailed instructions on:
Creating a restricted OceanBase user
Setting appropriate permissions
Monitoring database access
Security best practices
⚠️ IMPORTANT: Always follow the principle of least privilege when configuring database access.
Apache License - see LICENSE file for details.
Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request
Execute an SQL query on the OceanBase server
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The SQL query to execute |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions execution but fails to address critical aspects like required permissions, transaction handling, error behavior, or result format. This leaves significant gaps for a tool that performs database operations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without unnecessary elaboration. It's appropriately sized and front-loaded, with zero wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a database execution tool with no annotations and no output schema, the description is insufficient. It lacks information about return values, error handling, security requirements, and operational constraints, which are critical for proper tool invocation in this context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'query' documented in the schema. The description adds no additional parameter semantics beyond what the schema already provides, so it meets the baseline for adequate but unenhanced documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('execute') and resource ('SQL query on the OceanBase server'), providing a specific verb+resource combination. However, with no sibling tools mentioned, there's no opportunity to distinguish from alternatives, which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, prerequisites, or limitations. It merely states what the tool does without context for application, leaving the agent to infer usage scenarios independently.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0execute_sqlWith only one tool, there is no possibility of ambiguity or overlap between tools. The single tool 'execute_sql' has a clear and distinct purpose that cannot be confused with any other tool in this set.
The single tool name 'execute_sql' follows a clear verb_noun pattern, and with only one tool, consistency is inherently perfect. There are no other tools to compare against, so no inconsistencies can exist.
A single tool is too few for a database server's apparent scope, which typically requires operations like querying, updating, schema management, and transaction handling. This minimal set severely limits functionality and will likely cause agent failures in complex tasks.
The tool surface is severely incomplete for a database server domain. It only provides SQL execution, missing essential operations such as listing tables, describing schemas, creating/dropping tables, managing transactions, or handling connections, leaving significant gaps that will hinder agent workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
The BigQuery remote MCP server is a fully managed service that uses the Model Context Protocol to connect AI applications and LLMs to BigQuery data sources. It provides secure, standardized tools for AI agents to list datasets and tables, retrieve schemas, generate and execute SQL queries through natural language, and analyze data—enabling direct access to enterprise analytics data without requiring manual SQL coding.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
The Grafbase MCP server sits in front of a GraphQL API and exposes an MCP protocol-compliant interface that allows AI agents and LLMs to explore and query GraphQL APIs using natural language. It provides tools to search schemas, introspect types and fields, and execute GraphQL queries while minimizing context bloat by returning only relevant schema subsets, with built-in support for authentication, authorization, and configurable access control.
The HubSpot MCP Server acts as a bridge that enables AI assistants and Large Language Models to securely interact with HubSpot CRM data through natural conversation, without requiring users to understand complex API structures. It provides read-only access to standard CRM objects (contacts, companies, deals, tickets, products, invoices, and more) and their associations, secured via OAuth 2.0, allowing AI agents to perform tasks like summarizing deals, fetching company updates, and looking up record changes.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/yuanoOo/oceanbase_mcp_server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
