mcp-server-motherduck 0.2.2__tar.gz → 0.3.1__tar.gz

mcp_server_motherduck-0.3.1/.github/workflows/python-publish.yml

@@ -0,0 +1,33 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  
+jobs:
+  pypi-publish:
+    name: python
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: "Set up Python"
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Install the project
+        run: uv sync
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish package
+        run: uv publish

mcp_server_motherduck-0.3.1/.gitignore

@@ -0,0 +1,176 @@
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

{mcp_server_motherduck-0.2.2 → mcp_server_motherduck-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-server-motherduck
-Version: 0.2.2
+Version: 0.3.1
 Summary: A MCP server for MotherDuck and local DuckDB
 Author-email: tdoehmen <till@motherduck.com>
 License-File: LICENSE
@@ -11,30 +11,28 @@ Description-Content-Type: text/markdown
 
 # mcp-server-motherduck MCP server
 
-A MCP server for MotherDuck and local DuckDB 
+An [MCP server](https://modelcontextprotocol.io/introduction) for MotherDuck and local DuckDB.
 
 ## Components
 
-### Resources
-
 ### Prompts
 
 The server provides one prompt:
-- duckdb-motherduck-initial-prompt: A prompt to initialize a connection to duckdb or motherduck and start working with it
+
+- duckdb-motherduck-prompt: A prompt to initialize a connection to duckdb or motherduck and start working with it
 
 ### Tools
 
-The server offers three tools:
-- initialize-connection: Create a connection to either a local DuckDB or MotherDuck and retrieve available databases
-  - Takes "type" (DuckDB or MotherDuck) as input
-- read-schemas: Get table schemas from a specific DuckDB/MotherDuck database
-  - Takes "database_name" as required string arguments
-- execute-query: Execute a query on the MotherDuck (DuckDB) database
+The server offers one tool:
+
+- query: Execute a query on the MotherDuck (DuckDB) database
   - Takes "query" as required string arguments
 
+This is because all the interactions with both the DuckDB and MotherDuck are done through writing SQL queries.
+
 ## Usage with Claude Desktop
 
-Add the snippet below to your Claude Desktop config and make sure to set the HOME var to your home folder (needed by DuckDB). 
+Add the snippet below to your Claude Desktop config and make sure to set the HOME var to your home folder (needed by DuckDB).
 
 When using MotherDuck, you also need to set a [MotherDuck token](https://motherduck.com/docs/key-tasks/authenticating-and-connecting-to-motherduck/authenticating-to-motherduck/#storing-the-access-token-as-an-environment-variable) env var.
 
@@ -43,6 +41,7 @@ On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
 On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
 
 ### Servers Configuration
+
 ```
 "mcpServers": {
   "mcp-server-motherduck": {
@@ -51,8 +50,8 @@ On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
       "mcp-server-motherduck"
     ],
     "env": {
-      "motherduck_token": "",
-      "HOME": ""
+      "motherduck_token": "<your-motherduck-token>",
+      "HOME": "<your-home-folder-for-project-files>"
     }
   }
 }
@@ -61,4 +60,3 @@ On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
 ## License
 
 This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
-

{mcp_server_motherduck-0.2.2 → mcp_server_motherduck-0.3.1}/README.md

@@ -1,29 +1,27 @@
 # mcp-server-motherduck MCP server
 
-A MCP server for MotherDuck and local DuckDB 
+An [MCP server](https://modelcontextprotocol.io/introduction) for MotherDuck and local DuckDB.
 
 ## Components
 
-### Resources
-
 ### Prompts
 
 The server provides one prompt:
-- duckdb-motherduck-initial-prompt: A prompt to initialize a connection to duckdb or motherduck and start working with it
+
+- duckdb-motherduck-prompt: A prompt to initialize a connection to duckdb or motherduck and start working with it
 
 ### Tools
 
-The server offers three tools:
-- initialize-connection: Create a connection to either a local DuckDB or MotherDuck and retrieve available databases
-  - Takes "type" (DuckDB or MotherDuck) as input
-- read-schemas: Get table schemas from a specific DuckDB/MotherDuck database
-  - Takes "database_name" as required string arguments
-- execute-query: Execute a query on the MotherDuck (DuckDB) database
+The server offers one tool:
+
+- query: Execute a query on the MotherDuck (DuckDB) database
   - Takes "query" as required string arguments
 
+This is because all the interactions with both the DuckDB and MotherDuck are done through writing SQL queries.
+
 ## Usage with Claude Desktop
 
-Add the snippet below to your Claude Desktop config and make sure to set the HOME var to your home folder (needed by DuckDB). 
+Add the snippet below to your Claude Desktop config and make sure to set the HOME var to your home folder (needed by DuckDB).
 
 When using MotherDuck, you also need to set a [MotherDuck token](https://motherduck.com/docs/key-tasks/authenticating-and-connecting-to-motherduck/authenticating-to-motherduck/#storing-the-access-token-as-an-environment-variable) env var.
 
@@ -32,6 +30,7 @@ On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
 On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
 
 ### Servers Configuration
+
 ```
 "mcpServers": {
   "mcp-server-motherduck": {
@@ -40,8 +39,8 @@ On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
       "mcp-server-motherduck"
     ],
     "env": {
-      "motherduck_token": "",
-      "HOME": ""
+      "motherduck_token": "<your-motherduck-token>",
+      "HOME": "<your-home-folder-for-project-files>"
     }
   }
 }
@@ -50,4 +49,3 @@ On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
 ## License
 
 This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.
-

mcp_server_motherduck-0.3.1/makefile

@@ -0,0 +1,6 @@
+.ONESHELL:
+
+.PHONY: publish
+
+publish:
+	uv publish --token $(PYPI_KEY)

{mcp_server_motherduck-0.2.2 → mcp_server_motherduck-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-server-motherduck"
-version = "0.2.2"
+version = "0.3.1"
 description = "A MCP server for MotherDuck and local DuckDB"
 readme = "README.md"
 requires-python = ">=3.10"

mcp_server_motherduck-0.3.1/src/mcp_server_motherduck/__init__.py

@@ -0,0 +1,19 @@
+from . import server
+import asyncio
+import argparse
+
+
+def main():
+    """Main entry point for the package."""
+    parser = argparse.ArgumentParser(description="MotherDuck MCP Server")
+    parser.add_argument(
+        "--db-path",
+        help="Path to local DuckDB database file",
+    )
+
+    args = parser.parse_args()
+    asyncio.run(server.main(db_path=args.db_path))
+
+
+# Optionally expose other important items at package level
+__all__ = ["main", "server"]

mcp_server_motherduck-0.3.1/src/mcp_server_motherduck/__main__.py

@@ -0,0 +1,19 @@
+from . import server
+import asyncio
+import argparse
+
+
+def main():
+    """Main entry point for the package."""
+    parser = argparse.ArgumentParser(description="MotherDuck MCP Server")
+    parser.add_argument(
+        "--db-path",
+        help="Path to local DuckDB database file",
+    )
+
+    args = parser.parse_args()
+    asyncio.run(server.main(db_path=args.db_path))
+
+
+if __name__ == "__main__":
+    main()

mcp_server_motherduck-0.2.2/src/mcp_server_motherduck/server.py → mcp_server_motherduck-0.3.1/src/mcp_server_motherduck/prompt.py

@@ -1,33 +1,20 @@
-import asyncio
-
-from mcp.server.models import InitializationOptions
-import mcp.types as types
-from mcp.server import NotificationOptions, Server
-from pydantic import AnyUrl
-import mcp.server.stdio
-import os
-import duckdb
-
-SERVER_VERSION = "0.2.2"
-
-PROMPT_TEMPLATE = """The assistant's goal is to help users interact with DuckDB/MotherDuck databases effectively. 
+PROMPT_TEMPLATE = """The assistant's goal is to help users interact with DuckDB or MotherDuck databases effectively. 
 Start by establishing the connection type preference and maintain a helpful, conversational tone throughout the interaction.
+
 <mcp>
 Tools:
-- "initialize-connection": Creates connection to DuckDB or MotherDuck
-- "read-schemas": Retrieves table schemas from specified database
-- "execute-query": Runs SQL queries and returns results
+- "query": Runs SQL queries and returns results
 </mcp>
 
 <workflow>
 1. Connection Setup:
    - Ask whether user prefers MotherDuck or local DuckDB
-   - Use initialize-connection with chosen type
+   - Use query with the chosen type
    - Store and display available databases if successful
 
 2. Database Exploration:
    - When user mentions data analysis needs, identify target database
-   - Use read-schemas to fetch table information
+   - Use query to fetch table information
    - Present schema details in user-friendly format
 
 3. Query Execution:
@@ -50,7 +37,7 @@ Tools:
 </workflow>
 
 <conversation-flow>
-1. Start with: "Hi! Would you prefer to connect to MotherDuck or use a local DuckDB instance?"
+1. Start with: "Hi! What query would you like to run on your database?"
 
 2. After connection:
    - Acknowledge success/failure
@@ -206,164 +193,3 @@ Common DuckDB Keywords:
 `ALL`: The `ALL` keyword in SQL specifies that operations should retain all duplicate rows, as seen in commands like `UNION ALL`, `INTERSECT ALL`, and `EXCEPT ALL`, which follow bag semantics instead of eliminating duplicates., Examples: ['UNION ALL\n\n```sql\nSELECT * FROM range(2) t1(x)\nUNION ALL\nSELECT * FROM range(3) t2(x);\n```\nThis example demonstrates using `UNION ALL` to combine rows from two queries without eliminating duplicates.', 'INTERSECT ALL\n\n```sql\nSELECT unnest([5, 5, 6, 6, 6, 6, 7, 8]) AS x\nINTERSECT ALL\nSELECT unnest([5, 6, 6, 7, 7, 9]);\n```\nThis example shows using `INTERSECT ALL` to select rows that are present in both result sets, keeping duplicate values.', 'EXCEPT ALL\n\n```sql\nSELECT unnest([5, 5, 6, 6, 6, 6, 7, 8]) AS x\nEXCEPT ALL\nSELECT unnest([5, 6, 6, 7, 7, 9]);\n```\nThis example illustrates `EXCEPT ALL`, which selects all rows present in the first query but not in the second, without removing duplicates.', 'ORDER BY ALL\n\n```sql\nSELECT *\nFROM addresses\nORDER BY ALL;\n```\nThis SQL command uses `ORDER BY ALL` to sort the result set by all columns sequentially from left to right.']
 `LIKE`: The `LIKE` expression is used to determine if a string matches a specified pattern, allowing wildcard characters such as `_` to represent any single character and `%` to match any sequence of characters., Examples: ["SELECT 'abc' LIKE 'abc'; -- true", "SELECT 'abc' LIKE 'a%'; -- true", "SELECT 'abc' LIKE '_b_'; -- true", "SELECT 'abc' LIKE 'c'; -- false", "SELECT 'abc' LIKE 'c%'; -- false", "SELECT 'abc' LIKE '%c'; -- true", "SELECT 'abc' NOT LIKE '%c'; -- false", "SELECT 'abc' ILIKE '%C'; -- true"]
 """
-
-server = Server("mcp-server-motherduck")
-
-conn = duckdb.connect()
-
-@server.list_resources()
-async def handle_list_resources() -> list[types.Resource]:
-    """
-    List available note resources.
-    Each note is exposed as a resource with a custom note:// URI scheme.
-    """
-    return []
-
-@server.read_resource()
-async def handle_read_resource(uri: AnyUrl) -> str:
-    """
-    Read a specific note's content by its URI.
-    The note name is extracted from the URI host component.
-    """
-    raise ValueError(f"Unsupported URI scheme: {uri.scheme}")
-
-@server.list_prompts()
-async def handle_list_prompts() -> list[types.Prompt]:
-    """
-    List available prompts.
-    Each prompt can have optional arguments to customize its behavior.
-    """
-    return [
-        types.Prompt(
-            name="duckdb-motherduck-initial-prompt",
-            description="A prompt to initialize a connection to duckdb or motherduck and start working with it",
-        )
-    ]
-
-@server.get_prompt()
-async def handle_get_prompt(
-        name: str, arguments: dict[str, str] | None
-) -> types.GetPromptResult:
-    """
-    Generate a prompt by combining arguments with server state.
-    The prompt includes all current notes and can be customized via arguments.
-    """
-    if name != "duckdb-motherduck-initial-prompt":
-        raise ValueError(f"Unknown prompt: {name}")
-
-    return types.GetPromptResult(
-        description=f"Initial prompt for interacting with DuckDB/MotherDuck",
-        messages=[
-            types.PromptMessage(
-                role="user",
-                content=types.TextContent(type="text", text=PROMPT_TEMPLATE),
-            )
-        ],
-    )
-
-@server.list_tools()
-async def handle_list_tools() -> list[types.Tool]:
-    """
-    List available tools.
-    Each tool specifies its arguments using JSON Schema validation.
-    """
-    return [
-        types.Tool(
-            name="initialize-connection",
-            description="Create a connection to either a local DuckDB or MotherDuck and retrieve available databases",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "type": {"type": "string", "description": "Type of the database, either 'DuckDB' or 'MotherDuck'"},
-                },
-                "required": ["type"],
-            },
-        ),
-        types.Tool(
-            name="read-schemas",
-            description="Get table schemas from a specific DuckDB/MotherDuck database",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "type": {"database_name": "string", "description": "name of the database"},
-                },
-                "required": ["database_name"],
-            },
-        ),
-        types.Tool(
-            name="execute-query",
-            description="Execute a query on the MotherDuck (DuckDB) database",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "query": {"type": "string", "description": "SQL query to execute"},
-                },
-                "required": ["query"],
-            },
-        )
-    ]
-
-@server.call_tool()
-async def handle_call_tool(
-        name: str, arguments: dict | None
-) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
-    """
-    Handle tool execution requests.
-    Tools can modify server state and notify clients of changes.
-    """
-    global conn
-    if name == "initialize-connection":
-        type = arguments["type"].strip().upper()
-        if not type in ['DUCKDB', 'MOTHERDUCK']:
-            raise ValueError("Only 'DuckDB' or 'MotherDuck' are supported")
-        if type == 'MOTHERDUCK' and not os.getenv('motherduck_token'):
-            raise ValueError("Please set the `motherduck_token` environment variable.")
-        if type == 'MOTHERDUCK':
-            conn = duckdb.connect('md:', config={
-                "custom_user_agent": f"mcp-server-motherduck/{SERVER_VERSION}"
-            })
-        elif type == 'DUCKDB':
-            conn = duckdb.connect()
-        databases = conn.execute("""select string_agg(database_name, ',\n')
-                                    from duckdb_databases() where database_name 
-                                    not in ('system', 'temp')""").fetchone()[0]
-        response = f'Connection to {type} successfully established. Here are the available databases: \n{databases}'
-        return [types.TextContent(type="text", text=response)]
-    if name == "read-schemas":
-        database = arguments["database_name"]
-        tables = conn.execute(f"""
-                    SELECT string_agg(regexp_replace(sql, 'CREATE TABLE ', 'CREATE TABLE '||database_name||'.'), '\n\n') as sql 
-                    FROM duckdb_tables()
-                    WHERE database_name = '{database}'""").fetchone()[0]
-        views = conn.execute(f"""
-                    SELECT string_agg(regexp_replace(sql, 'CREATE TABLE ', 'CREATE TABLE '||database_name||'.'), '\n\n') as sql 
-                    FROM duckdb_views()
-                    where schema_name not in ('information_schema', 'pg_catalog', 'localmemdb')
-                    and view_name not in ('duckdb_columns','duckdb_constraints','duckdb_databases','duckdb_indexes','duckdb_schemas','duckdb_tables','duckdb_types','duckdb_views','pragma_database_list','sqlite_master','sqlite_schema','sqlite_temp_master','sqlite_temp_schema')
-                    and database_name = '{database}'
-                    """).fetchone()[0]
-        results = f"Here are all tables: \n{tables} \n\n Here are all views: {views}"
-        return [types.TextContent(type="text", text=str(results))]
-    if name == "execute-query":
-        try:
-            results = conn.execute(arguments["query"]).fetchall()
-        except Exception as e:
-            raise ValueError('Error querying the database:'+str(e))
-        return [types.TextContent(type="text", text=str(results))]
-
-
-async def main():
-    # Run the server using stdin/stdout streams
-    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-        await server.run(
-            read_stream,
-            write_stream,
-            InitializationOptions(
-                server_name="motherduck",
-                server_version=SERVER_VERSION,
-                capabilities=server.get_capabilities(
-                    notification_options=NotificationOptions(),
-                    experimental_capabilities={},
-                ),
-            ),
-        )

mcp_server_motherduck-0.3.1/src/mcp_server_motherduck/server.py

@@ -0,0 +1,196 @@
+import os
+import logging
+import duckdb
+from pydantic import AnyUrl
+from typing import Literal
+import mcp.server.stdio
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+from .prompt import PROMPT_TEMPLATE
+
+SERVER_VERSION = "0.3.1"
+
+logger = logging.getLogger("mcp_server_motherduck")
+
+
+class DatabaseClient:
+    def __init__(self, db_path: str = None):
+        self.db_path, self.db_type = self._resolve_db_path_type(db_path)
+        self.conn = self._initialize_connection()
+
+    def _initialize_connection(self) -> duckdb.DuckDBPyConnection:
+        """Initialize connection to the MotherDuck or DuckDB database"""
+
+        logger.info(f"Connecting to {self.db_type} database: `{self.db_path}`")
+
+        return duckdb.connect(
+            self.db_path,
+            config={"custom_user_agent": f"mcp-server-motherduck/{SERVER_VERSION}"},
+        )
+
+    def _resolve_db_path_type(
+        self, db_path: str = None
+    ) -> tuple[str, Literal["duckdb", "motherduck"]]:
+        """Resolve and validate the database path"""
+        # Use MotherDuck if token is available and no path specified
+        if db_path is None and os.getenv("motherduck_token"):
+            logger.info("Using MotherDuck token to connect to database `md:`")
+            return "md:", "motherduck"
+
+        # Handle MotherDuck paths
+        if db_path and (db_path == "md:" or db_path.startswith("md:")):
+            if not os.getenv("motherduck_token"):
+                raise ValueError(
+                    "Please set the `motherduck_token` environment variable when using `md:` as db_path."
+                )
+            return db_path, "motherduck"
+
+        # Handle local database paths
+        if db_path:
+            if not os.path.exists(db_path):
+                raise FileNotFoundError(
+                    f"The database path `{db_path}` does not exist."
+                )
+            return db_path, "duckdb"
+
+        # Default to in-memory database
+        return ":memory:", "duckdb"
+
+    def query(self, query: str) -> str:
+        try:
+            return str(self.conn.execute(query).fetchall())
+        except Exception as e:
+            logger.error(f"Database error executing query: {e}")
+            raise ValueError(f"Error executing query: {e}")
+
+    def mcp_config(self) -> str:
+        """Used for debugging purposes to show the current MCP config"""
+        return {
+            "current_working_directory": os.getcwd(),
+            "database_type": self.db_type,
+            "database_path": self.db_path,
+        }
+
+
+async def main(db_path: str):
+    logger.info(f"Starting MotherDuck MCP Server with DB path: {db_path}")
+    server = Server("mcp-server-motherduck")
+    db_client = DatabaseClient(db_path=db_path)
+
+    logger.info("Registering handlers")
+
+    @server.list_resources()
+    async def handle_list_resources() -> list[types.Resource]:
+        """
+        List available note resources.
+        Each note is exposed as a resource with a custom note:// URI scheme.
+        """
+        logger.info("No resources available to list")
+        return []
+
+    @server.read_resource()
+    async def handle_read_resource(uri: AnyUrl) -> str:
+        """
+        Read a specific note's content by its URI.
+        The note name is extracted from the URI host component.
+        """
+        logger.info(f"Reading resource: {uri}")
+        raise ValueError(f"Unsupported URI scheme: {uri.scheme}")
+
+    @server.list_prompts()
+    async def handle_list_prompts() -> list[types.Prompt]:
+        """
+        List available prompts.
+        Each prompt can have optional arguments to customize its behavior.
+        """
+        logger.info("Listing prompts")
+        # TODO: Check where and how this is used, and how to optimize this.
+        # Check postgres and sqlite servers.
+        return [
+            types.Prompt(
+                name="duckdb-motherduck-initial-prompt",
+                description="A prompt to initialize a connection to duckdb or motherduck and start working with it",
+            )
+        ]
+
+    @server.get_prompt()
+    async def handle_get_prompt(
+        name: str, arguments: dict[str, str] | None
+    ) -> types.GetPromptResult:
+        """
+        Generate a prompt by combining arguments with server state.
+        The prompt includes all current notes and can be customized via arguments.
+        """
+        logger.info(f"Getting prompt: {name}::{arguments}")
+        # TODO: Check where and how this is used, and how to optimize this.
+        # Check postgres and sqlite servers.
+        if name != "duckdb-motherduck-initial-prompt":
+            raise ValueError(f"Unknown prompt: {name}")
+
+        return types.GetPromptResult(
+            description="Initial prompt for interacting with DuckDB/MotherDuck",
+            messages=[
+                types.PromptMessage(
+                    role="user",
+                    content=types.TextContent(type="text", text=PROMPT_TEMPLATE),
+                )
+            ],
+        )
+
+    @server.list_tools()
+    async def handle_list_tools() -> list[types.Tool]:
+        """
+        List available tools.
+        Each tool specifies its arguments using JSON Schema validation.
+        """
+        logger.info("Listing tools")
+        return [
+            types.Tool(
+                name="query",
+                description="Use this to execute a query on the MotherDuck or DuckDB database",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "SQL query to execute that is a dialect of DuckDB SQL",
+                        },
+                    },
+                    "required": ["query"],
+                },
+            ),
+        ]
+
+    @server.call_tool()
+    async def handle_tool_call(
+        name: str, arguments: dict | None
+    ) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
+        """
+        Handle tool execution requests.
+        Tools can modify server state and notify clients of changes.
+        """
+        logger.info(f"Calling tool: {name}::{arguments}")
+        try:
+            if name == "query":
+                tool_response = db_client.query(arguments["query"])
+                return [types.TextContent(type="text", text=str(tool_response))]
+
+        except Exception as e:
+            logger.error(f"Error executing tool {name}: {e}")
+            raise ValueError(f"Error executing tool {name}: {str(e)}")
+
+    # Run the server using stdin/stdout streams
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="motherduck",
+                server_version=SERVER_VERSION,
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )

mcp_server_motherduck-0.2.2/.gitignore

@@ -1 +0,0 @@
-.DS_Store

mcp_server_motherduck-0.2.2/src/mcp_server_motherduck/__init__.py

@@ -1,9 +0,0 @@
-from . import server
-import asyncio
-
-def main():
-    """Main entry point for the package."""
-    asyncio.run(server.main())
-
-# Optionally expose other important items at package level
-__all__ = ['main', 'server']