sqlsaber 0.29.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

sqlsaber/tools/sql_tools.py

@@ -7,7 +7,6 @@ from sqlsaber.database import BaseDatabaseConnection
 from sqlsaber.database.schema import SchemaManager
 
 from .base import Tool
-from .enums import ToolCategory, WorkflowPosition
 from .registry import register_tool
 from .sql_guard import add_limit, validate_read_only
 
@@ -26,11 +25,6 @@ class SQLTool(Tool):
         self.db = db_connection
         self.schema_manager = SchemaManager(db_connection)
 
-    @property
-    def category(self) -> ToolCategory:
-        """SQL tools belong to the 'sql' category."""
-        return ToolCategory.SQL
-
 
 @register_tool
 class ListTablesTool(SQLTool):
@@ -52,18 +46,6 @@ class ListTablesTool(SQLTool):
             "required": [],
         }
 
-    def get_usage_instructions(self) -> str | None:
-        """Return usage instructions for this tool."""
-        return "ALWAYS start with 'list_tables' to see available tables and row counts. Use this first to discover available tables."
-
-    def get_priority(self) -> int:
-        """Return priority for tool ordering."""
-        return 10  # High priority - should be used first
-
-    def get_workflow_position(self) -> WorkflowPosition:
-        """Return workflow position."""
-        return WorkflowPosition.DISCOVERY
-
     async def execute(self, **kwargs) -> str:
         """List all tables in the database."""
         if not self.db or not self.schema_manager:
@@ -101,18 +83,6 @@ class IntrospectSchemaTool(SQLTool):
             "required": [],
         }
 
-    def get_usage_instructions(self) -> str | None:
-        """Return usage instructions for this tool."""
-        return "Use 'introspect_schema' with a table_pattern to get details ONLY for relevant tables. Use table patterns like 'sample%' or '%experiment%' to filter related tables."
-
-    def get_priority(self) -> int:
-        """Return priority for tool ordering."""
-        return 20  # Should come after list_tables
-
-    def get_workflow_position(self) -> WorkflowPosition:
-        """Return workflow position."""
-        return WorkflowPosition.ANALYSIS
-
     async def execute(self, **kwargs) -> str:
         """Introspect database schema."""
         if not self.db or not self.schema_manager:
@@ -184,18 +154,6 @@ class ExecuteSQLTool(SQLTool):
             "required": ["query"],
         }
 
-    def get_usage_instructions(self) -> str | None:
-        """Return usage instructions for this tool."""
-        return "Execute SQL queries safely with automatic LIMIT clauses for SELECT statements. Only SELECT queries are permitted for security."
-
-    def get_priority(self) -> int:
-        """Return priority for tool ordering."""
-        return 30  # Should come after schema tools
-
-    def get_workflow_position(self) -> WorkflowPosition:
-        """Return workflow position."""
-        return WorkflowPosition.EXECUTION
-
     async def execute(self, **kwargs) -> str:
         """Execute a SQL query."""
         if not self.db:

{sqlsaber-0.29.0.dist-info → sqlsaber-0.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.29.0
+Version: 0.30.0
 Summary: SQLsaber - Open-source agentic SQL assistant
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -9,7 +9,6 @@ Requires-Dist: aiosqlite>=0.21.0
 Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: cyclopts>=3.22.1
 Requires-Dist: duckdb>=0.9.2
-Requires-Dist: fastmcp>=2.9.0
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: keyring>=25.6.0
 Requires-Dist: platformdirs>=4.0.0
@@ -44,10 +43,7 @@ Ask your questions in natural language and `sqlsaber` will gather the right cont
   - [Resume Past Conversation](#resume-past-conversation)
   - [Database Selection](#database-selection)
 - [Examples](#examples)
-- [MCP Server Integration](#mcp-server-integration)
-  - [Starting the MCP Server](#starting-the-mcp-server)
-  - [Configuring MCP Clients](#configuring-mcp-clients)
-  - [Available MCP Tools](#available-mcp-tools)
+
 - [How It Works](#how-it-works)
 - [Contributing](#contributing)
 - [License](#license)
@@ -60,7 +56,7 @@ Ask your questions in natural language and `sqlsaber` will gather the right cont
 - Interactive REPL mode
 - Conversation threads (store, display, and resume conversations)
 - Support for PostgreSQL, MySQL, SQLite, DuckDB, and CSVs
-- MCP (Model Context Protocol) server support
+
 - Extended thinking mode for select models (Anthropic, OpenAI, Google, Groq)
 - Beautiful formatted output
 
@@ -220,43 +216,6 @@ saber "show me orders with customer details for this week"
 saber "which products had the highest sales growth last quarter?"
 ```
 
-## MCP Server Integration
-
-SQLSaber includes an MCP (Model Context Protocol) server that allows AI agents like Claude Code to directly leverage tools available in SQLSaber.
-
-### Starting the MCP Server
-
-Run the MCP server using uvx:
-
-```bash
-uvx --from sqlsaber saber-mcp
-```
-
-### Configuring MCP Clients
-
-#### Claude Code
-
-Add SQLSaber as an MCP server in Claude Code:
-
-```bash
-claude mcp add sqlsaber -- uvx --from sqlsaber saber-mcp
-```
-
-#### Other MCP Clients
-
-For other MCP clients, configure them to run the command: `uvx --from sqlsaber saber-mcp`
-
-### Available MCP Tools
-
-Once connected, the MCP client will have access to these tools:
-
-- `get_databases()` - Lists all configured databases
-- `list_tables(database)` - Get all tables in a database with row counts
-- `introspect_schema(database, table_pattern?)` - Get detailed schema information
-- `execute_sql(database, query, limit?)` - Execute SQL queries (read-only)
-
-The MCP server uses your existing SQLSaber database configurations, so make sure to set up your databases using `saber db add` first.
-
 ## How It Works
 
 SQLsaber uses a multi-step agentic process to gather the right context and execute SQL queries to answer your questions:

sqlsaber-0.30.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+sqlsaber/__init__.py,sha256=HjS8ULtP4MGpnTL7njVY45NKV9Fi4e_yeYuY-hyXWQc,73
+sqlsaber/__main__.py,sha256=RIHxWeWh2QvLfah-2OkhI5IJxojWfy4fXpMnVEJYvxw,78
+sqlsaber/agents/__init__.py,sha256=qYI6rLY4q5AbF47vXH5RVoM08-yQjymBSaePh4lFIW4,116
+sqlsaber/agents/base.py,sha256=T05UsMZPwAlMhsJFpuuVI1RNDhdiwiEsgCWr9MbPoAU,2654
+sqlsaber/agents/pydantic_ai_agent.py,sha256=cHHwQHJf9TqrBhItWJgnScL31lvyvKLcCBTSjRSwWug,12002
+sqlsaber/application/__init__.py,sha256=KY_-d5nEdQyAwNOsK5r-f7Tb69c63XbuEkHPeLpJal8,84
+sqlsaber/application/auth_setup.py,sha256=D94dyU9bOVfnNHLnnFJb5PaeWsKPTL21CiS_DLcY93A,5114
+sqlsaber/application/db_setup.py,sha256=ZSgR9rJJVHttIjsbYQS9GEIyzkM09k5RLrVGdegrfYc,6859
+sqlsaber/application/model_selection.py,sha256=fSC06MZNKinHDR-csMFVYYJFyK8MydKf6pStof74Jp0,3191
+sqlsaber/application/prompts.py,sha256=4rMGcWpYJbNWPMzqVWseUMx0nwvXOkWS6GaTAJ5mhfc,3473
+sqlsaber/cli/__init__.py,sha256=qVSLVJLLJYzoC6aj6y9MFrzZvAwc4_OgxU9DlkQnZ4M,86
+sqlsaber/cli/auth.py,sha256=elUpw8gypHGlxbHx4a4_z4wFznx2vr6V1h8lqpeC6OQ,6121
+sqlsaber/cli/commands.py,sha256=Pii_SlVKpNEtt57_QPQzwC1u-x6tA8kuG8yd43undWE,8628
+sqlsaber/cli/completers.py,sha256=g-hLDq5fiBx7gg8Bte1Lq8GU-ZxCYVs4dcPsmHPIcK4,6574
+sqlsaber/cli/database.py,sha256=Tqy8H5MnjsrmOSPcbA5Qy-u-IOYJCIXRJVhk0veLNDk,10726
+sqlsaber/cli/display.py,sha256=WB5JCumhXadziDEX1EZHG3vN1Chol5FNAaTXHieqFK0,17892
+sqlsaber/cli/interactive.py,sha256=PcY6mszImo_3PsqjjWmx_cOfj44OmKvD9ENOvGA-wjU,13715
+sqlsaber/cli/memory.py,sha256=IKq09DUbqpvvtATsyDlpm7rDlGqWEhdUX9wgnR-oiq4,7850
+sqlsaber/cli/models.py,sha256=nbn75gCnkRciGt4Q47yxa8wImiZcCkDdQZNVeehDim8,8530
+sqlsaber/cli/onboarding.py,sha256=iBGT-W-OJFRvQoEpuHYyO1c9Mym5c97eIefRvxGHtTg,11265
+sqlsaber/cli/streaming.py,sha256=eggj25ZlA-xKrAF726S29vfS2MHTFC5wTmgXLbS-RvM,6515
+sqlsaber/cli/theme.py,sha256=hP0kmsMLCtqaT7b5wB1dk1hW1hV94oP4BHdz8S6887A,4243
+sqlsaber/cli/threads.py,sha256=o9q9Hst1Wt7cxSyrpAtwG6pkUct6csgiAmN_0P_WO3k,13637
+sqlsaber/config/__init__.py,sha256=olwC45k8Nc61yK0WmPUk7XHdbsZH9HuUAbwnmKe3IgA,100
+sqlsaber/config/api_keys.py,sha256=9RyhD5Bntq8NMFRPiZZo8YEHACK9MPyFGp8dsmQZ1iI,3678
+sqlsaber/config/auth.py,sha256=b5qB2h1doXyO9Bn8z0CcL8LAR2jF431gGXBGKLgTmtQ,2756
+sqlsaber/config/database.py,sha256=Yec6_0wdzq-ADblMNnbgvouYCimYOY_DWHT9oweaISc,11449
+sqlsaber/config/oauth_flow.py,sha256=P81lHhtICdhiQu8lNwyqn2m45FGEqCEzLgUQTLG5UW0,10343
+sqlsaber/config/oauth_tokens.py,sha256=V4U8GAQHjTfgUcTzwjRVaIE7DeN0tF9OsSjiasHw7Uc,5970
+sqlsaber/config/providers.py,sha256=JFjeJv1K5Q93zWSlWq3hAvgch1TlgoF0qFa0KJROkKY,2957
+sqlsaber/config/settings.py,sha256=iB4CnGQ4hw8gxkaa9CVLB_JEy6Y9h9FQTAams5OCVyI,6421
+sqlsaber/database/__init__.py,sha256=Gi9N_NOkD459WRWXDg3hSuGoBs3xWbMDRBvsTVmnGAg,2025
+sqlsaber/database/base.py,sha256=oaipLxlvoylX6oJCITPAWWqRqv09hRELqqEBufsmFic,3703
+sqlsaber/database/csv.py,sha256=41wuP40FaGPfj28HMiD0I69uG0JbUxArpoTLC3MG2uc,4464
+sqlsaber/database/duckdb.py,sha256=8HNKdx208aFK_YtwGjLz6LTne0xEmNevD-f9dRWlrFg,11244
+sqlsaber/database/mysql.py,sha256=wMzDQqq4GFbfEdqXtv_sCb4Qbr9GSWqYAvOLeo5UryY,14472
+sqlsaber/database/postgresql.py,sha256=fuf2Wl29NKXvD3mqsR08PDleNQ1PG-fNvWSxT6HDh2M,13223
+sqlsaber/database/resolver.py,sha256=wSCcn__aCqwIfpt_LCjtW2Zgb8RpG5PlmwwZHli1q_U,3628
+sqlsaber/database/schema.py,sha256=CuV0ewoVaERe1gj_fJFJFWAP8aEPgepmn6X6B7bgkfQ,6962
+sqlsaber/database/sqlite.py,sha256=iReEIiSpkhhS1VzITd79ZWqSL3fHMyfe3DRCDpM0DvE,9421
+sqlsaber/memory/__init__.py,sha256=GiWkU6f6YYVV0EvvXDmFWe_CxarmDCql05t70MkTEWs,63
+sqlsaber/memory/manager.py,sha256=p3fybMVfH-E4ApT1ZRZUnQIWSk9dkfUPCyfkmA0HALs,2739
+sqlsaber/memory/storage.py,sha256=ne8szLlGj5NELheqLnI7zu21V8YS4rtpYGGC7tOmi-s,5745
+sqlsaber/theme/__init__.py,sha256=qCICX1Cg4B6yCbZ1UrerxglWxcqldRFVSRrSs73na_8,188
+sqlsaber/theme/manager.py,sha256=TPourIKGU-UzHtImgexgtazpuDaFhqUYtVauMblgGAQ,6480
+sqlsaber/threads/__init__.py,sha256=Hh3dIG1tuC8fXprREUpslCIgPYz8_6o7aRLx4yNeO48,139
+sqlsaber/threads/storage.py,sha256=rsUdxT4CR52D7xtGir9UlsFnBMk11jZeflzDrk2q4ME,11183
+sqlsaber/tools/__init__.py,sha256=O6eqkMk8mkhYDniQD1eYgAElOjiHz03I2bGARdgkDkk,421
+sqlsaber/tools/base.py,sha256=NKEEooliPKTJj_Pomwte_wW0Xd9Z5kXNfVdCRfTppuw,883
+sqlsaber/tools/registry.py,sha256=XmBzERq0LJXtg3BZ-r8cEyt8J54NUekgUlTJ_EdSYMk,2204
+sqlsaber/tools/sql_guard.py,sha256=dTDwcZP-N4xPGzcr7MQtKUxKrlDzlc1irr9aH5a4wvk,6182
+sqlsaber/tools/sql_tools.py,sha256=eo-NTxiXGHMopAjujvDDjmv9hf5bQNbiy3nTpxoJ_E8,7369
+sqlsaber-0.30.0.dist-info/METADATA,sha256=8fYZ1qVQDu-oNhxPSTeLDwewRz1OMy3BK5iTF80nHaQ,5823
+sqlsaber-0.30.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlsaber-0.30.0.dist-info/entry_points.txt,sha256=tw1mB0fjlkXQiOsC0434X6nE-o1cFCuQwt2ZYHv_WAE,91
+sqlsaber-0.30.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sqlsaber-0.30.0.dist-info/RECORD,,

{sqlsaber-0.29.0.dist-info → sqlsaber-0.30.0.dist-info}/entry_points.txt

@@ -1,5 +1,3 @@
 [console_scripts]
 saber = sqlsaber.cli.commands:main
-saber-mcp = sqlsaber.mcp.mcp:main
 sqlsaber = sqlsaber.cli.commands:main
-sqlsaber-mcp = sqlsaber.mcp.mcp:main

sqlsaber/agents/mcp.py

@@ -1,21 +0,0 @@
-"""Generic SQL agent implementation for MCP tools."""
-
-from typing import AsyncIterator
-
-from sqlsaber.agents.base import BaseSQLAgent
-from sqlsaber.database import BaseDatabaseConnection
-
-
-class MCPSQLAgent(BaseSQLAgent):
-    """MCP SQL Agent for MCP tool operations without LLM-specific logic."""
-
-    def __init__(self, db_connection: BaseDatabaseConnection):
-        super().__init__(db_connection)
-
-    async def query_stream(
-        self, user_query: str, use_history: bool = True
-    ) -> AsyncIterator:
-        """Not implemented for generic agent as it's only used for tool operations."""
-        raise NotImplementedError(
-            "MCPSQLAgent does not support query streaming. Use specific agent implementations for conversation."
-        )

sqlsaber/mcp/__init__.py

@@ -1,5 +0,0 @@
-"""MCP (Model Context Protocol) server implementation for SQLSaber."""
-
-from .mcp import mcp
-
-__all__ = ["mcp"]

sqlsaber/mcp/mcp.py

@@ -1,129 +0,0 @@
-"""FastMCP server implementation for SQLSaber."""
-
-import json
-
-from fastmcp import FastMCP
-
-from sqlsaber.agents.mcp import MCPSQLAgent
-from sqlsaber.config.database import DatabaseConfigManager
-from sqlsaber.database import DatabaseConnection
-from sqlsaber.tools import SQLTool, tool_registry
-from sqlsaber.tools.instructions import InstructionBuilder
-
-# Initialize the instruction builder
-instruction_builder = InstructionBuilder(tool_registry)
-
-# Generate dynamic instructions
-DYNAMIC_INSTRUCTIONS = instruction_builder.build_mcp_instructions()
-
-# Create the FastMCP server instance with dynamic instructions
-mcp = FastMCP(name="SQL Assistant", instructions=DYNAMIC_INSTRUCTIONS)
-
-# Initialize the database config manager
-config_manager = DatabaseConfigManager()
-
-
-async def _create_agent_for_database(database_name: str) -> MCPSQLAgent | None:
-    """Create a MCPSQLAgent for the specified database."""
-    try:
-        # Look up configured database connection
-        db_config = config_manager.get_database(database_name)
-        if not db_config:
-            return None
-        connection_string = db_config.to_connection_string()
-
-        # Create database connection
-        db_conn = DatabaseConnection(connection_string)
-
-        # Create and return the agent
-        agent = MCPSQLAgent(db_conn)
-        return agent
-
-    except Exception:
-        return None
-
-
-@mcp.tool
-def get_databases() -> dict:
-    """List all configured databases with their types."""
-    databases = []
-    for db_config in config_manager.list_databases():
-        databases.append(
-            {
-                "name": db_config.name,
-                "type": db_config.type,
-                "database": db_config.database,
-                "host": db_config.host,
-                "port": db_config.port,
-                "is_default": db_config.name == config_manager.get_default_name(),
-            }
-        )
-
-    return {"databases": databases, "count": len(databases)}
-
-
-async def _execute_with_connection(tool_name: str, database: str, **kwargs) -> str:
-    """Execute a SQL tool with database connection management.
-
-    Args:
-        tool_name: Name of the tool to execute
-        database: Database name to connect to
-        **kwargs: Tool-specific parameters
-
-    Returns:
-        JSON string with the tool's output
-    """
-    try:
-        agent = await _create_agent_for_database(database)
-        if not agent:
-            return json.dumps(
-                {"error": f"Database '{database}' not found or could not connect"}
-            )
-
-        # Get the tool and set up connection
-        tool = tool_registry.get_tool(tool_name)
-        if isinstance(tool, SQLTool):
-            tool.set_connection(agent.db)
-
-        # Execute the tool
-        result = await tool.execute(**kwargs)
-        await agent.db.close()
-        return result
-
-    except Exception as e:
-        return json.dumps({"error": f"Error in {tool_name}: {str(e)}"})
-
-
-# SQL Tool Wrappers with explicit signatures
-
-
-@mcp.tool
-async def list_tables(database: str) -> str:
-    """Get a list of all tables in the database with row counts. Use this first to discover available tables."""
-    return await _execute_with_connection("list_tables", database)
-
-
-@mcp.tool
-async def introspect_schema(database: str, table_pattern: str = None) -> str:
-    """Introspect database schema to understand table structures."""
-    kwargs = {}
-    if table_pattern is not None:
-        kwargs["table_pattern"] = table_pattern
-    return await _execute_with_connection("introspect_schema", database, **kwargs)
-
-
-@mcp.tool
-async def execute_sql(database: str, query: str, limit: int = 100) -> str:
-    """Execute a SQL query against the database."""
-    return await _execute_with_connection(
-        "execute_sql", database, query=query, limit=limit
-    )
-
-
-def main():
-    """Entry point for the MCP server console script."""
-    mcp.run()
-
-
-if __name__ == "__main__":
-    main()

sqlsaber/tools/enums.py

@@ -1,19 +0,0 @@
-"""Enums for tool categories and workflow positions."""
-
-from enum import Enum
-
-
-class ToolCategory(Enum):
-    """Tool categories for organizing and filtering tools."""
-
-    GENERAL = "general"
-    SQL = "sql"
-
-
-class WorkflowPosition(Enum):
-    """Workflow positions for organizing tools by usage order."""
-
-    DISCOVERY = "discovery"
-    ANALYSIS = "analysis"
-    EXECUTION = "execution"
-    OTHER = "other"

sqlsaber/tools/instructions.py

@@ -1,231 +0,0 @@
-"""Dynamic instruction builder for tools."""
-
-from .base import Tool
-from .enums import ToolCategory, WorkflowPosition
-from .registry import ToolRegistry
-
-
-class InstructionBuilder:
-    """Builds dynamic instructions based on available tools."""
-
-    def __init__(self, tool_registry: ToolRegistry):
-        """Initialize with a tool registry."""
-        self.registry = tool_registry
-
-    def build_instructions(
-        self,
-        db_type: str = "database",
-        category: str | ToolCategory | None = None,
-        include_base_instructions: bool = True,
-    ) -> str:
-        """Build dynamic instructions from available tools.
-
-        Args:
-            db_type: Type of database (PostgreSQL, MySQL, SQLite, etc.)
-            category: Optional category to filter tools by (string or ToolCategory enum)
-            include_base_instructions: Whether to include base SQL assistant instructions
-
-        Returns:
-            Complete instruction string for LLM
-        """
-        # Get available tools
-        tools = self.registry.get_all_tools(category)
-
-        if not tools:
-            return self._get_base_instructions(db_type)
-
-        # Sort tools by priority and workflow position
-        sorted_tools = self._sort_tools_by_workflow(tools)
-
-        # Build instruction components
-        instructions_parts = []
-
-        if include_base_instructions:
-            instructions_parts.append(self._get_base_instructions(db_type))
-
-        # Add tool-specific workflow guidance
-        workflow_instructions = self._build_workflow_instructions(sorted_tools)
-        if workflow_instructions:
-            instructions_parts.append(workflow_instructions)
-
-        # Add tool descriptions and guidelines
-        tool_guidelines = self._build_tool_guidelines(sorted_tools)
-        if tool_guidelines:
-            instructions_parts.append(tool_guidelines)
-
-        # Add general guidelines
-        general_guidelines = self._build_general_guidelines(sorted_tools)
-        if general_guidelines:
-            instructions_parts.append(general_guidelines)
-
-        return "\n\n".join(instructions_parts)
-
-    def _get_base_instructions(self, db_type: str) -> str:
-        """Get base SQL assistant instructions."""
-        return f"""You are also a helpful SQL assistant that helps users query their {db_type} database.
-
-Your responsibilities:
-1. Understand user's natural language requests, think and convert them to SQL
-2. Use the provided tools efficiently to explore database schema
-3. Generate appropriate SQL queries
-4. Execute queries safely - queries that modify the database are not allowed
-5. Format and explain results clearly"""
-
-    def _sort_tools_by_workflow(self, tools: list[Tool]) -> list[Tool]:
-        """Sort tools by priority and workflow position."""
-        # Define workflow position ordering
-        position_order = {
-            WorkflowPosition.DISCOVERY: 1,
-            WorkflowPosition.ANALYSIS: 2,
-            WorkflowPosition.EXECUTION: 3,
-            WorkflowPosition.OTHER: 4,
-        }
-
-        return sorted(
-            tools,
-            key=lambda tool: (
-                position_order.get(tool.get_workflow_position(), 4),
-                tool.get_priority(),
-                tool.name,
-            ),
-        )
-
-    def _build_workflow_instructions(self, sorted_tools: list[Tool]) -> str:
-        """Build workflow-based instructions."""
-        # Group tools by workflow position
-        workflow_groups = {}
-        for tool in sorted_tools:
-            position = tool.get_workflow_position()
-            if position not in workflow_groups:
-                workflow_groups[position] = []
-            workflow_groups[position].append(tool)
-
-        # Build workflow instructions
-        instructions = ["IMPORTANT - Tool Usage Strategy:"]
-        step = 1
-
-        # Add discovery tools first
-        if WorkflowPosition.DISCOVERY in workflow_groups:
-            discovery_tools = workflow_groups[WorkflowPosition.DISCOVERY]
-            for tool in discovery_tools:
-                usage = tool.get_usage_instructions()
-                if usage:
-                    instructions.append(f"{step}. {usage}")
-                else:
-                    instructions.append(
-                        f"{step}. Use '{tool.name}' to {tool.description.lower()}"
-                    )
-                step += 1
-
-        # Add analysis tools
-        if WorkflowPosition.ANALYSIS in workflow_groups:
-            analysis_tools = workflow_groups[WorkflowPosition.ANALYSIS]
-            for tool in analysis_tools:
-                usage = tool.get_usage_instructions()
-                if usage:
-                    instructions.append(f"{step}. {usage}")
-                else:
-                    instructions.append(
-                        f"{step}. Use '{tool.name}' to {tool.description.lower()}"
-                    )
-                step += 1
-
-        # Add execution tools
-        if WorkflowPosition.EXECUTION in workflow_groups:
-            execution_tools = workflow_groups[WorkflowPosition.EXECUTION]
-            for tool in execution_tools:
-                usage = tool.get_usage_instructions()
-                if usage:
-                    instructions.append(f"{step}. {usage}")
-                else:
-                    instructions.append(
-                        f"{step}. Use '{tool.name}' to {tool.description.lower()}"
-                    )
-                step += 1
-
-        return "\n".join(instructions) if len(instructions) > 1 else ""
-
-    def _build_tool_guidelines(self, sorted_tools: list[Tool]) -> str:
-        """Build tool-specific guidelines."""
-        guidelines = []
-
-        for tool in sorted_tools:
-            usage = tool.get_usage_instructions()
-            if usage and not self._is_usage_in_workflow(usage):
-                guidelines.append(f"- {tool.name}: {usage}")
-
-        if guidelines:
-            return "Tool-Specific Guidelines:\n" + "\n".join(guidelines)
-        return ""
-
-    def _build_general_guidelines(self, sorted_tools: list[Tool]) -> str:
-        """Build general usage guidelines."""
-        guidelines = [
-            "Guidelines:",
-            "- Use proper JOIN syntax and avoid cartesian products",
-            "- Include appropriate WHERE clauses to limit results",
-            "- Explain what the query does in simple terms",
-            "- Handle errors gracefully and suggest fixes",
-            "- Be security conscious - use parameterized queries when needed",
-        ]
-
-        # Add category-specific guidelines
-        categories = {tool.category for tool in sorted_tools}
-
-        if ToolCategory.SQL in categories:
-            guidelines.extend(
-                [
-                    "- Timestamp columns must be converted to text when you write queries",
-                    "- Use table patterns like 'sample%' or '%experiment%' to filter related tables",
-                ]
-            )
-
-        return "\n".join(guidelines)
-
-    def _is_usage_in_workflow(self, usage: str) -> bool:
-        """Check if usage instruction is already covered in workflow section."""
-        # Simple heuristic - if usage starts with workflow words, it's probably in workflow
-        workflow_words = ["always start", "first", "use this", "begin with", "start by"]
-        usage_lower = usage.lower()
-        return any(word in usage_lower for word in workflow_words)
-
-    def build_mcp_instructions(self) -> str:
-        """Build instructions specifically for MCP server."""
-        instructions = [
-            "This server provides helpful resources and tools that will help you address users queries on their database.",
-            "",
-        ]
-
-        # Add database discovery
-        instructions.append("- Get all databases using `get_databases()`")
-
-        # Add tool-specific instructions
-        sql_tools = self.registry.get_all_tools(category=ToolCategory.SQL)
-        sorted_tools = self._sort_tools_by_workflow(sql_tools)
-
-        for tool in sorted_tools:
-            instructions.append(f"- Call `{tool.name}()` to {tool.description.lower()}")
-
-        # Add workflow guidelines
-        instructions.extend(["", "Guidelines:"])
-
-        workflow_instructions = self._build_workflow_instructions(sorted_tools)
-        if workflow_instructions:
-            # Extract just the numbered steps without the "IMPORTANT" header
-            lines = workflow_instructions.split("\n")[1:]  # Skip header
-            for line in lines:
-                if line.strip():
-                    # Convert numbered steps to bullet points
-                    if line.strip()[0].isdigit():
-                        instructions.append(f"- {line.strip()[3:]}")  # Remove "X. "
-
-        # Add general guidelines
-        instructions.extend(
-            [
-                "- Use proper JOIN syntax and avoid cartesian products",
-                "- Include appropriate WHERE clauses to limit results",
-                "- Handle errors gracefully and suggest fixes",
-            ]
-        )
-
-        return "\n".join(instructions)