s2_mcp_server 0.1.0__py3-none-any.whl

s2_mcp_server/__init__.py

@@ -0,0 +1,9 @@
+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']

s2_mcp_server/config.py

@@ -0,0 +1,9 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()  # Loads environment variables from a .env file
+
+SINGLESTORE_API_KEY = os.getenv("SINGLESTORE_API_KEY")
+SINGLESTORE_DB_USERNAME = os.getenv("SINGLESTORE_DB_USERNAME")
+SINGLESTORE_DB_PASSWORD = os.getenv("SINGLESTORE_DB_PASSWORD")
+SINGLESTORE_API_BASE_URL = "https://api.singlestore.com"

s2_mcp_server/server.py

@@ -0,0 +1,131 @@
+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
+from s2_mcp_server.config import SINGLESTORE_API_KEY
+from s2_mcp_server.tools import tools, tool_functions
+
+# Store notes as a simple key-value dict to demonstrate state management
+notes: dict[str, str] = {}
+
+# Store custom text resources
+custom_text_resources: dict[str, str] = {}
+
+# Store session state for caching user inputs
+session_state: dict[str, dict] = {}
+
+server = Server("SingleStore MCP Server")
+
+
+@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 [
+        types.Resource(
+            uri=AnyUrl(f"note://internal/{name}"),
+            name=f"Note: {name}",
+            description=f"A simple note named {name}",
+            mimeType="text/plain",
+        )
+        for name in notes
+    ]
+
+
+@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.
+    """
+    if uri.scheme != "note":
+        raise ValueError(f"Unsupported URI scheme: {uri.scheme}")
+
+    name = uri.path
+    if name is not None:
+        name = name.lstrip("/")
+        return notes[name]
+    raise ValueError(f"Note not found: {name}")
+
+
+@server.list_resources()
+async def handle_list_custom_text_resources() -> list[types.Resource]:
+    """
+    List available custom text resources.
+    Each resource is exposed with a custom text:// URI scheme.
+    """
+    return [
+        types.Resource(
+            uri=AnyUrl(f"text://internal/{name}"),
+            name=f"Text Resource: {name}",
+            description=f"A custom text resource named {name}",
+            mimeType="text/plain",
+        )
+        for name in custom_text_resources
+    ]
+
+
+@server.read_resource()
+async def handle_read_custom_text_resource(uri: AnyUrl) -> str:
+    """
+    Read a specific custom text resource's content by its URI.
+    The resource name is extracted from the URI host component.
+    """
+    if uri.scheme != "text":
+        raise ValueError(f"Unsupported URI scheme: {uri.scheme}")
+
+    name = uri.path
+    if name is not None:
+        name = name.lstrip("/")
+        return custom_text_resources[name]
+    raise ValueError(f"Resource not found: {name}")
+
+
+@server.list_tools()
+async def handle_list_tools() -> list[types.Tool]:
+    """
+    List available tools.
+    Each tool specifies its arguments using JSON Schema validation.
+    """
+    return tools
+
+
+@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.
+    """
+    if name not in tool_functions:
+        raise ValueError(f"Unknown tool: {name}")
+
+    result = tool_functions[name](**arguments)
+
+    return [types.TextContent(type="text", text=str(result))]
+
+
+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="SingleStore MCP Server",
+                server_version="0.1.0",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+                initialization_options={
+                    "singlestore_api_key": SINGLESTORE_API_KEY,
+                },
+            ),
+        )

s2_mcp_server/tools/__init__.py

@@ -0,0 +1,15 @@
+import mcp.types as types
+from .definitions import tools_definitions
+
+# Export the tools
+tools = [
+    types.Tool(
+        name=tool["name"],
+        description=tool["description"],
+        inputSchema=tool["inputSchema"]
+    )
+    for tool in tools_definitions
+]
+
+# Map tool functions by name for execution
+tool_functions = {tool["name"]: tool["func"] for tool in tools_definitions}