mssql-agent-mcp 1.0.0__py3-none-any.whl

mssql_agent_mcp/__init__.py

@@ -0,0 +1,9 @@
+"""MSSQL Agent MCP Server.
+
+A Model Context Protocol server for Microsoft SQL Server with support for
+database queries, stored procedure management, and SQL Server Agent jobs.
+"""
+
+from .server import main, mcp
+
+__all__ = ["main", "mcp"]

mssql_agent_mcp/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running the MSSQL MCP server as a module."""
+
+from .server import main
+
+if __name__ == "__main__":
+    main()

mssql_agent_mcp/config.py

@@ -0,0 +1,25 @@
+"""Configuration and environment variables for MSSQL MCP Server."""
+
+import os
+
+# Security configuration
+READONLY_MODE = os.getenv("MSSQL_READONLY", "true").lower() in ("true", "1", "yes")
+
+# Database configuration from environment variables
+DB_CONFIG = {
+    "server": os.getenv("MSSQL_SERVER", "localhost"),
+    "database": os.getenv("MSSQL_DATABASE", "master"),
+    "user": os.getenv("MSSQL_USER", ""),
+    "password": os.getenv("MSSQL_PASSWORD", ""),
+    "port": os.getenv("MSSQL_PORT", "1433"),
+    "driver": os.getenv("MSSQL_DRIVER", "ODBC Driver 18 for SQL Server"),
+    "encrypt": os.getenv("MSSQL_ENCRYPT", "yes"),
+    "trust_server_certificate": os.getenv("MSSQL_TRUST_SERVER_CERTIFICATE", "no"),
+    "auth_mode": os.getenv("MSSQL_AUTH_MODE", "sql"),  # sql, windows, azure
+}
+
+# Blocked SQL statement types when in readonly mode
+BLOCKED_STATEMENT_TYPES = {
+    "INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "ALTER",
+    "TRUNCATE", "MERGE", "EXEC", "EXECUTE", "GRANT", "REVOKE", "DENY",
+}

mssql_agent_mcp/server.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""MSSQL MCP Server - Main entry point.
+
+Provides tools for interacting with Microsoft SQL Server databases,
+including stored procedure management and SQL Server Agent job management.
+"""
+
+from fastmcp import FastMCP
+
+from .tools import database as db_tools
+from .tools import jobs as job_tools
+from .tools import procedures as proc_tools
+
+# Create the FastMCP server instance
+mcp = FastMCP(
+    "mssql-agent-mcp",
+    instructions="""This MCP server provides tools for interacting with Microsoft SQL Server databases.
+
+    It supports:
+    - Database queries and schema inspection
+    - Stored procedure management with export/import workflows
+    - SQL Server Agent job management with jobs-as-code workflow
+
+    Use `query` for SELECT statements, `execute` for write operations.
+    Jobs and procedures can be exported to files, edited, and pushed back to the server.
+    """,
+)
+
+# Register database tools
+mcp.tool()(db_tools.query)
+mcp.tool()(db_tools.execute)
+mcp.tool()(db_tools.list_tables)
+mcp.tool()(db_tools.describe_table)
+mcp.tool()(db_tools.list_databases)
+mcp.tool()(db_tools.get_table_sample)
+mcp.tool()(db_tools.get_table_indexes)
+mcp.tool()(db_tools.get_foreign_keys)
+
+# Register stored procedure tools
+mcp.tool()(proc_tools.list_procedures)
+mcp.tool()(proc_tools.list_all_procedures)
+mcp.tool()(proc_tools.get_procedure_details)
+mcp.tool()(proc_tools.get_procedure_parameters)
+mcp.tool()(proc_tools.export_procedures_to_files)
+mcp.tool()(proc_tools.update_procedure_from_file)
+
+# Register SQL Server Agent job tools
+mcp.tool()(job_tools.list_agent_jobs)
+mcp.tool()(job_tools.get_job_steps)
+mcp.tool()(job_tools.get_job_details)
+mcp.tool()(job_tools.get_job_schedules)
+mcp.tool()(job_tools.get_job_history)
+mcp.tool()(job_tools.export_enabled_jobs_to_files)
+mcp.tool()(job_tools.update_job_step_from_file)
+mcp.tool()(job_tools.create_job_step_from_file)
+
+
+def main():
+    """Run the MCP server."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

mssql_agent_mcp/tools/__init__.py

@@ -0,0 +1,58 @@
+"""MCP tools for MSSQL Server operations."""
+
+from .database import (
+    describe_table,
+    execute,
+    get_foreign_keys,
+    get_table_indexes,
+    get_table_sample,
+    list_databases,
+    list_tables,
+    query,
+)
+from .jobs import (
+    create_job_step_from_file,
+    export_enabled_jobs_to_files,
+    get_job_details,
+    get_job_history,
+    get_job_schedules,
+    get_job_steps,
+    list_agent_jobs,
+    update_job_step_from_file,
+)
+from .procedures import (
+    export_procedures_to_files,
+    get_procedure_details,
+    get_procedure_parameters,
+    list_all_procedures,
+    list_procedures,
+    update_procedure_from_file,
+)
+
+__all__ = [
+    # Database tools
+    "query",
+    "execute",
+    "list_tables",
+    "describe_table",
+    "list_databases",
+    "get_table_sample",
+    "get_table_indexes",
+    "get_foreign_keys",
+    # Procedure tools
+    "list_procedures",
+    "list_all_procedures",
+    "get_procedure_details",
+    "get_procedure_parameters",
+    "export_procedures_to_files",
+    "update_procedure_from_file",
+    # Job tools
+    "list_agent_jobs",
+    "get_job_steps",
+    "get_job_details",
+    "get_job_schedules",
+    "get_job_history",
+    "export_enabled_jobs_to_files",
+    "update_job_step_from_file",
+    "create_job_step_from_file",
+]

mssql_agent_mcp/tools/database.py

@@ -0,0 +1,193 @@
+"""Database query and schema inspection tools."""
+
+from typing import Annotated
+
+from ..config import READONLY_MODE
+from ..utils import format_result, get_connection, rows_to_dicts, validate_query
+
+
+def query(
+    sql: Annotated[str, "The SQL query to execute (SELECT statements)"]
+) -> str:
+    """Execute a SQL query and return results. Use for SELECT statements."""
+    is_valid, error_msg = validate_query(sql)
+    if not is_valid:
+        return format_result({"error": error_msg})
+
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql)
+        if cursor.description:
+            rows = rows_to_dicts(cursor)
+            return format_result(rows) if rows else "Query executed successfully. No rows returned."
+        return "Query executed successfully. No rows returned."
+    finally:
+        conn.close()
+
+
+def execute(
+    sql: Annotated[str, "The SQL statement to execute (INSERT, UPDATE, DELETE, CREATE, etc.)"]
+) -> str:
+    """Execute a SQL statement (INSERT, UPDATE, DELETE, CREATE, etc.) and return affected rows count."""
+    if READONLY_MODE:
+        return format_result({
+            "error": "Write operations are disabled in read-only mode. Set MSSQL_READONLY=false to enable."
+        })
+
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql)
+        conn.commit()
+        return f"Statement executed successfully. Rows affected: {cursor.rowcount}"
+    finally:
+        conn.close()
+
+
+def list_tables(
+    schema: Annotated[str | None, "Schema name to filter tables (optional, defaults to all schemas)"] = None
+) -> str:
+    """List all tables in the current database."""
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        if schema:
+            sql = """
+                SELECT TABLE_SCHEMA as [schema], TABLE_NAME as [table], TABLE_TYPE as [type]
+                FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?
+                ORDER BY TABLE_SCHEMA, TABLE_NAME
+            """
+            cursor.execute(sql, (schema,))
+        else:
+            sql = """
+                SELECT TABLE_SCHEMA as [schema], TABLE_NAME as [table], TABLE_TYPE as [type]
+                FROM INFORMATION_SCHEMA.TABLES ORDER BY TABLE_SCHEMA, TABLE_NAME
+            """
+            cursor.execute(sql)
+        return format_result(rows_to_dicts(cursor))
+    finally:
+        conn.close()
+
+
+def describe_table(
+    table: Annotated[str, "The table name to describe"],
+    schema: Annotated[str, "The schema name (defaults to 'dbo')"] = "dbo"
+) -> str:
+    """Get the schema/structure of a specific table including columns, data types, and constraints."""
+    sql = """
+        SELECT
+            c.COLUMN_NAME as [column], c.DATA_TYPE as [type],
+            c.CHARACTER_MAXIMUM_LENGTH as [max_length],
+            c.NUMERIC_PRECISION as [precision], c.NUMERIC_SCALE as [scale],
+            c.IS_NULLABLE as [nullable], c.COLUMN_DEFAULT as [default],
+            CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 'YES' ELSE 'NO' END as [primary_key]
+        FROM INFORMATION_SCHEMA.COLUMNS c
+        LEFT JOIN (
+            SELECT ku.TABLE_SCHEMA, ku.TABLE_NAME, ku.COLUMN_NAME
+            FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+            JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku ON tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
+            WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+        ) pk ON c.TABLE_SCHEMA = pk.TABLE_SCHEMA AND c.TABLE_NAME = pk.TABLE_NAME AND c.COLUMN_NAME = pk.COLUMN_NAME
+        WHERE c.TABLE_NAME = ? AND c.TABLE_SCHEMA = ?
+        ORDER BY c.ORDINAL_POSITION
+    """
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql, (table, schema))
+        return format_result(rows_to_dicts(cursor))
+    finally:
+        conn.close()
+
+
+def list_databases() -> str:
+    """List all databases on the SQL Server instance."""
+    sql = """
+        SELECT name as [database], state_desc as [state],
+               recovery_model_desc as [recovery_model], create_date as [created]
+        FROM sys.databases ORDER BY name
+    """
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql)
+        return format_result(rows_to_dicts(cursor))
+    finally:
+        conn.close()
+
+
+def get_table_sample(
+    table: Annotated[str, "The table name"],
+    schema: Annotated[str, "The schema name (defaults to 'dbo')"] = "dbo",
+    limit: Annotated[int, "Number of rows to return (defaults to 10, max 1000)"] = 10
+) -> str:
+    """Get a sample of rows from a table."""
+    safe_schema = "".join(c for c in schema if c.isalnum() or c == "_")
+    safe_table = "".join(c for c in table if c.isalnum() or c == "_")
+    safe_limit = min(max(1, int(limit)), 1000)
+
+    sql = f"SELECT TOP {safe_limit} * FROM [{safe_schema}].[{safe_table}]"
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql)
+        return format_result(rows_to_dicts(cursor))
+    finally:
+        conn.close()
+
+
+def get_table_indexes(
+    table: Annotated[str, "The table name"],
+    schema: Annotated[str, "The schema name (defaults to 'dbo')"] = "dbo"
+) -> str:
+    """Get indexes defined on a table."""
+    sql = """
+        SELECT i.name as [index_name], i.type_desc as [index_type],
+               i.is_unique as [is_unique], i.is_primary_key as [is_primary_key],
+               STRING_AGG(c.name, ', ') WITHIN GROUP (ORDER BY ic.key_ordinal) as [columns]
+        FROM sys.indexes i
+        JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+        JOIN sys.tables t ON i.object_id = t.object_id
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        WHERE t.name = ? AND s.name = ?
+        GROUP BY i.name, i.type_desc, i.is_unique, i.is_primary_key
+        ORDER BY i.name
+    """
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql, (table, schema))
+        return format_result(rows_to_dicts(cursor))
+    finally:
+        conn.close()
+
+
+def get_foreign_keys(
+    table: Annotated[str, "The table name"],
+    schema: Annotated[str, "The schema name (defaults to 'dbo')"] = "dbo"
+) -> str:
+    """Get foreign key relationships for a table."""
+    sql = """
+        SELECT fk.name as [constraint_name],
+               OBJECT_SCHEMA_NAME(fk.parent_object_id) as [from_schema],
+               OBJECT_NAME(fk.parent_object_id) as [from_table],
+               COL_NAME(fkc.parent_object_id, fkc.parent_column_id) as [from_column],
+               OBJECT_SCHEMA_NAME(fk.referenced_object_id) as [to_schema],
+               OBJECT_NAME(fk.referenced_object_id) as [to_table],
+               COL_NAME(fkc.referenced_object_id, fkc.referenced_column_id) as [to_column]
+        FROM sys.foreign_keys fk
+        JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id
+        JOIN sys.tables t ON fk.parent_object_id = t.object_id
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        WHERE t.name = ? AND s.name = ?
+        ORDER BY fk.name
+    """
+    conn = get_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute(sql, (table, schema))
+        return format_result(rows_to_dicts(cursor))
+    finally:
+        conn.close()