Skip to main content
Glama
TDengine Query MCP Server

TDengine Query MCP Server

TDengine Query MCP Server

License: MIT

A Model Context Protocol (MCP) server that provides read-only TDengine database queries for AI assistants. Execute queries, explore database structures, and investigate your data directly from your AI-powered tools.

Supported AI Tools

This MCP server works with any tool that supports the Model Context Protocol, including:

  • Cursor IDE: Set up in .cursor/mcp.json

  • Anthropic Claude: Use with a compatible MCP client

  • Other MCP-compatible AI assistants: Follow the tool's MCP configuration instructions

Related MCP server: MySQL Query MCP Server

Features & Limitations

What It Does

  • ✅ Execute read-only TDengine queries (SELECT, SHOW, DESCRIBE only)

  • ✅ Provide database/stable information and metadata

  • ✅ List available database and stables

What It Doesn't Do

  • ❌ Execute write operations (INSERT, UPDATE, DELETE, CREATE, ALTER, etc.)

  • ❌ Provide database design or schema generation capabilities

  • ❌ Function as a full database management tool

This tool is designed specifically for data investigation and exploration through read-only queries. It is not intended for database administration, schema management, or data modification.

How to use

Run from source code

The recommended way to use this MCP server is to run it directly with uv without installation. This is how both Claude Desktop and Cursor are configured to use it in the examples below.

If you want to clone the repository:

git clone https://github.com/Abeautifulsnow/tdengine-mcp.git
cd tdengine-mcp

Then you can run the server directly:

uv run src/tdengine_mcp_server -th 192.100.8.22 -db log -ll debug

Alternatively you can change the .env file in the src/tdengine_mcp_server/ directory to set the environment variables and run the server with the following command:

uv run src/tdengine_mcp_server

Important: the .env file will have higher priority than the command line arguments.

Install From Pypi by pip command

# Install globally with pip
pip install tdengine_mcp_server

and then run:

python -m tdengine_mcp_server -h

Install by uvx command

uvx tdengine-mcp-server -h

Install From smithery by npx command

npx -y @smithery/cli@latest install @Abeautifulsnow/tdengine-mcp --client cursor --config '"{}"'

You can change the client after the --client option with alternatives claude, 'windsurf' and so on. Also you can refer to this: smithery/tdengine-mcp-server

Configuration Options

.env file

Environment Variable

Description

Default

LOG_LEVEL

Set the log level (DEBUG, INFO, WARN, ERROR)

INFO

TDENGINE_HOST

Database host for environment

localhost

TDENGINE_PORT

Database port

6041

TDENGINE_USERNAME

Database username

root

TDENGINE_PASSWORD

Database password

taosdata

TDENGINE_DATABASE

Database name

log

TDENGINE_TIMEOUT

Set the connection timeout in seconds

30

TRANSPORT

Control the transport to use

stdio

cli usage

$ python3 -m tdengine_mcp_server -h

usage: __main__.py [-h] [-th TAOS_HOST] [-tp TAOS_PORT] [-tu TAOS_USERNAME] [-pwd TAOS_PASSWORD] [-db TAOS_DATABASE] [-to TAOS_TIMEOUT] [-ll LOG_LEVEL]

TDengine MCP Server

options:
  -h, --help            show this help message and exit
  -th, --taos-host TAOS_HOST
                        TDengine host address. Default: `localhost`
  -tp, --taos-port TAOS_PORT
                        TDengine port number. Default: `6041`
  -tu, --taos-username TAOS_USERNAME
                        TDengine username. Default: `root`
  -pwd, --taos-password TAOS_PASSWORD
                        TDengine password. Default: `taosdata`
  -db, --taos-database TAOS_DATABASE
                        TDengine database name. Default: `default`
  -to, --taos-timeout TAOS_TIMEOUT
                        TDengine connection timeout. Default: `30`
  -ll, --log-level LOG_LEVEL
                        Log level. Default: `INFO`
  -trans, --transport {sse,stdio}
                        The transport to use. Default: `sse`

Integration with AI Assistants

Your AI assistant can interact with TDengine databases through the MCP server. Here are some examples:

Example queries:

Can you use the query tool to show me the first 10 records from the database?
I need to analyze our sales data. Can you run a SQL query to get the total sales per region for last month from the development database?
Can you list all the available databases we have?

Using TDengine MCP Tools

The TDengine Query MCP server provides three main tools that your AI assistant can use:

1. query

Execute read-only SQL queries against a specific stable:

Use the query tool to run:

SELECT * FROM customers WHERE itemid > '2025-01-01' LIMIT 10;

2. info

Get detailed information about your stable:

Use the info tool to check the meta info about the specified stable.

DESCRIBE disks_info;

Security Considerations

  • ✅ Only read-only queries are allowed (SELECT, SHOW, DESCRIBE)

Troubleshooting

Connection Issues

If you're having trouble connecting:

  1. Verify your database credentials in your MCP configuration

  2. Ensure the TDengine server is running and accessible

  3. Check for firewall rules blocking connections

  4. Enable debug mode by setting LOG_LEVEL in your configuration

Common Errors

Error: Query execution failed

  • Verify your SQL syntax

  • Check that you're only using supported query types (SELECT, SHOW, DESCRIBE)

  • Ensure your query is truly read-only

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.


For more information or support, please open an issue on the GitHub repository.

Available Tools

6 tools
get_all_dbsB

Get all databases.

    Returns:
        TaosSqlResponse: All databases in the current Taos configuration.
    

Inputs: no named parameters. Returns: data, head, rows, status, +1 more

get_all_stablesC

Get all stables.

    Args:
        db_name (Optional[str]): The name of the database. Defaults to None. When the value is None, it means the configured database is used.

    Returns:
        TaosSqlResponse: All stables in the current Taos database.
    

Inputs: db_name. Returns: data, head, rows, status, +1 more

get_field_infosC

Get the field information of the specified stable.

    Args:
        db_name (Optional[str]): The name of the database. Defaults to None. When the value is None, it means the configured database is used.
        stable_name (str): The name of the stable.

    Returns:
        TaosSqlResponse: The field information of the specified stable.
    

Inputs: stable_name (required), db_name. Returns: data, head, rows, status, +1 more

query_taos_db_dataB

Important: Run a read-only SQL query on Taos database(涛思数据库).

    Args:
        sql_stmt (str): The sql statement you want to retrieve data from taos db.

    Returns:
        List: All data from the specified table.

Inputs: sql_stmt (required). Returns: data, head, rows, status, +1 more

switch_dbB

Switch to the specified database.

    Args:
        db_name (str): The name of the database to switch to.

    Returns:
        TaosSqlResponse: The result of the `USE` command.
    

Inputs: db_name (required). Returns: data, head, rows, status, +1 more

test_table_existsB

Important: Check if the stable exists in the current Taos database(涛思数据库) configuration.

    Args:
        stable_name (str): The name of the stable.

    Returns:
        Dict: The `stable_name` exists or not in the current Taos configuration. If the `stable_name` does not exist, an empty dictionary is returned.

        The key of the dictionary is the `stable_name` name, and the value is a boolean indicating whether the `stable_name` exists.
    

Inputs: stable_name (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 6 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose with no overlap: get_all_dbs lists databases, get_all_stables lists stables, get_field_infos retrieves field details, query_taos_db_data executes SQL queries, switch_db changes database context, and test_table_exists checks stable existence. The descriptions clearly differentiate their functions, preventing agent misselection.

    Naming Consistency4/5

    The naming follows a consistent snake_case pattern with clear verb_noun structures (e.g., get_all_dbs, switch_db, test_table_exists). The only minor deviation is query_taos_db_data, which includes 'taos_db' in the name while others omit it, but this doesn't significantly impact readability or predictability.

    Tool Count5/5

    With 6 tools, this server is well-scoped for database querying and management. Each tool serves a specific, necessary function in the TDengine domain, from basic queries to metadata inspection and context switching, without being overly sparse or bloated.

    Completeness4/5

    The toolset covers core database operations effectively: querying data, listing databases and stables, inspecting schema, switching contexts, and checking existence. A minor gap is the lack of write operations (e.g., insert, update, delete), but for a query-focused server, the surface is largely complete and supports common agent workflows.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      A Model Context Protocol server implementation that enables AI assistants to securely interact with GreptimeDB, allowing them to explore database schema, read data, and execute SQL queries through a controlled interface.
      15
      29
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      A Model Context Protocol server that provides read-only MySQL database queries for AI assistants, allowing them to execute queries, explore database structures, and investigate data directly from AI-powered tools.
      3
      82 npm
      13
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server that provides AI assistants with comprehensive access to SQL databases, enabling schema inspection, query execution, and database operations with enterprise-grade security.
      55 npm
      9
      MIT
    • F
      license
      A
      quality
      D
      maintenance
      A Model Context Protocol server that provides read-only access to Datasette instances, enabling AI assistants to explore, query, and analyze data from Datasette databases through a standardized interface.
      5
      2
      -