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

sqlsaber/agents/base.py

@@ -61,7 +61,7 @@ class BaseSQLAgent(ABC):
     def _init_tools(self) -> None:
         """Initialize SQL tools with database connection."""
         # Get all SQL tools and set their database connection
-        for tool_name in tool_registry.list_tools(category="sql"):
+        for tool_name in tool_registry.list_tools():
             tool = tool_registry.get_tool(tool_name)
             if isinstance(tool, SQLTool):
                 tool.set_connection(self.db)

sqlsaber/agents/pydantic_ai_agent.py

@@ -24,7 +24,6 @@ from sqlsaber.database import (
     SQLiteConnection,
 )
 from sqlsaber.memory.manager import MemoryManager
-from sqlsaber.tools.instructions import InstructionBuilder
 from sqlsaber.tools.registry import tool_registry
 from sqlsaber.tools.sql_tools import SQLTool
 
@@ -43,7 +42,6 @@ class SQLSaberAgent:
         self.database_name = database_name
         self.config = Config()
         self.memory_manager = memory_manager or MemoryManager()
-        self.instruction_builder = InstructionBuilder(tool_registry)
         self.db_type = self._get_database_type_name()
 
         # Thinking configuration (CLI override or config default)
@@ -61,7 +59,7 @@ class SQLSaberAgent:
 
     def _configure_sql_tools(self) -> None:
         """Ensure SQL tools receive the active database connection."""
-        for tool_name in tool_registry.list_tools(category="sql"):
+        for tool_name in tool_registry.list_tools():
             tool = tool_registry.get_tool(tool_name)
             if isinstance(tool, SQLTool):
                 tool.set_connection(self.db_connection)
@@ -165,30 +163,54 @@ class SQLSaberAgent:
         return Agent(model_obj, name="sqlsaber")
 
     def _setup_system_prompt(self, agent: Agent) -> None:
-        """Set up the dynamic system prompt for the agent."""
+        """Configure the agent's system prompt using a simple prompt string."""
         if not self.is_oauth:
 
             @agent.system_prompt(dynamic=True)
             async def sqlsaber_system_prompt(ctx: RunContext) -> str:
-                instructions = self.instruction_builder.build_instructions(
-                    db_type=self.db_type
-                )
-
-                # Add memory context if available
-                mem = ""
-                if self.database_name:
-                    mem = self.memory_manager.format_memories_for_prompt(
-                        self.database_name
-                    )
-
-                parts = [p for p in (instructions, mem) if p and p.strip()]
-                return "\n\n".join(parts) if parts else ""
+                return self.system_prompt_text(include_memory=True)
         else:
 
             @agent.system_prompt(dynamic=True)
             async def sqlsaber_system_prompt(ctx: RunContext) -> str:
+                # OAuth clients (Claude Code) ignore custom system prompts; we inject later.
                 return "You are Claude Code, Anthropic's official CLI for Claude."
 
+    def system_prompt_text(self, include_memory: bool = True) -> str:
+        """Return the original SQLSaber system prompt as a single string."""
+        db = self.db_type
+        base = (
+            f"You are a helpful SQL assistant that helps users query their {db} database.\n\n"
+            "Your responsibilities:\n"
+            "1. Understand user's natural language requests, think and convert them to SQL\n"
+            "2. Use the provided tools efficiently to explore database schema\n"
+            "3. Generate appropriate SQL queries\n"
+            "4. Execute queries safely - queries that modify the database are not allowed\n"
+            "5. Format and explain results clearly\n\n"
+            "IMPORTANT - Tool Usage Strategy:\n"
+            "1. ALWAYS start with 'list_tables' to see available tables and row counts. Use this first to discover available tables.\n"
+            "2. 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.\n"
+            "3. Execute SQL queries safely with automatic LIMIT clauses for SELECT statements. Only SELECT queries are permitted for security.\n\n"
+            "Tool-Specific Guidelines:\n"
+            "- introspect_schema: 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.\n"
+            "- execute_sql: Execute SQL queries safely with automatic LIMIT clauses for SELECT statements. Only SELECT queries are permitted for security.\n\n"
+            "Guidelines:\n"
+            "- Use proper JOIN syntax and avoid cartesian products\n"
+            "- Include appropriate WHERE clauses to limit results\n"
+            "- Explain what the query does in simple terms\n"
+            "- Handle errors gracefully and suggest fixes\n"
+            "- Be security conscious - use parameterized queries when needed\n"
+            "- Timestamp columns must be converted to text when you write queries\n"
+            "- Use table patterns like 'sample%' or '%experiment%' to filter related tables"
+        )
+
+        if include_memory and self.database_name:
+            mem = self.memory_manager.format_memories_for_prompt(self.database_name)
+            mem = mem.strip()
+            if mem:
+                return f"{base}\n\n{mem}"
+        return base
+
     def _register_tools(self, agent: Agent) -> None:
         """Register all the SQL tools with the agent."""
 

sqlsaber/cli/models.py

@@ -152,7 +152,7 @@ def list():
         table.add_column("Name", style="success")
         table.add_column("Description", style="info")
         table.add_column("Context", style="warning", justify="right")
-        table.add_column("Current", style="bold accent", justify="center")
+        table.add_column("Current", style="accent", justify="center")
 
         current_model = model_manager.get_current_model()
 

sqlsaber/cli/streaming.py

@@ -144,17 +144,8 @@ class StreamingQueryHandler:
             prepared_prompt: str | list[str] = user_query
             no_history = not message_history
             if sqlsaber_agent.is_oauth and no_history:
-                instructions = sqlsaber_agent.instruction_builder.build_instructions(
-                    db_type=sqlsaber_agent.db_type
-                )
-                mem = ""
-                if sqlsaber_agent.database_name:
-                    mem = sqlsaber_agent.memory_manager.format_memories_for_prompt(
-                        sqlsaber_agent.database_name
-                    )
-                parts = [p for p in (instructions, mem) if p and str(p).strip()]
-                if parts:
-                    injected = "\n\n".join(parts)
+                injected = sqlsaber_agent.system_prompt_text(include_memory=True)
+                if injected and str(injected).strip():
                     prepared_prompt = [injected, user_query]
 
             # Show a transient status until events start streaming

sqlsaber/theme/manager.py

@@ -9,7 +9,7 @@ from typing import Dict
 from platformdirs import user_config_dir
 from prompt_toolkit.styles import Style as PTStyle
 from prompt_toolkit.styles.pygments import style_from_pygments_cls
-from pygments.styles import get_style_by_name
+from pygments.styles import get_all_styles, get_style_by_name
 from pygments.token import Token
 from pygments.util import ClassNotFound
 from rich.console import Console
@@ -200,6 +200,9 @@ def get_theme_manager() -> ThemeManager:
     user_cfg = _load_user_theme_config()
     env_name = os.getenv("SQLSABER_THEME")
 
+    if env_name and env_name.lower() not in get_all_styles():
+        env_name = None
+
     name = (
         env_name or user_cfg.get("theme", {}).get("name") or DEFAULT_THEME_NAME
     ).lower()

sqlsaber/tools/__init__.py

@@ -1,8 +1,6 @@
 """SQLSaber tools module."""
 
 from .base import Tool
-from .enums import ToolCategory, WorkflowPosition
-from .instructions import InstructionBuilder
 from .registry import ToolRegistry, register_tool, tool_registry
 
 # Import concrete tools to register them
@@ -10,12 +8,9 @@ from .sql_tools import ExecuteSQLTool, IntrospectSchemaTool, ListTablesTool, SQL
 
 __all__ = [
     "Tool",
-    "ToolCategory",
-    "WorkflowPosition",
     "ToolRegistry",
     "tool_registry",
     "register_tool",
-    "InstructionBuilder",
     "SQLTool",
     "ListTablesTool",
     "IntrospectSchemaTool",

sqlsaber/tools/base.py

@@ -3,8 +3,6 @@
 from abc import ABC, abstractmethod
 from typing import Any
 
-from .enums import ToolCategory, WorkflowPosition
-
 
 class Tool(ABC):
     """Abstract base class for all tools."""
@@ -42,32 +40,3 @@ class Tool(ABC):
             JSON string with the tool's output
         """
         pass
-
-    @property
-    def category(self) -> ToolCategory:
-        """Return the tool category. Override to customize."""
-        return ToolCategory.GENERAL
-
-    def get_usage_instructions(self) -> str | None:
-        """Return tool-specific usage instructions for LLM guidance.
-
-        Returns:
-            Usage instructions string, or None for no specific guidance
-        """
-        return None
-
-    def get_priority(self) -> int:
-        """Return priority for tool ordering in instructions.
-
-        Returns:
-            Priority number (lower = higher priority, default = 100)
-        """
-        return 100
-
-    def get_workflow_position(self) -> WorkflowPosition:
-        """Return the typical workflow position for this tool.
-
-        Returns:
-            WorkflowPosition enum value
-        """
-        return WorkflowPosition.OTHER

sqlsaber/tools/registry.py

@@ -3,7 +3,6 @@
 from typing import Type
 
 from .base import Tool
-from .enums import ToolCategory
 
 
 class ToolRegistry:
@@ -61,45 +60,13 @@ class ToolRegistry:
 
         return self._instances[name]
 
-    def list_tools(self, category: str | ToolCategory | None = None) -> list[str]:
-        """List all registered tool names.
+    def list_tools(self) -> list[str]:
+        """List all registered tool names."""
+        return list(self._tools.keys())
 
-        Args:
-            category: Optional category to filter by (string or ToolCategory enum)
-
-        Returns:
-            List of tool names
-        """
-        if category is None:
-            return list(self._tools.keys())
-
-        # Convert string to enum
-        if isinstance(category, str):
-            try:
-                category = ToolCategory(category)
-            except ValueError:
-                # If string doesn't match any enum, return empty list
-                return []
-
-        # Filter by category
-        result = []
-        for name, tool_class in self._tools.items():
-            tool = self.get_tool(name)
-            if tool.category == category:
-                result.append(name)
-        return result
-
-    def get_all_tools(self, category: str | ToolCategory | None = None) -> list[Tool]:
-        """Get all tool instances.
-
-        Args:
-            category: Optional category to filter by (string or ToolCategory enum)
-
-        Returns:
-            List of tool instances
-        """
-        names = self.list_tools(category)
-        return [self.get_tool(name) for name in names]
+    def get_all_tools(self) -> list[Tool]:
+        """Get all tool instances."""
+        return [self.get_tool(name) for name in self.list_tools()]
 
 
 # Global registry instance

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.1.dist-info → sqlsaber-0.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlsaber
-Version: 0.29.1
+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.29.1.dist-info → sqlsaber-0.30.0.dist-info}/RECORD

@@ -1,9 +1,8 @@
 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=40-MKEoz5rGrqVIylV1U2DaAUSPFcC75ohRin4E3-kk,2668
-sqlsaber/agents/mcp.py,sha256=Pn8tdDRUEVLYQyEi5nHRp9MKNePwHVVoeNI-uqWcr0Y,757
-sqlsaber/agents/pydantic_ai_agent.py,sha256=wBxKz0pjOkL-HI-TXV6B67bczZNgu7k26Rr3w5usR3o,10064
+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
@@ -17,9 +16,9 @@ sqlsaber/cli/database.py,sha256=Tqy8H5MnjsrmOSPcbA5Qy-u-IOYJCIXRJVhk0veLNDk,1072
 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=iMTw3DCKIQbWfSfikwy-nQ5tiHWjoN4cbKA-G6RFlj4,8535
+sqlsaber/cli/models.py,sha256=nbn75gCnkRciGt4Q47yxa8wImiZcCkDdQZNVeehDim8,8530
 sqlsaber/cli/onboarding.py,sha256=iBGT-W-OJFRvQoEpuHYyO1c9Mym5c97eIefRvxGHtTg,11265
-sqlsaber/cli/streaming.py,sha256=1XoZGPPMoTmBQVgp_Bqk483MR93j9oXxSV6Tx_-TpOg,6923
+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
@@ -39,24 +38,20 @@ sqlsaber/database/postgresql.py,sha256=fuf2Wl29NKXvD3mqsR08PDleNQ1PG-fNvWSxT6HDh
 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/mcp/__init__.py,sha256=COdWq7wauPBp5Ew8tfZItFzbcLDSEkHBJSMhxzy8C9c,112
-sqlsaber/mcp/mcp.py,sha256=tpNPHpkaCre1Xjp7c4DHXbTKeuYpDQ8qhmJZvAyr7Vk,3939
 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=xOi1ZLNr31ZtE8-WzxdtvywCB1rbJ7z2DTzcqHsCavY,6377
+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=x3YdmX_7P0Qq_HtZHAgfIVKTLxYqKk6oc4tGsujQWsc,586
-sqlsaber/tools/base.py,sha256=mHhvAj27BHmckyvuDLCPlAQdzABJyYxd9SJnaYAwwuA,1777
-sqlsaber/tools/enums.py,sha256=CH32mL-0k9ZA18911xLpNtsgpV6tB85TktMj6uqGz54,411
-sqlsaber/tools/instructions.py,sha256=X-x8maVkkyi16b6Tl0hcAFgjiYceZaSwyWTfmrvx8U8,9024
-sqlsaber/tools/registry.py,sha256=HWOQMsNIdL4XZS6TeNUyrL-5KoSDH6PHsWd3X66o-18,3211
+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=ujmAcfLkNaBrb5LWEgWcINQEQSX0LRPX3VK5Dag1Sj4,9178
-sqlsaber-0.29.1.dist-info/METADATA,sha256=kx_nQDGhcDUJp4DadT7Pi89QsUuf8S5W6IVqwaJfuXM,7174
-sqlsaber-0.29.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlsaber-0.29.1.dist-info/entry_points.txt,sha256=qEbOB7OffXPFgyJc7qEIJlMEX5RN9xdzLmWZa91zCQQ,162
-sqlsaber-0.29.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sqlsaber-0.29.1.dist-info/RECORD,,
+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.1.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)