Provides tools and prompts for interacting with Teradata databases, enabling querying, analysis, data quality checks, DBA administration, backup/restore operations, vector store management, and more.
Click on "Deploy 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., "@BachStudio Teradata MCP Server show me the top 10 customers by total sales"
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.
The Teradata MCP server provides sets of tools and prompts, grouped as modules for interacting with Teradata databases. Enabling AI agents and users to query, analyze, and manage their data efficiently.
Related MCP server: tdsql-mcp
We are providing groupings of tools and associated helpful prompts to support all type of agentic applications on the data platform.
Search tools, prompts and resources to search and manage vector stores.
RAG Tools rapidly build RAG applications.
Query tools, prompts and resources to query and navigate your Teradata platform:
Table tools, to efficiently and predictably access structured data models:
Feature Store Tools to access and manage the Teradata Enterprise Feature Store.
Semantic layer definitions to easily implement domain-specific tools, prompts and resources for your own business data models.
Data Quality tools, prompts and resources accelerate exploratory data analysis:
DBA tools, prompts and resources to facilitate your platform administration tasks:
Data Scientist tools, prompts, and resources to build powerful AI agents and workflows for data-driven applications.
BAR tools, prompts and resources for database backup and restore operations:
BAR Tools integrate AI agents with Teradata DSA (Data Stream Architecture) for comprehensive backup management across multiple storage solutions including disk files, cloud storage (AWS S3, Azure Blob, Google Cloud), and enterprise systems (NetBackup, IBM Spectrum).
Prefer to use other tools? Check out our Quick Starts for VS Code/Copilot, Open WebUI, or dive into simple code examples! You can use Claude Desktop to give the Teradata MCP server a quick try, Claude can manage the server in the background using
uv. No permanent installation needed.
Pre-requisites
Get your Teradata database credentials or create a free sandbox at Teradata Clearscape Experience.
Install Claude Desktop.
Install uv. If you are on MacOS, Use Homebrew: brew install uv, on Windows you may use pip install uv as an alternative to the installer.
Configure the claude_desktop_config.json (Settings>Developer>Edit Config) by adding the configuration below, updating the database username, password and URL:
{
"mcpServers": {
"teradata": {
"command": "uvx",
"args": ["bachstudio-teradata-mcp-server"],
"env": {
"DATABASE_URI": "teradata://<USERNAME>:<PASSWORD>@<HOST_URL>:1025/<USERNAME>"
}
}
}
}Follow this process to install your server, connect it to your Teradata platform and integrated your tools.
Step 1. - Identify the running Teradata System, you need username, password and host details. If you do not have a Teradata system to connect to, then leverage Teradata Clearscape Experience
Step 2. - To install, configure and run the MCP server, refer to the Teradata MCP Server Documentation.
Step 3. - There are many client options available, the Client Guide explains how to configure and run a sample of different clients.
Check out our libraries of curated examples or video guides.
Please refer to the Contributing guide and the Developer Guide.
Shows detailed column information about a database table via SQLAlchemy, bind parameters if provided (prepared SQL), and return the fully rendered SQL (with literals) in metadata.
Arguments: database_name - Database name obj_name - table or view name
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), obj_name (required).
Lists all databases in the Teradata System.
Returns: ResponseType: formatted response with query results + metadata
Inputs: no named parameters.
Execute a SQL query via SQLAlchemy, bind parameters if provided (prepared SQL), and return the fully rendered SQL (with literals) in metadata.
Arguments: sql - SQL text, with optional bind-parameter placeholders
Returns: ResponseType: formatted response with query results + metadata
Inputs: sql.
Get tables commonly used together by database users, this is helpful to infer relationships between tables via SQLAlchemy, bind parameters if provided (prepared SQL), and return the fully rendered SQL (with literals) in metadata.
Arguments: database_name - Database name object_name - table or view name
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), obj_name (required).
Displays the DDL definition of a table via SQLAlchemy, bind parameters if provided (prepared SQL), and return the fully rendered SQL (with literals) in metadata.
Arguments: database_name - Database name table_name - table name
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required).
Lists all tables in a database.
Arguments: database_name - Database name
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name.
This function returns data sample and inferred structure from a database table or view via SQLAlchemy, bind parameters if provided (prepared SQL), and return the fully rendered SQL (with literals) in metadata.
Arguments: table_name - table or view name database_name - Database name
Returns: ResponseType: formatted response with query results + metadata
Inputs: table_name (required), database_name.
Measure the usage of a table and views by users in a given schema, this is helpful to infer what database objects are most actively used or drive most value via SQLAlchemy, bind parameters if provided (prepared SQL), and return the fully rendered SQL (with literals) in metadata.
Arguments: database_name - Database name
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name.
Get database space if database name is provided, otherwise get all databases space allocations.
Arguments: database_name - database name
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required).
Get Teradata database version information.
Inputs: no named parameters.
Get the user feature usage metrics for a specified date range.
Inputs: start_date (required), end_date (required).
Get the Teradata flow control metrics for a specified date range.
Inputs: start_date (required), end_date (required).
Get the Teradata system usage summary metrics by weekday and hour for each workload type and query complexity bucket.
Arguments:
dimensions - list of dimensions to aggregate the resource usage summary. All dimensions are: ["LogDate", "hourOfDay", "dayOfWeek", "workloadType", "workloadComplexity", "UserName", "AppId"]
user_name - user name
date - Date to analyze, formatted as YYYY-MM-DD
dayOfWeek - day of the week to analyze
hourOfDay - hour of day to analyze
workloadType - workload type to analyze, example: 'LOAD', 'ETL/ELT', 'EXPORT', 'QUERY', 'ADMIN', 'OTHER'
workloadComplexity - workload complexity to analyze, example: 'Ingest & Prep', 'Answers', 'System/Procedural'
AppId - Application ID to analyze, example: 'TPTLOAD%', 'TPTUPD%', 'FASTLOAD%', 'MULTLOAD%', 'EXECUTOR%', 'JDBC%'
Inputs: dimensions, user_name, date, dayOfWeek, +4 more.
Get the Teradata session information for user.
Inputs: user_name (required).
Get the Teradata total system database space usage.
Inputs: no named parameters.
Get table space used for a table if table name is provided or get table space for all tables in a database if a database name is provided."
Arguments: database_name - database name table_name - table name
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name, table_name.
Get a list of SQL run against a table in the last number of days.
Arguments: table_name - table name no_days - number of days
Returns: ResponseType: formatted response with query results + metadata
Inputs: table_name (required), no_days.
Measure the usage of a table and views by users, this is helpful to understand what user and tables are driving most resource usage at any point in time.
Arguments: database_name - database name to analyze user_name - user name to analyze
Inputs: database_name, user_name.
Get the Teradata user delay metrics for a specified date range.
Inputs: start_date (required), end_date (required).
Get a list of SQL run by a user in the last number of days if a user name is provided, otherwise get list of all SQL in the last number of days.
Arguments: user_name - user name no_days - number of days
Returns: ResponseType: formatted response with query results + metadata
Inputs: user_name (required), no_days.
Function to generate a line plot for labels and columns. Columns mentioned in labels are used for x-axis and columns are used for y-axis.
PARAMETERS: table_name: Required Argument. Specifies the name of the table to generate the donut plot. Types: str
labels:
Required Argument.
Specifies the labels to be used for the line plot.
Types: str
columns:
Required Argument.
Specifies the column to be used for generating the line plot.
Types: List[str]RETURNS: dict
Inputs: table_name (required), labels (required), columns (required).
Function to generate a pie chart plot for labels and columns. Columns mentioned in labels are used as labels and column is used to plot.
PARAMETERS: table_name: Required Argument. Specifies the name of the table to generate the donut plot. Types: str
labels:
Required Argument.
Specifies the labels to be used for the line plot.
Types: str
column:
Required Argument.
Specifies the column to be used for generating the line plot.
Types: strRETURNS: dict
Inputs: table_name (required), labels (required), column (required).
Function to generate a polar area plot for labels and columns. Columns mentioned in labels are used as labels and column is used to plot.
PARAMETERS: table_name: Required Argument. Specifies the name of the table to generate the donut plot. Types: str
labels:
Required Argument.
Specifies the labels to be used for the line plot.
Types: str
column:
Required Argument.
Specifies the column to be used for generating the line plot.
Types: strRETURNS: dict
Inputs: table_name (required), labels (required), column (required).
Function to generate a radar plot for labels and columns. Columns mentioned in labels are used as labels and column is used to plot.
PARAMETERS: table_name: Required Argument. Specifies the name of the table to generate the donut plot. Types: str
labels:
Required Argument.
Specifies the labels to be used for the line plot.
Types: str
columns:
Required Argument.
Specifies the column to be used for generating the line plot.
Types: strRETURNS: dict
Inputs: table_name (required), labels (required), columns (required).
Get the column summary statistics for a table.
Arguments: database_name - name of the database table_name - table name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required).
Get the destinct categories from column in a table.
Arguments: database_name - name of the database table_name - table name to analyze column_name - column name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required), column_name (required).
Get the column names that having missing values in a table.
Arguments: database_name - name of the database table_name - table name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required).
Get the column names that having negative values in a table.
Arguments: database_name - name of the database table_name - table name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required).
Get the rows with missing values in a table.
Arguments: database_name - name of the database table_name - table name to analyze column_name - column name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required), column_name (required).
Get the standard deviation from column in a table.
Arguments: database_name - name of the database table_name - table name to analyze column_name - column name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required), column_name (required).
Get the univariate statistics for a table.
Arguments: database_name - name of the database table_name - table name to analyze column_name - column name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: database_name (required), table_name (required), column_name (required).
Execute complete RAG workflow to answer user questions based on document context. This tool handles the entire RAG pipeline in a single step when a user query is tagged with /rag.
WORKFLOW STEPS (executed automatically):
Configuration setup using configurable values from rag_config.yml
Store user query with '/rag ' prefix stripping
Generate query embeddings using either BYOM (ONNXEmbeddings) or IVSM functions based on config
Perform semantic search against precomputed chunk embeddings
Return context chunks for answer generation
CONFIGURATION VALUES (from rag_config.yml):
version: 'ivsm' or 'byom' to select embedding approach
All database names, table names, and model settings are configurable
Vector store metadata fields are dynamically detected
Embedding parameters are configurable
Default chunk retrieval count is configurable
Default values are provided as fallback
TECHNICAL DETAILS:
Strips the '/rag ' prefix if present from user questions
Creates query table if it does not exist (columns: id, txt, created_ts)
BYOM approach: Uses mldb.ONNXEmbeddings UDF for tokenization and embedding
IVSM approach: Uses ivsm.tokenizer_encode and ivsm.IVSM_score functions
Both approaches store embeddings in configured output table
Uses cosine similarity via TD_VECTORDISTANCE for semantic search
Returns the top-k matching chunks from the configured vector store
Each result includes chunk text, similarity score, and metadata fields
CRITICAL ANSWERING RULES:
Answer ONLY using retrieved chunks - no external knowledge, speculation, or inference
Quote source content directly without paraphrasing, summarizing, or rewriting
If no relevant context found: "Not enough information found in the provided context"
If partial context: "The available context does not fully answer the question"
Include document/page references when available (e.g., "On page 2 of 'demo_policy.pdf'...")
Execute entire workflow silently without showing function calls to user - only show final answer
LANGUAGE RESTRICTIONS:
Do not say "According to the context" or "The context says" - just quote directly
Do not say "It can be inferred that..." - no inference allowed
Use exact or near-verbatim quotes only
No paraphrasing, summarizing, or adding transitions between quotes
Copy content precisely - no expansion or interpretation
BEHAVIORAL REQUIREMENTS:
Execute all RAG workflow steps silently without showing tool calls to users
Only display final answers based strictly on retrieved context chunks
Do not use external knowledge or speculation - only quote retrieved content directly
RAG mode only triggers with explicit /rag prefix - do not enter RAG mode implicitly
Hide all tool execution steps from user
Provide clean, direct response with only the answer based on retrieved chunks
This is a complete end-to-end RAG workflow - no additional tools needed
EXECUTION: Run completely silently - user only sees their question and the final context-grounded answer.
Inputs: question (required), k.
Get permissions for a role.
Arguments: role_name - role name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: role_name (required).
Get permissions for a user.
Arguments: user_name - user name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: user_name (required).
Get roles assigned to a user.
Arguments: user_name - user name to analyze
Returns: ResponseType: formatted response with query results + metadata
Inputs: user_name (required).
ANALYZE SQL QUERY CLUSTER PERFORMANCE STATISTICS
This tool analyzes pre-computed cluster statistics to identify optimization opportunities without re-running the clustering pipeline. Perfect for iterative analysis and decision-making on which query clusters to focus optimization efforts.
ANALYSIS CAPABILITIES:
Performance Ranking: Sort clusters by any performance metric to identify top resource consumers
Resource Impact Assessment: Compare clusters by CPU usage, I/O volume, and execution complexity
Skew Problem Detection: Identify clusters with CPU or I/O distribution issues
Workload Characterization: Understand query patterns by user, application, and workload type
Optimization Prioritization: Focus on clusters with highest impact potential
AVAILABLE SORTING METRICS:
avg_cpu: Average CPU seconds per cluster (primary optimization target)
avg_io: Average logical I/O operations (scan intensity indicator)
avg_cpuskw: Average CPU skew (distribution problem indicator)
avg_ioskw: Average I/O skew (hot spot indicator)
avg_pji: Average Physical-to-Logical I/O ratio (compute intensity)
avg_uii: Average Unit I/O Intensity (I/O efficiency)
avg_numsteps: Average query plan complexity
queries: Number of queries in cluster (frequency indicator)
cluster_silhouette_score: Clustering quality measure
PERFORMANCE CATEGORIZATION: Automatically categorizes clusters using configurable thresholds (from sql_opt_config.yml):
HIGH_CPU_USAGE: Average CPU > config.performance_thresholds.cpu.high
HIGH_IO_USAGE: Average I/O > config.performance_thresholds.io.high
HIGH_CPU_SKEW: CPU skew > config.performance_thresholds.skew.high
HIGH_IO_SKEW: I/O skew > config.performance_thresholds.skew.high
NORMAL: Clusters within configured normal performance ranges
TYPICAL ANALYSIS WORKFLOW:
Sort by 'avg_cpu' or 'avg_io' to find highest resource consumers
Sort by 'avg_cpuskw' or 'avg_ioskw' to find distribution problems
Use limit_results to focus on top problematic clusters
OPTIMIZATION DECISION FRAMEWORK:
High CPU + High Query Count: Maximum impact optimization candidates
High Skew + Moderate CPU: Distribution/statistics problems
High I/O + Low PJI: Potential indexing opportunities
High NumSteps: Complex query rewriting candidates
OUTPUT FORMAT: Returns detailed cluster statistics with performance rankings, categories, and metadata for LLM analysis and optimization recommendations.
Inputs: sort_by_metric, limit_results.
COMPLETE SQL QUERY CLUSTERING PIPELINE FOR HIGH-USAGE QUERY OPTIMIZATION
This tool executes the entire SQL query clustering workflow to identify and analyze high CPU usage queries for optimization opportunities. It's designed for database performance analysts and DBAs who need to systematically identify query optimization candidates.
FULL PIPELINE WORKFLOW:
Query Log Extraction: Extracts SQL queries from DBC.DBQLSqlTbl with comprehensive performance metrics
Performance Metrics Calculation: Computes CPU skew, I/O skew, PJI (Physical to Logical I/O ratio), UII (Unit I/O Intensity)
Query Tokenization: Tokenizes SQL text using {sql_clustering_config.get('model', {}).get('model_id', 'bge-small-en-v1.5')} tokenizer via ivsm.tokenizer_encode
Embedding Generation: Creates semantic embeddings using ivsm.IVSM_score with ONNX models
Vector Store Creation: Converts embeddings to vector columns via ivsm.vector_to_columns
K-Means Clustering: Groups similar queries using TD_KMeans with optimal K from configuration
Silhouette Analysis: Calculates clustering quality scores using TD_Silhouette
Statistics Generation: Creates comprehensive cluster statistics with performance aggregations
PERFORMANCE METRICS EXPLAINED:
AMPCPUTIME: Total CPU seconds across all AMPs (primary optimization target)
CPUSKW/IOSKW: CPU/I/O skew ratios (>2.0 indicates distribution problems)
PJI: Physical-to-Logical I/O ratio (higher = more CPU-intensive)
UII: Unit I/O Intensity (higher = more I/O-intensive relative to CPU)
LogicalIO: Total logical I/O operations (indicates scan intensity)
NumSteps: Query plan complexity (higher = more complex plans)
CONFIGURATION (from sql_opt_config.yml):
Uses top {default_max_queries} queries by CPU time (configurable)
Creates {default_optimal_k} clusters by default (configurable via optimal_k parameter)
Embedding model: {sql_clustering_config.get('model', {}).get('model_id', 'bge-small-en-v1.5')}
Vector dimensions: {sql_clustering_config.get('embedding', {}).get('vector_length', 384)}
All database and table names are configurable
OPTIMIZATION WORKFLOW: After running this tool, use:
sql_Analyze_Cluster_Stats to identify problematic clusters
sql_Retrieve_Cluster_Queries to get actual SQL from target clusters
LLM analysis to identify patterns and propose specific optimizations
USE CASES:
Identify query families consuming the most system resources
Find queries with similar patterns but different performance
Discover optimization opportunities through clustering analysis
Prioritize DBA effort on highest-impact query improvements
Understand workload composition and resource distribution
PREREQUISITES:
DBC.DBQLSqlTbl and DBC.DBQLOgTbl must be accessible
Embedding models and tokenizers must be installed in feature_ext_db
Sufficient space in feature_ext_db for intermediate and final tables
Inputs: optimal_k, max_queries.
RETRIEVE ACTUAL SQL QUERIES FROM SPECIFIC CLUSTERS FOR PATTERN ANALYSIS
This tool extracts the actual SQL query text and performance metrics from selected clusters, enabling detailed pattern analysis and specific optimization recommendations. Essential for moving from cluster-level analysis to actual query optimization.
DETAILED ANALYSIS CAPABILITIES:
SQL Pattern Recognition: Analyze actual query structures, joins, predicates, and functions
Performance Correlation: Connect query patterns to specific performance characteristics
Optimization Identification: Identify common anti-patterns, missing indexes, inefficient joins
Code Quality Assessment: Evaluate query construction, complexity, and best practices
Workload Understanding: See actual business logic and data access patterns
QUERY SELECTION STRATEGIES:
By CPU Impact: Sort by 'ampcputime' to focus on highest CPU consumers
By I/O Volume: Sort by 'logicalio' to find scan-intensive queries
By Skew Problems: Sort by 'cpuskw' or 'ioskw' for distribution issues
By Complexity: Sort by 'numsteps' for complex execution plans
By Response Time: Sort by 'response_secs' for user experience impact
AVAILABLE METRICS FOR SORTING:
ampcputime: Total CPU seconds (primary optimization target)
logicalio: Total logical I/O operations (scan indicator)
cpuskw: CPU skew ratio (distribution problems)
ioskw: I/O skew ratio (hot spot indicators)
pji: Physical-to-Logical I/O ratio (compute intensity)
uii: Unit I/O Intensity (I/O efficiency)
numsteps: Query execution plan steps (complexity)
response_secs: Wall-clock execution time (user impact)
delaytime: Time spent in queue (concurrency issues)
AUTOMATIC PERFORMANCE CATEGORIZATION: Each query is categorized using configurable thresholds (from sql_opt_config.yml):
CPU Categories: VERY_HIGH_CPU (>config.very_high), HIGH_CPU (>config.high), MEDIUM_CPU (>10s), LOW_CPU
CPU Skew: SEVERE_CPU_SKEW (>config.severe), HIGH_CPU_SKEW (>config.high), MODERATE_CPU_SKEW (>config.moderate), NORMAL
I/O Skew: SEVERE_IO_SKEW (>config.severe), HIGH_IO_SKEW (>config.high), MODERATE_IO_SKEW (>config.moderate), NORMAL
Use thresholds set in config file for, CPU - high, very_high, Skew moderate, high, severe
TYPICAL OPTIMIZATION WORKFLOW:
Start with clusters identified from sql_Analyze_Cluster_Stats
Retrieve top queries by impact metric (usually 'ampcputime')
Analyze SQL patterns for common issues:
Missing WHERE clauses or inefficient predicates
Cartesian products or missing JOIN conditions
Inefficient GROUP BY or ORDER BY operations
Suboptimal table access patterns
Missing or outdated statistics
Develop specific optimization recommendations
QUERY LIMIT STRATEGY:
Use the query limit set in config file for pattern recognition and analysis, unless user specifies a different limit
OUTPUT INCLUDES:
Complete SQL query text for each query
All performance metrics, user, application, and workload context, cluster membership and rankings
Performance categories for quick filtering
Inputs: cluster_ids (required), metric, limit_per_cluster.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 38 tools
Most tools have distinct purposes, but there is some overlap between base_tableUsage and dba_tableUsageImpact, which both measure table usage. Similarly, qlty_missingValues and qlty_rowsWithMissingValues could be confused, though they target different outputs. Overall, the tool set is reasonably disambiguated.
Tool names use prefixes (base_, dba_, qlty_, sec_, sql_, rag_, plot_) but mixing camelCase (base_columnDescription) and underscores (sql_Analyze_Cluster_Stats) within the same server creates inconsistency. Naming after the prefix is also inconsistent: some are verb-noun (base_readQuery), others noun-noun (base_tableList).
With 38 tools, the server is on the heavier side for a database interaction server. While the scope justifies many functions, several tools overlap (e.g., table usage metrics) and plotting tools feel slightly out of place, making the count feel excessive rather than lean.
The server covers broad areas (metadata, DBA, data quality, security, SQL optimization, RAG, plotting), but has notable gaps: no dedicated tools for DDL operations (create/alter/drop) beyond generic readQuery, and no individual RAG utilities (e.g., embedding search). The SQL optimization suite is thorough but dependent on pre-existing tables.
MCP server for building and testing AI agents with multi-model experimentation and insights.
Cloud-hosted MCP server for secure AI access to enterprise data sources via CData Connect AI.
MCP server for querying and analyzing data from ad platforms, analytics tools, and spreadsheets
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
