MCP Server - Model Context Protocol

Dalineage provides an MCP (Model Context Protocol) server that allows AI assistants and other tools to interact with the SQL parser directly via REST API.

What is MCP?

MCP (Model Context Protocol) is a standard protocol for AI assistants to interact with external tools and services. The Dalineage MCP server exposes parsing capabilities through a simple REST endpoint.

Parser Endpoint

The MCP server provides a parser endpoint that accepts SQL code in various dialects and returns the Abstract Syntax Tree (AST).

Endpoint URL

POST /api/parser/{dialect}

Supported Dialects

oracle - Oracle SQL
tsql - Microsoft SQL Server / T-SQL
bigquery - Google BigQuery
snowflake - Snowflake
teradata - Teradata
impala - Apache Impala
redshift - Amazon Redshift
powerbi - Power BI M language

Authentication

The endpoint requires HTTP Basic Authentication (same as other API endpoints).

Request

Method: POST
Content-Type: text/plain
Body: SQL code to parse (plain text)

Response

The response is a JSON object with the following structure:

Success response:

{
  "status": "success",
  "data": {
    "type": "Script",
    "statementCount": 2,
    "ast": "Script(\n  statements = List(\n    SelectQuery(...),\n    InsertQuery(...)\n  )\n)"
  }
}

Error response:

{
  "status": "error",
  "data": "Parsing failed: unexpected token at line 5..."
}

Usage Examples

Basic Example - Oracle

curl -X POST http://localhost:8080/api/parser/oracle \
  -u admin:admin \
  -H "Content-Type: text/plain" \
  -d "SELECT * FROM employees WHERE salary > 1000"

T-SQL Example

curl -X POST http://localhost:8080/api/parser/tsql \
  -u admin:admin \
  -H "Content-Type: text/plain" \
  -d "SELECT TOP 10 * FROM customers WHERE country = 'USA'"

BigQuery Example

curl -X POST http://localhost:8080/api/parser/bigquery \
  -u admin:admin \
  -H "Content-Type: text/plain" \
  -d "SELECT * FROM \`project.dataset.table\` WHERE date > '2023-01-01'"

Parse from File

curl -X POST http://localhost:8080/api/parser/snowflake \
  -u admin:admin \
  -H "Content-Type: text/plain" \
  --data-binary @my_script.sql

With jq for Pretty Output

curl -X POST http://localhost:8080/api/parser/oracle \
  -u admin:admin \
  -H "Content-Type: text/plain" \
  -d "SELECT * FROM employees" | jq

Response Format

The AST (Abstract Syntax Tree) is returned as a formatted string representation using the same format as internal Dalineage processing. This representation shows:

Script structure
All parsed statements
Query structure (SELECT, INSERT, UPDATE, DELETE, etc.)
Table references
Column references
WHERE clauses, JOINs, and other SQL constructs
Position information for each element

Use Cases

1. AI Assistants

AI assistants can use this endpoint to:

Parse SQL code provided by users
Validate SQL syntax
Extract table and column dependencies
Analyze query structure

2. IDE Integration

Development tools can integrate the parser to:

Provide syntax validation
Extract metadata from SQL scripts
Build dependency graphs

3. CI/CD Pipelines

Automated pipelines can use the parser to:

Validate SQL scripts before deployment
Extract lineage information
Generate documentation

4. Code Analysis Tools

Static analysis tools can:

Parse large SQL codebases
Extract schema information
Identify code patterns

Error Handling

The parser returns detailed error messages when parsing fails:

{
  "status": "error",
  "data": "Parsing failed: Expected identifier:1:8, found \"FROM\""
}

Error messages include:

Line and column numbers
Expected vs. found tokens
Context of the error

Configuration

The MCP server uses the same configuration as the main Dalineage application:

Port: Default 8080 (configurable via -Dserver.port=XXXX)
Authentication: Uses the same user database as the web interface
Timeouts: Standard HTTP timeouts apply

Limitations

Maximum request size is limited by server configuration (default 2GB)
Complex scripts may take longer to parse
The endpoint is synchronous (waits for parsing to complete)

Technical Details

The parser endpoint:

Uses the same parser as batch processing
Returns AST in pprint format (standard Scala pretty-print)
Supports all SQL dialects available in Dalineage
Includes position information for each parsed element
Runs in a Future for non-blocking execution