dtlpymcp 0.1.8__tar.gz → 0.1.10__tar.gz

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtlpymcp
-Version: 0.1.8
+Version: 0.1.10
 Summary: STDIO MCP proxy server for Dataloop platform.
 Author-email: Your Name <your.email@example.com>
 Classifier: Programming Language :: Python :: 3.10

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/dtlpymcp/__init__.py

@@ -1,4 +1,3 @@
 from .utils.dtlpy_context import DataloopContext, MCPSource
 
-__version__ = "0.1.8"
-
+__version__ = "0.1.10"

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/dtlpymcp/__main__.py

@@ -2,39 +2,35 @@
 CLI entry point for dtlpymcp.
 Reads from STDIN and writes to STDOUT.
 """
+
 import sys
 import argparse
 from dtlpymcp.proxy import main as proxy_main
 
+
 def main():
-    parser = argparse.ArgumentParser(
-        description="Dataloop MCP Proxy Server CLI"
-    )
+    parser = argparse.ArgumentParser(description="Dataloop MCP Proxy Server CLI")
     subparsers = parser.add_subparsers(dest="command", required=False)
 
     # 'start' subcommand
     start_parser = subparsers.add_parser("start", help="Start the MCP proxy server (STDIO mode)")
     start_parser.add_argument(
-        "--sources-file",
-        "-s",
-        type=str,
-        default=None,
-        help="Path to a JSON file with MCP sources to load"
+        "--sources-file", "-s", type=str, default=None, help="Path to a JSON file with MCP sources to load"
     )
     start_parser.add_argument(
         "--init-timeout",
         "-t",
         type=float,
         default=30.0,
-        help="Timeout in seconds for Dataloop context initialization (default: 30.0)"
+        help="Timeout in seconds for Dataloop context initialization (default: 30.0)",
     )
     start_parser.add_argument(
         "--log-level",
         "-l",
         type=str,
+        default="INFO",
         choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
-        default="DEBUG",
-        help="Logging verbosity level (default: DEBUG)"
+        help="Logging level (default: INFO)",
     )
 
     args = parser.parse_args()
@@ -45,5 +41,6 @@ def main():
         parser.print_help()
         return 1
 
+
 if __name__ == "__main__":
-    main() 
+    main()

dtlpymcp-0.1.8/dtlpymcp/proxy.py → dtlpymcp-0.1.10/dtlpymcp/min_proxy.py

@@ -1,32 +1,19 @@
-
 from mcp.server.fastmcp import FastMCP, Context
-from typing import Any, Optional
+from typing import Any
 import traceback
 import os
-
+import logging
+from mcp.server.fastmcp.tools.base import Tool, FuncMetadata
+from pydantic import create_model
+from mcp.server.fastmcp.utilities.func_metadata import ArgModelBase
 from dtlpymcp.utils.dtlpy_context import DataloopContext
-from dtlpymcp.utils.server_utils import safe_initialize_dataloop_context
-from dtlpymcp.utils.logging_config import setup_logging, get_logger
 
-# Get the main logger
-logger = get_logger()
+logger = logging.getLogger(__name__)
 
 
-def create_dataloop_mcp_server(sources_file: Optional[str] = None, init_timeout: float = 30.0) -> FastMCP:
+def create_dataloop_mcp_server() -> FastMCP:
     """Create a FastMCP server for Dataloop with Bearer token authentication."""
-    app = FastMCP(
-        name="Dataloop MCP Server",
-        instructions="A multi-tenant MCP server for Dataloop with authentication",
-        stateless_http=True,
-        debug=True,
-    )
-    
-    # Create Dataloop context
-    dl_context = DataloopContext(token=os.environ.get('DATALOOP_API_KEY'), 
-                                 env=os.environ.get('DATALOOP_ENV', 'prod'),
-                                 sources_file=sources_file)
-    
-    @app.tool(description="Test tool for health checks")
+
     async def test(ctx: Context, ping: Any = None) -> dict[str, Any]:
         """Health check tool. Returns status ok and echoes ping if provided."""
         result = {"status": "ok"}
@@ -34,29 +21,43 @@ def create_dataloop_mcp_server(sources_file: Optional[str] = None, init_timeout:
             result["ping"] = ping
         return result
 
-    # Initialize context using the safe utility function
-    initialization_success = safe_initialize_dataloop_context(dl_context, app, init_timeout)
-    
-    if not initialization_success:
-        logger.info("Server will start without Dataloop tools - they will be available on next restart")
-        # Continue without initialization - the server will still work with the test tool
-    
+    app = FastMCP(
+        name="Dataloop MCP Server",
+        instructions="A multi-tenant MCP server for Dataloop with authentication",
+        debug=True,
+        log_level="DEBUG",
+    )
+    tool_name = "test"
+    input_schema = {"properties": {"ping": {"type": "string", "default": "pong"}}, "required": ["ping"]}
+    # Create Dataloop context
+    dynamic_pydantic_model_params = DataloopContext.build_pydantic_fields_from_schema(input_schema)
+    arguments_model = create_model(f"{tool_name}Arguments", **dynamic_pydantic_model_params, __base__=ArgModelBase)
+    resp = FuncMetadata(arg_model=arguments_model)
+
+    app._tool_manager._tools[tool_name] = Tool(
+        fn=test,
+        name=tool_name,
+        description="Test tool for health checks",
+        parameters=input_schema,
+        is_async=True,
+        context_kwarg="ctx",
+        fn_metadata=resp,
+        annotations=None,
+    )
+
     return app
 
 
-def main(sources_file: Optional[str] = None, init_timeout: float = 30.0, log_level: str = "DEBUG") -> int:
-    # Setup logging with the specified level
-    setup_logging(log_level)
-    
+def main() -> int:
     logger.info("Starting Dataloop MCP server in stdio mode")
-    
+
     # Validate environment variables
     if not os.environ.get('DATALOOP_API_KEY'):
         logger.error("DATALOOP_API_KEY environment variable is required")
         return 1
-    
+
     try:
-        mcp_server = create_dataloop_mcp_server(sources_file=sources_file, init_timeout=init_timeout)
+        mcp_server = create_dataloop_mcp_server()
         logger.info("Dataloop MCP server created successfully")
         logger.info("Starting server in stdio mode...")
         mcp_server.run(transport="stdio")

dtlpymcp-0.1.10/dtlpymcp/proxy.py

@@ -0,0 +1,174 @@
+from mcp.server.fastmcp import FastMCP, Context
+from mcp.server.fastmcp.tools.base import Tool, FuncMetadata
+from typing import Any, Optional, List
+import traceback
+from datetime import datetime
+from pathlib import Path
+import os
+import asyncio
+import logging
+from pydantic import create_model
+from mcp.server.fastmcp.utilities.func_metadata import ArgModelBase
+
+from dtlpymcp.utils.dtlpy_context import DataloopContext
+
+
+def setup_logging(log_level: str = "INFO") -> logging.Logger:
+    """
+    Setup logging configuration with the specified log level.
+    
+    Args:
+        log_level: Logging level as string (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        
+    Returns:
+        logging.Logger: Configured logger instance
+    """
+    # Setup logging directory and file
+    log_dir = Path.home() / ".dataloop" / "mcplogs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / f"{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.log"
+
+    # Remove any existing handlers
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+
+    # File handler with timestamp
+    file_handler = logging.FileHandler(log_file, mode="a", encoding="utf-8")
+    file_handler.setFormatter(
+        logging.Formatter(fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    )
+
+    # Console handler (default format)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(logging.Formatter(fmt="[%(levelname)s] %(name)s: %(message)s"))
+
+    # Convert string log level to logging constant
+    numeric_level = getattr(logging, log_level.upper(), logging.INFO)
+    
+    # Configure root logger
+    logging.basicConfig(level=numeric_level, handlers=[file_handler, console_handler])
+
+    # Get the main logger
+    logger = logging.getLogger("dtlpymcp")
+    logger.info(f"Logging configured with level: {log_level.upper()}")
+    logger.info(f"Log file: {log_file}")
+    
+    return logger
+
+
+def run_async(coro):
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        # No event loop running
+        return asyncio.run(coro)
+    else:
+        # Already running event loop
+        return loop.create_task(coro)
+
+
+async def initialize_dataloop_context(sources_file: Optional[str] = None, init_timeout: float = 30.0) -> List[Tool]:
+    """
+    Initialize Dataloop context with timeout protection.
+
+    Args:
+        sources_file: Path to sources file
+        init_timeout: Timeout in seconds for initialization
+
+    Returns:
+        List[Tool]: List of tools
+    """
+    logger = logging.getLogger("dtlpymcp")
+    try:
+        tools = []
+        dl_context = DataloopContext(
+            token=os.environ.get('DATALOOP_API_KEY'),
+            env=os.environ.get('DATALOOP_ENV', 'prod'),
+            sources_file=sources_file,
+        )
+        logger.info("Initializing Dataloop context...")
+        await dl_context.initialize()
+        logger.info("Dataloop context initialized successfully")
+
+        logger.info(f"Adding tools from {len(dl_context.mcp_sources)} sources")
+        for source in dl_context.mcp_sources:
+            logger.info(f"Adding tools from source: {source.dpk_name}")
+            for tool in source.tools:
+                tools.append(tool)
+                logger.info(f"Registered tool: {tool.name}")
+
+        return tools
+
+    except asyncio.TimeoutError:
+        logger.error("Timeout during Dataloop context initialization")
+        return []
+    except Exception as e:
+        logger.error(f"Failed to initialize Dataloop context: {e}")
+        return []
+
+
+def create_dataloop_mcp_server(sources_file: Optional[str] = None, init_timeout: float = 30.0) -> FastMCP:
+    """Create a FastMCP server for Dataloop with Bearer token authentication."""
+
+    async def test(ctx: Context, ping: Any = None) -> dict[str, Any]:
+        """Health check tool. Returns status ok and echoes ping if provided."""
+        result = {"status": "ok"}
+        if ping is not None:
+            result["ping"] = ping
+        return result
+
+    tool_name = "test"
+    input_schema = {"properties": {"ping": {"type": "string"}}, "required": ["ping"]}
+    dynamic_pydantic_model_params = DataloopContext.build_pydantic_fields_from_schema(input_schema)
+    arguments_model = create_model(f"{tool_name}Arguments", **dynamic_pydantic_model_params, __base__=ArgModelBase)
+    resp = FuncMetadata(arg_model=arguments_model)
+    t = Tool(
+        fn=test,
+        name=tool_name,
+        description="Test tool for health checks",
+        parameters=input_schema,
+        is_async=True,
+        context_kwarg="ctx",
+        fn_metadata=resp,
+        annotations=None,
+    )
+    tools = [t]
+    tools.extend(run_async(initialize_dataloop_context(sources_file=sources_file, init_timeout=init_timeout)))
+    app = FastMCP(
+        name="Dataloop MCP Server",
+        instructions="A multi-tenant MCP server for Dataloop with authentication",
+        debug=True,
+        tools=tools,
+    )
+
+    return app
+
+
+def main(sources_file: Optional[str] = None, init_timeout: float = 30.0, log_level: str = "INFO") -> int:
+    # Setup logging with the specified level
+    logger = setup_logging(log_level)
+    
+    logger.info("Starting Dataloop MCP server in stdio mode")
+
+    # Validate environment variables
+    if not os.environ.get('DATALOOP_API_KEY'):
+        logger.error("DATALOOP_API_KEY environment variable is required")
+        return 1
+
+    try:
+        mcp_server = create_dataloop_mcp_server(sources_file=sources_file, init_timeout=init_timeout)
+        logger.info("Dataloop MCP server created successfully")
+        logger.info("Starting server in stdio mode...")
+        mcp_server.run(transport="stdio")
+        return 0
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+        return 0
+    except Exception as e:
+        logger.error(f"Failed to start MCP server: {e}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        return 1
+
+
+if __name__ == "__main__":
+    main()

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/dtlpymcp/utils/dtlpy_context.py

@@ -9,13 +9,12 @@ from mcp import ClientSession
 import dtlpy as dl
 import traceback
 import requests
+import logging
 import time
 import jwt
 import json
 
-from dtlpymcp.utils.logging_config import get_logger
-
-logger = get_logger("dtlpy_context")
+logger = logging.getLogger("dtlpymcp")
 
 
 class MCPSource(BaseModel):
@@ -52,7 +51,8 @@ class DataloopContext:
             filters = dl.Filters(resource='apps')
             filters.add(field="dpkName", values="dataloop-mcp*")
             filters.add(field="scope", values="system")
-            apps = list(dl.apps.list(filters=filters).all())
+            # IMPORTANT: Listing with `all()` cause everything to get stuck. getting only first page using `items` for now
+            apps = dl.apps.list(filters=filters).items
             if len(apps) == 0:
                 raise ValueError(f"No app found for DPK name: dataloop-mcp*")
             sources = []
@@ -230,17 +230,19 @@ class DataloopContext:
                 logger.info(f"Discovered {len(tools.tools)} tools for source {source.dpk_name}")
                 return (source.dpk_name, tools, call_fn)
 
-    def openapi_type_to_python(self, type_str):
+    @staticmethod
+    def openapi_type_to_python(type_str):
         return {"string": str, "integer": int, "number": float, "boolean": bool, "array": list, "object": dict}.get(
             type_str, str
         )
 
-    def build_pydantic_fields_from_schema(self, input_schema):
+    @staticmethod
+    def build_pydantic_fields_from_schema(input_schema):
         required = set(input_schema.get("required", []))
         properties = input_schema.get("properties", {})
         fields = {}
         for name, prop in properties.items():
-            py_type = self.openapi_type_to_python(prop.get("type", "string"))
+            py_type = DataloopContext.openapi_type_to_python(prop.get("type", "string"))
             if name in required:
                 fields[name] = (py_type, Field(...))
             else:

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/dtlpymcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtlpymcp
-Version: 0.1.8
+Version: 0.1.10
 Summary: STDIO MCP proxy server for Dataloop platform.
 Author-email: Your Name <your.email@example.com>
 Classifier: Programming Language :: Python :: 3.10

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/dtlpymcp.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 dtlpymcp/__init__.py
 dtlpymcp/__main__.py
+dtlpymcp/min_proxy.py
 dtlpymcp/proxy.py
 dtlpymcp.egg-info/PKG-INFO
 dtlpymcp.egg-info/SOURCES.txt
@@ -11,8 +12,6 @@ dtlpymcp.egg-info/entry_points.txt
 dtlpymcp.egg-info/requires.txt
 dtlpymcp.egg-info/top_level.txt
 dtlpymcp/utils/dtlpy_context.py
-dtlpymcp/utils/logging_config.py
-dtlpymcp/utils/server_utils.py
 tests/test_context.py
 tests/test_custom_sources_file.py
 tests/test_list_platform_tools.py

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dtlpymcp"
-version = "0.1.8"
+version = "0.1.10"
 description = "STDIO MCP proxy server for Dataloop platform."
 authors = [
     { name = "Your Name", email = "your.email@example.com" }

{dtlpymcp-0.1.8 → dtlpymcp-0.1.10}/tests/test_proxy.py

@@ -1,32 +1,34 @@
 import asyncio
 import random
 import json
+import sys
 import os
 from datetime import timedelta
 from mcp.client.stdio import stdio_client
 from mcp import ClientSession, StdioServerParameters
 import dtlpy as dl
 
-dl.setenv('rc')
+dl.setenv('prod')
 if dl.token_expired():
     dl.login()
 token = dl.token()
 env = {"DATALOOP_API_KEY": str(token)} if token else None
 # Create server parameters for stdio connection
 server_params = StdioServerParameters(
-    command="dtlpymcp",  # Executable
-    args=["start"],  # Command line arguments
+    command=sys.executable,  # Use current Python interpreter
+    args=["-m", "dtlpymcp.min_proxy"],  # Run as module with start command
     env=env,  # Optional environment variables
     cwd=os.getcwd(),
 )
 
 
+
 async def test_health_check():
     print("[TEST CLIENT] Connecting to MCP server and calling test tool...")
     async with stdio_client(server=server_params) as (read, write):
         async with ClientSession(read, write, read_timeout_seconds=timedelta(seconds=60)) as session:
             await session.initialize()
-            num = random.randint(1, 1000000)
+            num = str(random.randint(1, 1000000))
             tool_result = await session.call_tool("test", {"ping": num})
             print("[RESULT]", tool_result)
             assert json.loads(tool_result.content[0].text).get("status") == "ok", "Health check failed!"
@@ -34,6 +36,6 @@ async def test_health_check():
 
 
 if __name__ == "__main__":
+    
 
     asyncio.run(test_health_check())
-    # asyncio.run(test_ask_dataloop())

dtlpymcp-0.1.8/dtlpymcp/utils/logging_config.py

@@ -1,61 +0,0 @@
-"""
-Centralized logging configuration for dtlpymcp.
-Handles file and console logging with configurable verbosity levels.
-"""
-
-import logging
-from datetime import datetime
-from pathlib import Path
-
-
-def setup_logging(log_level: str = "DEBUG") -> None:
-    """
-    Set up logging configuration for the entire dtlpymcp application.
-    
-    Args:
-        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-    """
-    # Convert string level to logging constant
-    level = getattr(logging, log_level.upper(), logging.DEBUG)
-    
-    # Setup logging directory and file
-    log_dir = Path.home() / ".dataloop" / "mcplogs"
-    log_dir.mkdir(parents=True, exist_ok=True)
-    log_file = log_dir / f"{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.log"
-    
-    # Remove any existing handlers
-    for handler in logging.root.handlers[:]:
-        logging.root.removeHandler(handler)
-    
-    # File handler with timestamp
-    file_handler = logging.FileHandler(log_file, mode="a", encoding="utf-8")
-    file_handler.setFormatter(
-        logging.Formatter(fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
-    )
-    
-    # Console handler (default format)
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(logging.Formatter(fmt="[%(levelname)s] %(name)s: %(message)s"))
-    
-    # Configure root logger
-    logging.basicConfig(level=level, handlers=[file_handler, console_handler])
-    
-    # Get the main logger
-    logger = logging.getLogger("dtlpymcp")
-    logger.info(f"Logging configured with level: {log_level.upper()}")
-    logger.info(f"Log file: {log_file}")
-
-
-def get_logger(name: str = None) -> logging.Logger:
-    """
-    Get a logger instance with the specified name.
-    
-    Args:
-        name: Logger name (optional, defaults to "dtlpymcp")
-        
-    Returns:
-        logging.Logger: Configured logger instance
-    """
-    if name is None:
-        return logging.getLogger("dtlpymcp")
-    return logging.getLogger(f"dtlpymcp.{name}")

dtlpymcp-0.1.8/dtlpymcp/utils/server_utils.py

@@ -1,91 +0,0 @@
-"""
-Utility functions for Dataloop MCP server initialization and management.
-"""
-
-import asyncio
-from mcp.server.fastmcp import FastMCP
-from dtlpymcp.utils.dtlpy_context import DataloopContext
-from dtlpymcp.utils.logging_config import get_logger
-
-logger = get_logger("server_utils")
-
-
-def run_async(coro):
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        # No event loop running
-        return asyncio.run(coro)
-    else:
-        # Already running event loop
-        return loop.create_task(coro)
-
-
-async def initialize_dataloop_context(dl_context: DataloopContext, app: FastMCP, init_timeout: float = 30.0) -> bool:
-    """
-    Initialize Dataloop context with timeout protection.
-
-    Args:
-        dl_context: The DataloopContext instance to initialize
-        app: The FastMCP app instance to register tools with
-        init_timeout: Timeout in seconds for initialization
-
-    Returns:
-        bool: True if initialization succeeded, False otherwise
-    """
-    try:
-        logger.info("Initializing Dataloop context...")
-        # Use asyncio.wait_for for timeout protection
-        await asyncio.wait_for(dl_context.initialize(), timeout=init_timeout)
-        logger.info("Dataloop context initialized successfully")
-
-        # Register tools after initialization
-        logger.info(f"Adding tools from {len(dl_context.mcp_sources)} sources")
-        for source in dl_context.mcp_sources:
-            logger.info(f"Adding tools from source: {source.dpk_name}")
-            for tool in source.tools:
-                app._tool_manager._tools[tool.name] = tool
-                logger.info(f"Registered tool: {tool.name}")
-
-        return True
-
-    except asyncio.TimeoutError:
-        logger.error("Timeout during Dataloop context initialization")
-        return False
-    except Exception as e:
-        logger.error(f"Failed to initialize Dataloop context: {e}")
-        return False
-
-
-def safe_initialize_dataloop_context(dl_context: DataloopContext, app: FastMCP, init_timeout: float = 30.0) -> bool:
-    """
-    Safely initialize Dataloop context using run_async utility.
-
-    Args:
-        dl_context: The DataloopContext instance to initialize
-        app: The FastMCP app instance to register tools with
-        init_timeout: Timeout in seconds for initialization
-
-    Returns:
-        bool: True if initialization succeeded, False otherwise
-    """
-    try:
-        # Use the run_async utility to handle async execution properly
-        result = run_async(initialize_dataloop_context(dl_context, app, init_timeout))
-
-        # Handle different return types from run_async
-        if hasattr(result, 'done'):
-            # It's a task, wait for it to complete
-            while not result.done():
-                pass
-            return result.result()
-        elif asyncio.iscoroutine(result):
-            # It's a coroutine, run it
-            return asyncio.run(result)
-        else:
-            # It's already the result (bool)
-            return result
-
-    except Exception as e:
-        logger.error(f"Failed to initialize during server creation: {e}")
-        return False