dtlpymcp 0.1.7__tar.gz

dtlpymcp-0.1.7/MANIFEST.in

@@ -0,0 +1 @@
+include dtlpymcp/default_sources.json 

dtlpymcp-0.1.7/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: dtlpymcp
+Version: 0.1.7
+Summary: STDIO MCP proxy server for Dataloop platform.
+Author-email: Your Name <your.email@example.com>
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dtlpy
+Requires-Dist: pydantic-settings
+Requires-Dist: mcp
+Requires-Dist: requests
+Requires-Dist: pyjwt
+Requires-Dist: makefun
+
+# Dataloop MCP Proxy Server
+
+This is the main proxy for the Dataloop Micro MCPs, installable as a Python package.
+
+## Installation
+
+```shell
+pip install git+<repository-url>
+```
+
+## Usage
+
+You can run the proxy server via CLI:
+
+```shell
+dtlpymcp start
+```
+
+Or using Python module syntax:
+
+```shell
+python -m dtlpymcp start
+```
+
+## Local Development
+
+- Requires Python 3.10+
+- Install dependencies with `pip install -e .`
+- Run tests with `pytest`
+
+## Cursor MCP Integration
+
+To add this MCP to Cursor, add the following to your configuration:
+
+### Docker Example
+```json
+{
+  "mcpServers": {
+    "dataloop-ai-mcp": {
+      "command": "docker run -i --rm -e DATALOOP_API_KEY docker.io/dataloopai/mcp:latest",
+      "env": {
+        "DATALOOP_API_KEY": "API KEY"
+      }
+    }
+  }
+}
+```
+
+### Local CLI Example
+```json
+{
+  "mcpServers": {
+    "dataloop-ai-mcp": {
+      "command": "uvx",
+      "args": ["dtlpymcp", "start"],
+      "env": {
+        "DATALOOP_ENV": "prod",
+        "DATALOOP_API_KEY": "API KEY"
+      }
+    }
+  }
+}
+```
+
+Replace `API KEY` with your actual Dataloop API key.

dtlpymcp-0.1.7/README.md

@@ -0,0 +1,65 @@
+# Dataloop MCP Proxy Server
+
+This is the main proxy for the Dataloop Micro MCPs, installable as a Python package.
+
+## Installation
+
+```shell
+pip install git+<repository-url>
+```
+
+## Usage
+
+You can run the proxy server via CLI:
+
+```shell
+dtlpymcp start
+```
+
+Or using Python module syntax:
+
+```shell
+python -m dtlpymcp start
+```
+
+## Local Development
+
+- Requires Python 3.10+
+- Install dependencies with `pip install -e .`
+- Run tests with `pytest`
+
+## Cursor MCP Integration
+
+To add this MCP to Cursor, add the following to your configuration:
+
+### Docker Example
+```json
+{
+  "mcpServers": {
+    "dataloop-ai-mcp": {
+      "command": "docker run -i --rm -e DATALOOP_API_KEY docker.io/dataloopai/mcp:latest",
+      "env": {
+        "DATALOOP_API_KEY": "API KEY"
+      }
+    }
+  }
+}
+```
+
+### Local CLI Example
+```json
+{
+  "mcpServers": {
+    "dataloop-ai-mcp": {
+      "command": "uvx",
+      "args": ["dtlpymcp", "start"],
+      "env": {
+        "DATALOOP_ENV": "prod",
+        "DATALOOP_API_KEY": "API KEY"
+      }
+    }
+  }
+}
+```
+
+Replace `API KEY` with your actual Dataloop API key.

dtlpymcp-0.1.7/dtlpymcp/__init__.py

@@ -0,0 +1,7 @@
+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/__main__.py

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

dtlpymcp-0.1.7/dtlpymcp/default_sources.json

@@ -0,0 +1,32 @@
+[
+    {
+        "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

@@ -0,0 +1,101 @@
+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()

dtlpymcp-0.1.7/dtlpymcp/utils/dtlpy_context.py

@@ -0,0 +1,244 @@
+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 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
+from mcp import ClientSession
+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__)
+
+
+class MCPSource(BaseModel):
+    dpk_name: Optional[str] = None
+    app_url: Optional[str] = None
+    server_url: Optional[str] = None
+    app_jwt: Optional[str] = None
+    tools: Optional[List[Tool]] = []
+
+
+class DataloopContext:
+    """
+    DataloopContext manages authentication, tool discovery, and proxy registration for Dataloop MCP servers.
+    Handles JWTs, server URLs, and dynamic tool registration for multi-tenant environments.
+    """
+
+    def __init__(self, token: str = None, sources_file: str = None, env: str = 'prod'):
+        self._token = token
+        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:    
+            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:
+            try:
+                if not isinstance(entry, dict):
+                    raise ValueError(f"Invalid source entry: {entry}")
+                logger.info(f"Adding MCP source: {entry.get('dpk_name')}, url: {entry.get('server_url')}")
+                await self.add_mcp_source(MCPSource(**entry))
+            except Exception as e:
+                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)
+        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}")
+        server_name, tools, call_fn = result
+        for tool in tools.tools:
+            tool_name = tool.name
+            ns_tool_name = f"{server_name}.{tool_name}"
+            description = tool.description
+            input_schema = tool.inputSchema
+
+            def build_handler(tool_name):
+                async def inner(**kwargs):
+                    fn = call_fn(tool_name, kwargs)
+                    return await fn()
+
+                return inner
+
+            dynamic_pydantic_model_params = self.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=build_handler(tool_name),
+                name=ns_tool_name,
+                description=description,
+                parameters=input_schema,
+                fn_metadata=resp,
+                is_async=True,
+                context_kwarg="ctx",
+                annotations=None,
+            )
+            mcp_source.tools.append(t)
+        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}")
+
+    @property
+    def token(self) -> str:
+        return self._token
+
+    @token.setter
+    def token(self, token: str):
+        self._token = token
+
+    def load_app_info(self, source: MCPSource) -> None:
+        """
+        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()))
+            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:
+            logger.error(f"Failed getting app info: {traceback.format_exc()}")
+            raise Exception(f"Failed getting app info: {traceback.format_exc()}") from e
+
+    @staticmethod
+    def is_expired(app_jwt: str) -> bool:
+        """
+        Check if the APP_JWT is expired.
+        """
+        try:
+            decoded = jwt.decode(app_jwt, options={"verify_signature": False})
+            if decoded.get("exp") < time.time():
+                return True
+            return False
+        except jwt.ExpiredSignatureError:
+            return True
+        except Exception as e:
+            logger.error(f"Error decoding JWT: {e}")
+            return True
+
+    def get_app_jwt(self, source: MCPSource, token: str) -> str:
+        """
+        Get the APP_JWT from the request headers or refresh if expired.
+        """
+        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."
+            )
+        return source.app_jwt
+
+    @staticmethod
+    def user_info(token: str) -> dict:
+        """
+        Decode a JWT token and return user info.
+        """
+        decoded = jwt.decode(token, options={"verify_signature": False})
+        return decoded
+
+    async def list_source_tools(self, source: MCPSource) -> Tuple[str, List[dict], Callable]:
+        """
+        Discover tools for a given source and return (server_name, list_of_tools, call_fn).
+        """
+        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}"}
+        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()
+                tools = await session.list_tools()
+
+                def call_fn(tool_name, kwargs):
+                    async def inner():
+                        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()
+                                return await session.call_tool(tool_name, kwargs)
+
+                    return inner
+
+                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):
+        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):
+        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"))
+            if name in required:
+                fields[name] = (py_type, Field(...))
+            else:
+                default = prop.get("default", None)
+                fields[name] = (py_type, Field(default=default))
+        return fields

dtlpymcp-0.1.7/dtlpymcp.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: dtlpymcp
+Version: 0.1.7
+Summary: STDIO MCP proxy server for Dataloop platform.
+Author-email: Your Name <your.email@example.com>
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dtlpy
+Requires-Dist: pydantic-settings
+Requires-Dist: mcp
+Requires-Dist: requests
+Requires-Dist: pyjwt
+Requires-Dist: makefun
+
+# Dataloop MCP Proxy Server
+
+This is the main proxy for the Dataloop Micro MCPs, installable as a Python package.
+
+## Installation
+
+```shell
+pip install git+<repository-url>
+```
+
+## Usage
+
+You can run the proxy server via CLI:
+
+```shell
+dtlpymcp start
+```
+
+Or using Python module syntax:
+
+```shell
+python -m dtlpymcp start
+```
+
+## Local Development
+
+- Requires Python 3.10+
+- Install dependencies with `pip install -e .`
+- Run tests with `pytest`
+
+## Cursor MCP Integration
+
+To add this MCP to Cursor, add the following to your configuration:
+
+### Docker Example
+```json
+{
+  "mcpServers": {
+    "dataloop-ai-mcp": {
+      "command": "docker run -i --rm -e DATALOOP_API_KEY docker.io/dataloopai/mcp:latest",
+      "env": {
+        "DATALOOP_API_KEY": "API KEY"
+      }
+    }
+  }
+}
+```
+
+### Local CLI Example
+```json
+{
+  "mcpServers": {
+    "dataloop-ai-mcp": {
+      "command": "uvx",
+      "args": ["dtlpymcp", "start"],
+      "env": {
+        "DATALOOP_ENV": "prod",
+        "DATALOOP_API_KEY": "API KEY"
+      }
+    }
+  }
+}
+```
+
+Replace `API KEY` with your actual Dataloop API key.

dtlpymcp-0.1.7/dtlpymcp.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+MANIFEST.in
+README.md
+pyproject.toml
+dtlpymcp/__init__.py
+dtlpymcp/__main__.py
+dtlpymcp/default_sources.json
+dtlpymcp/proxy.py
+dtlpymcp.egg-info/PKG-INFO
+dtlpymcp.egg-info/SOURCES.txt
+dtlpymcp.egg-info/dependency_links.txt
+dtlpymcp.egg-info/entry_points.txt
+dtlpymcp.egg-info/requires.txt
+dtlpymcp.egg-info/top_level.txt
+dtlpymcp/utils/dtlpy_context.py
+tests/test_context.py
+tests/test_custom_sources_file.py
+tests/test_list_platform_tools.py
+tests/test_proxy.py
+tests/test_run.py

dtlpymcp-0.1.7/dtlpymcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dtlpymcp-0.1.7/dtlpymcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dtlpymcp = dtlpymcp.__main__:main

dtlpymcp-0.1.7/dtlpymcp.egg-info/requires.txt

@@ -0,0 +1,6 @@
+dtlpy
+pydantic-settings
+mcp
+requests
+pyjwt
+makefun

dtlpymcp-0.1.7/dtlpymcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+dtlpymcp

dtlpymcp-0.1.7/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dtlpymcp"
+version = "0.1.7"
+description = "STDIO MCP proxy server for Dataloop platform."
+authors = [
+    { name = "Your Name", email = "your.email@example.com" }
+]
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "dtlpy",
+    "pydantic-settings",
+    "mcp",
+    "requests",
+    "pyjwt",
+    "makefun"
+]
+
+[project.scripts]
+dtlpymcp = "dtlpymcp.__main__:main"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+dtlpymcp = ["default_sources.json"] 

dtlpymcp-0.1.7/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dtlpymcp-0.1.7/tests/test_context.py

@@ -0,0 +1,34 @@
+from dtlpymcp import DataloopContext, MCPSource
+import requests
+import dtlpy as dl
+import asyncio
+
+
+def test_url_and_headers():
+    dl_context = DataloopContext(token=dl.token())
+    dl_context.add_mcp_source(MCPSource(dpk_name="dataloop-mcp", app_url=None, app_jwt=None, server_url=None))
+    print(dl_context.mcp_sources[0].app_jwt)
+    print(dl_context.mcp_sources[0].server_url)
+    print(dl_context.mcp_sources[0].app_url)
+    headers = {"Cookie": f"JWT-APP={dl_context.mcp_sources[0].app_jwt}", "x-dl-info": dl_context.token}
+    health_check_url = dl_context.mcp_sources[0].server_url.replace("/mcp/", "/health")
+    response = requests.get(health_check_url, headers=headers)
+    print(response.json())
+
+
+def test_discover_tools_for_server():
+    dl_context = DataloopContext(token=dl.token())
+    dl_context.add_mcp_source(MCPSource(dpk_name="dataloop-mcp", app_url=None, app_jwt=None, server_url=None))
+
+    result = asyncio.run(dl_context.discover_tools_for_server(dl_context.mcp_sources[0]))
+    print(result)
+
+
+if __name__ == "__main__":
+    import dtlpy as dl
+
+    dl.setenv('rc')
+    if dl.token_expired():
+        dl.login()
+    # test_url_and_headers()
+    test_discover_tools_for_server()

dtlpymcp-0.1.7/tests/test_custom_sources_file.py

@@ -0,0 +1,34 @@
+import asyncio
+import random
+import json
+import os
+from datetime import timedelta
+from mcp.client.stdio import stdio_client
+from mcp import ClientSession, StdioServerParameters
+import dtlpy as dl
+
+# Create server parameters for stdio connection
+server_params = StdioServerParameters(
+    command="dtlpymcp",  # Executable
+    args=["start", "-s", "tests/assets/sources.json"],  # Command line arguments
+    env=None,  # 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)
+            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!"
+            assert json.loads(tool_result.content[0].text).get("ping") == num, "Ping failed!"
+
+if __name__ == "__main__":
+    dl.setenv('rc')
+    if dl.token_expired():
+        dl.login()
+    asyncio.run(test_health_check()) 
+    # asyncio.run(test_ask_dataloop()) 

dtlpymcp-0.1.7/tests/test_list_platform_tools.py

@@ -0,0 +1,36 @@
+import asyncio
+import random
+import json
+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')
+if dl.token_expired():
+    dl.login()
+# Create server parameters for stdio connection
+server_params = StdioServerParameters(
+    command="dtlpymcp",  # Executable
+    args=["start"],  # Command line arguments
+    env={"DATALOOP_API_KEY": dl.token()},  # Optional environment variables
+    cwd=os.getcwd()
+)
+
+async def test_list_platform_tools():
+    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()
+            tools = await session.list_tools()
+            for tool in tools.tools:
+                tool_str = '   \n'.join([f"{k}: {v}" for k, v in tool.model_dump().items()])
+                print(f"Tool: {tool.name}")
+                print(tool_str)
+                print("-" * 50)
+
+if __name__ == "__main__":
+
+    asyncio.run(test_list_platform_tools()) 
+    # asyncio.run(test_ask_dataloop()) 

dtlpymcp-0.1.7/tests/test_proxy.py

@@ -0,0 +1,39 @@
+import asyncio
+import random
+import json
+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')
+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
+    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)
+            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!"
+            assert json.loads(tool_result.content[0].text).get("ping") == num, "Ping failed!"
+
+
+if __name__ == "__main__":
+
+    asyncio.run(test_health_check())
+    # asyncio.run(test_ask_dataloop())

dtlpymcp-0.1.7/tests/test_run.py

@@ -0,0 +1,15 @@
+from dtlpymcp.proxy import main
+import dtlpy as dl
+import os
+dl.setenv('rc')
+if dl.token_expired():
+    dl.login()
+os.environ["DATALOOP_API_KEY"] = dl.token()
+main()
+
+
+
+
+
+
+