dtlpymcp 0.1.7__tar.gz → 0.1.9__tar.gz

{dtlpymcp-0.1.7 → dtlpymcp-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtlpymcp
-Version: 0.1.7
+Version: 0.1.9
 Summary: STDIO MCP proxy server for Dataloop platform.
 Author-email: Your Name <your.email@example.com>
 Classifier: Programming Language :: Python :: 3.10
@@ -30,7 +30,14 @@ pip install git+<repository-url>
 You can run the proxy server via CLI:
 
 ```shell
+# Basic usage
 dtlpymcp start
+
+# With custom sources file
+dtlpymcp start --sources-file /path/to/sources.json
+
+# With custom initialization timeout (default: 30 seconds)
+dtlpymcp start --init-timeout 60.0
 ```
 
 Or using Python module syntax:
@@ -45,6 +52,14 @@ python -m dtlpymcp start
 - Install dependencies with `pip install -e .`
 - Run tests with `pytest`
 
+## Architecture
+
+The server uses a modular architecture with utilities for safe async initialization:
+
+- `dtlpymcp/proxy.py` - Main server implementation using FastMCP
+- `dtlpymcp/utils/server_utils.py` - Safe async initialization utilities
+- `dtlpymcp/utils/dtlpy_context.py` - Dataloop context management
+
 ## Cursor MCP Integration
 
 To add this MCP to Cursor, add the following to your configuration:

{dtlpymcp-0.1.7 → dtlpymcp-0.1.9}/README.md

@@ -13,7 +13,14 @@ pip install git+<repository-url>
 You can run the proxy server via CLI:
 
 ```shell
+# Basic usage
 dtlpymcp start
+
+# With custom sources file
+dtlpymcp start --sources-file /path/to/sources.json
+
+# With custom initialization timeout (default: 30 seconds)
+dtlpymcp start --init-timeout 60.0
 ```
 
 Or using Python module syntax:
@@ -28,6 +35,14 @@ python -m dtlpymcp start
 - Install dependencies with `pip install -e .`
 - Run tests with `pytest`
 
+## Architecture
+
+The server uses a modular architecture with utilities for safe async initialization:
+
+- `dtlpymcp/proxy.py` - Main server implementation using FastMCP
+- `dtlpymcp/utils/server_utils.py` - Safe async initialization utilities
+- `dtlpymcp/utils/dtlpy_context.py` - Dataloop context management
+
 ## Cursor MCP Integration
 
 To add this MCP to Cursor, add the following to your configuration:

dtlpymcp-0.1.9/dtlpymcp/__init__.py

@@ -0,0 +1,34 @@
+from .utils.dtlpy_context import DataloopContext, MCPSource
+import logging
+from datetime import datetime
+from pathlib import Path
+
+__version__ = "0.1.9"
+
+
+# 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=logging.DEBUG, handlers=[file_handler, console_handler])
+
+# Get the main logger
+logger = logging.getLogger("dtlpymcp")
+logger.info(f"Logging configured with level: DEBUG")
+logger.info(f"Log file: {log_file}")

{dtlpymcp-0.1.7 → dtlpymcp-0.1.9}/dtlpymcp/__main__.py

@@ -2,33 +2,37 @@
 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)",
     )
 
     args = parser.parse_args()
 
     if args.command == "start":
-        sys.exit(proxy_main(sources_file=args.sources_file))
+        sys.exit(proxy_main(sources_file=args.sources_file, init_timeout=args.init_timeout))
     else:
         parser.print_help()
         return 1
 
+
 if __name__ == "__main__":
-    main() 
+    main()

dtlpymcp-0.1.9/dtlpymcp/min_proxy.py

@@ -0,0 +1,75 @@
+from mcp.server.fastmcp import FastMCP, Context
+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
+
+logger = logging.getLogger(__name__)
+
+
+def create_dataloop_mcp_server() -> 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
+
+    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() -> 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()
+        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.9/dtlpymcp/proxy.py

@@ -0,0 +1,129 @@
+from mcp.server.fastmcp import FastMCP, Context
+from mcp.server.fastmcp.tools.base import Tool, FuncMetadata
+from typing import Any, Optional, List
+import traceback
+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
+
+logger = logging.getLogger("dtlpymcp")
+
+
+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:
+        dl_context: The DataloopContext instance to initialize
+        app: The FastMCP app instance to register tools with
+        init_timeout: Timeout in seconds for initialization
+
+    Returns:
+        List[Tool]: List of tools
+    """
+    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) -> 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)
+        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.7 → dtlpymcp-0.1.9}/dtlpymcp/utils/dtlpy_context.py

@@ -1,8 +1,7 @@
 from mcp.server.fastmcp.utilities.func_metadata import ArgModelBase, FuncMetadata
 from mcp.client.streamable_http import streamablehttp_client
-from typing import Any, List, Tuple, Callable, Optional
+from typing import List, Tuple, Callable, Optional
 from mcp.server.fastmcp.tools.base import Tool
-from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
 from pydantic import create_model
 from datetime import timedelta
@@ -11,27 +10,11 @@ import dtlpy as dl
 import traceback
 import requests
 import logging
-import asyncio
 import time
 import jwt
 import json
-from dtlpymcp import SOURCES_FILEPATH
 
-# Utility to run async code from sync or async context
-# If called from a running event loop, returns a Task (caller must handle it)
-# If called from sync, blocks and returns result
-
-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)
-
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("dtlpymcp")
 
 
 class MCPSource(BaseModel):
@@ -53,22 +36,41 @@ class DataloopContext:
         self.env = env
         self.mcp_sources: List[MCPSource] = []
         logger.info("DataloopContext initialized.")
-        if sources_file is None:
-            sources_file = SOURCES_FILEPATH
         self.sources_file = sources_file
         self.initialized = False
-        
-    
+
     async def initialize(self, force: bool = False):
-        if not self.initialized or force:    
+        if not self.initialized or force:
             await self.register_sources(self.sources_file)
             self.initialized = True
 
-    async def register_sources(self, sources_file: str):
-        with open(sources_file, "r") as f:
-            data = json.load(f)
-        logger.info(f"Loading MCP sources from {sources_file}")
-        for entry in data:
+    async def register_sources(self, sources_file: str = None):
+        if sources_file is None:
+            logger.info("Loading MCP sources from all system apps")
+            # load all system apps
+            filters = dl.Filters(resource='apps')
+            filters.add(field="dpkName", values="dataloop-mcp*")
+            filters.add(field="scope", values="system")
+            # 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 = []
+            for app in apps:
+                sources.append(
+                    {
+                        "dpk_name": app.dpk_name,
+                        "app_url": next(iter(app.routes.values())),
+                        "server_url": None,
+                        "app_jwt": None,
+                    }
+                )
+        else:
+            logger.info(f"Loading MCP sources from {sources_file}")
+
+            with open(sources_file, "r") as f:
+                sources = json.load(f)
+        for entry in sources:
             try:
                 if not isinstance(entry, dict):
                     raise ValueError(f"Invalid source entry: {entry}")
@@ -78,9 +80,12 @@ class DataloopContext:
                 logger.error(f"Failed to add MCP source: {entry}\n{traceback.format_exc()}")
 
     async def add_mcp_source(self, mcp_source: MCPSource):
-        self.mcp_sources.append(mcp_source)
+
         if mcp_source.server_url is None:
-            self.load_app_info(mcp_source)
+            success = self.load_app_info(mcp_source)
+            if not success:
+                logger.error(f"Failed to load app info for source {mcp_source.dpk_name}")
+                return
         result = await self.list_source_tools(mcp_source)
         if result is None:
             raise ValueError(f"Failed to discover tools for source {mcp_source.dpk_name}")
@@ -114,6 +119,7 @@ class DataloopContext:
                 annotations=None,
             )
             mcp_source.tools.append(t)
+        self.mcp_sources.append(mcp_source)
         tool_str = ", ".join([tool.name for tool in mcp_source.tools])
         logger.info(f"Added MCP source: {mcp_source.dpk_name}, Available tools: {tool_str}")
 
@@ -125,32 +131,34 @@ class DataloopContext:
     def token(self, token: str):
         self._token = token
 
-    def load_app_info(self, source: MCPSource) -> None:
+    def load_app_info(self, source: MCPSource) -> bool:
         """
         Get the source URL and app JWT for a given DPK name using Dataloop SDK.
         """
         try:
-            dl.setenv(self.env)
-            dl.client_api.token = self.token
-            filters = dl.Filters(resource='apps')
-            filters.add(field="dpkName", values=source.dpk_name)
-            filters.add(field="scope", values="system")
-            apps = list(dl.apps.list(filters=filters).all())
-            if len(apps) == 0:
-                raise ValueError(f"No app found for DPK name: {source.dpk_name}")
-            if len(apps) > 1:
-                logger.warning(f"Multiple apps found for DPK name: {source.dpk_name}, using first one")
-            app = apps[0]
-            logger.info(f"App: {app.name}")
-            source.app_url = next(iter(app.routes.values()))
+            if source.app_url is None:
+                dl.setenv(self.env)
+                dl.client_api.token = self.token
+                filters = dl.Filters(resource='apps')
+                filters.add(field="dpkName", values=source.dpk_name)
+                filters.add(field="scope", values="system")
+                apps = list(dl.apps.list(filters=filters).all())
+                if len(apps) == 0:
+                    raise ValueError(f"No app found for DPK name: {source.dpk_name}")
+                if len(apps) > 1:
+                    logger.warning(f"Multiple apps found for DPK name: {source.dpk_name}, using first one")
+                app = apps[0]
+                logger.info(f"App: {app.name}")
+                source.app_url = next(iter(app.routes.values()))
             session = requests.Session()
             response = session.get(source.app_url, headers=dl.client_api.auth)
             logger.info(f"App route URL: {response.url}")
             source.server_url = response.url
             source.app_jwt = session.cookies.get("JWT-APP")
-        except Exception as e:
+        except Exception:
             logger.error(f"Failed getting app info: {traceback.format_exc()}")
-            raise Exception(f"Failed getting app info: {traceback.format_exc()}") from e
+            return False
+        return True
 
     @staticmethod
     def is_expired(app_jwt: str) -> bool:
@@ -172,18 +180,16 @@ class DataloopContext:
         """
         Get the APP_JWT from the request headers or refresh if expired.
         """
+        if source.app_url is None:
+            raise ValueError("App URL is missing. Please set the app URL.")
         if source.app_jwt is None or self.is_expired(source.app_jwt):
             try:
                 session = requests.Session()
                 response = session.get(source.app_url, headers={'authorization': 'Bearer ' + token})
                 source.app_jwt = session.cookies.get("JWT-APP")
             except Exception:
-                logger.error(f"Failed getting app JWT from cookies\n{traceback.format_exc()}")
                 raise Exception(f"Failed getting app JWT from cookies\n{traceback.format_exc()}") from None
         if not source.app_jwt:
-            logger.error(
-                "APP_JWT is missing. Please set the APP_JWT environment variable or ensure authentication is working."
-            )
             raise ValueError(
                 "APP_JWT is missing. Please set the APP_JWT environment variable or ensure authentication is working."
             )
@@ -204,8 +210,7 @@ class DataloopContext:
         if source.server_url is None:
             logger.error("DataloopContext required for DPK servers")
             raise ValueError("DataloopContext required for DPK servers")
-        headers = {"Cookie": f"JWT-APP={source.app_jwt}",
-                   "x-dl-info": f"{self.token}"}
+        headers = {"Cookie": f"JWT-APP={source.app_jwt}", "x-dl-info": f"{self.token}"}
         async with streamablehttp_client(source.server_url, headers=headers) as (read, write, _):
             async with ClientSession(read, write, read_timeout_seconds=timedelta(seconds=60)) as session:
                 await session.initialize()
@@ -225,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.7 → dtlpymcp-0.1.9}/dtlpymcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtlpymcp
-Version: 0.1.7
+Version: 0.1.9
 Summary: STDIO MCP proxy server for Dataloop platform.
 Author-email: Your Name <your.email@example.com>
 Classifier: Programming Language :: Python :: 3.10
@@ -30,7 +30,14 @@ pip install git+<repository-url>
 You can run the proxy server via CLI:
 
 ```shell
+# Basic usage
 dtlpymcp start
+
+# With custom sources file
+dtlpymcp start --sources-file /path/to/sources.json
+
+# With custom initialization timeout (default: 30 seconds)
+dtlpymcp start --init-timeout 60.0
 ```
 
 Or using Python module syntax:
@@ -45,6 +52,14 @@ python -m dtlpymcp start
 - Install dependencies with `pip install -e .`
 - Run tests with `pytest`
 
+## Architecture
+
+The server uses a modular architecture with utilities for safe async initialization:
+
+- `dtlpymcp/proxy.py` - Main server implementation using FastMCP
+- `dtlpymcp/utils/server_utils.py` - Safe async initialization utilities
+- `dtlpymcp/utils/dtlpy_context.py` - Dataloop context management
+
 ## Cursor MCP Integration
 
 To add this MCP to Cursor, add the following to your configuration:

{dtlpymcp-0.1.7 → dtlpymcp-0.1.9}/dtlpymcp.egg-info/SOURCES.txt

@@ -3,7 +3,7 @@ README.md
 pyproject.toml
 dtlpymcp/__init__.py
 dtlpymcp/__main__.py
-dtlpymcp/default_sources.json
+dtlpymcp/min_proxy.py
 dtlpymcp/proxy.py
 dtlpymcp.egg-info/PKG-INFO
 dtlpymcp.egg-info/SOURCES.txt

{dtlpymcp-0.1.7 → dtlpymcp-0.1.9}/pyproject.toml

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

{dtlpymcp-0.1.7 → dtlpymcp-0.1.9}/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.7/dtlpymcp/__init__.py

@@ -1,7 +0,0 @@
-import os
-SOURCES_FILEPATH = os.path.join(os.path.dirname(__file__), "default_sources.json")
-
-from .utils.dtlpy_context import DataloopContext, MCPSource
-
-__version__ = "0.1.7"
-

dtlpymcp-0.1.7/dtlpymcp/default_sources.json

@@ -1,32 +0,0 @@
-[
-    {
-        "dpk_name": "dataloop-mcp-donna",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    },
-    {
-        "dpk_name": "dataloop-mcp-apis",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    },
-    {
-        "dpk_name": "dataloop-mcp-debug",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    },
-    {
-        "dpk_name": "dataloop-mcp-data",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    },
-    {
-        "dpk_name": "dataloop-mcp-dtlpy-sandbox",
-        "app_url": null,
-        "server_url": null,
-        "app_jwt": null
-    }
-]

dtlpymcp-0.1.7/dtlpymcp/proxy.py

@@ -1,101 +0,0 @@
-from pydantic_settings import BaseSettings, SettingsConfigDict
-from mcp.server.fastmcp import FastMCP, Context
-from typing import Any, Optional
-from datetime import datetime
-import traceback
-import logging
-import asyncio
-import os
-from pathlib import Path
-
-from dtlpymcp.utils.dtlpy_context import DataloopContext, SOURCES_FILEPATH
-
-# Setup logging to both console and file with timestamp
-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"))
-
-logging.basicConfig(level=logging.INFO, handlers=[file_handler, console_handler])
-logger = logging.getLogger("[DATALOOP-MCP]")
-
-
-class ServerSettings(BaseSettings):
-    """Settings for the Dataloop MCP server."""
-
-    model_config = SettingsConfigDict(env_prefix="MCP_DATALOOP_")
-
-    def __init__(self, **data):
-        super().__init__(**data)
-
-
-def create_dataloop_mcp_server(settings: ServerSettings, sources_file: str) -> 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,
-    )
-    dl_context = DataloopContext(token=os.environ.get('DATALOOP_API_KEY'), 
-                                 env=os.environ.get('DATALOOP_ENV', 'prod'),
-                                 sources_file=sources_file)
-    
-    # Initialize the Dataloop context
-    asyncio.run(dl_context.initialize())
-    
-    @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"}
-        if ping is not None:
-            result["ping"] = ping
-        return result
-
-    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 app
-
-
-def main(sources_file: Optional[str] = None) -> int:
-    logger.info("Starting Dataloop MCP server in stdio mode")
-    try:
-        settings = ServerSettings()
-        logger.info("Successfully configured Dataloop MCP server")
-    except Exception as e:
-        logger.error(f"Unexpected error during startup:\n{e}")
-        return 1
-    try:
-        if sources_file is None:
-            sources_file = SOURCES_FILEPATH
-        logger.info(f"Using sources file: {sources_file}")
-        mcp_server = create_dataloop_mcp_server(settings, sources_file)
-        logger.info("Starting Dataloop MCP server in stdio mode")
-        mcp_server.run(transport="stdio")
-        return 0
-    except Exception:
-        logger.error(f"Failed to start MCP server: {traceback.format_exc()}")
-        return 1
-
-
-if __name__ == "__main__":
-    main()