iflow-mcp_modal-mcp-toolbox 0.1.12__py3-none-any.whl

iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_modal-mcp-toolbox
+Version: 0.1.12
+Summary: A collection of Model Context Protocol (MCP) tools for Modal
+Author-email: Philipp Eisen <hello@philippeisen.de>
+License-File: LICENSE
+Requires-Python: <3.13,>=3.10
+Requires-Dist: mcp>=1.3.0
+Requires-Dist: modal>=0.73.43
+Description-Content-Type: text/markdown
+
+# Modal MCP Toolbox 🛠️
+
+[![smithery badge](https://smithery.ai/badge/@philipp-eisen/modal-mcp-toolbox)](https://smithery.ai/server/@philipp-eisen/modal-mcp-toolbox)
+
+A collection of Model Context Protocol (MCP) tools that run on Modal.
+This let's you extend the capabilities of your LLM in tools such as [Goose](https://block.github.io/goose/) or the [Claude Desktop App](https://claude.ai/download).
+
+<a href="https://glama.ai/mcp/servers/ai78w0p5mc"><img width="380" height="200" src="https://glama.ai/mcp/servers/ai78w0p5mc/badge" alt="Modal Toolbox MCP server" /></a>
+
+## Tools
+
+- `run_python_code_in_sandbox`: Let's you run python code in a sandboxed environment.
+- `generate_flux_image`: Generate an image using the FLUX model.
+
+## Demo
+
+### Flux Image Generation
+
+![🎬Flux Image Generation](./assets/flux.gif)
+
+### Python Code Execution
+
+![🎬Python Code Execution](./assets/python-sandbox.gif)
+
+## Prerequisites
+
+- A [modal account](https://modal.com/signup) and a configured modal CLI.
+- [UV](https://github.com/astral-sh/uv?tab=readme-ov-file#installation)
+- A client that supports MCP. Such as the [Claude Desktop App](https://claude.ai/download) or [Goose](https://block.github.io/goose/)
+
+This runs against your modal account, so you will need to have a modal account and be logged in.
+
+## Installation
+
+Installation depends on the client that uses the MCP. Here is instructions for Claude and Goose.
+
+### Claude
+
+Got to `Settings > Developer` in the Claude Desktop App. And click on Edit Config.
+![🖼️Claude Settings](./assets/claude-settings.png)
+
+Add the config for the mcp server. My config looks like this:
+
+```json
+{
+  "mcpServers": {
+    "modal-toolbox": {
+      "command": "uvx",
+      "args": ["modal-mcp-toolbox"]
+    }
+  }
+}
+```
+
+### Goose
+
+Go to `Settings` and Click on Add.
+
+![🖼️Goose Settings](./assets/goose-settings-1.png)
+
+Then add an extension like in the screenshot below.
+The important part is to set command to:
+
+```
+uvx modal-mcp-toolbox
+```
+
+The rest you can fill in as you like.
+
+![🖼️Goose MCP Settings](./assets/goose-settings-2.png)
+
+### Installing via Smithery (not working currently)
+
+To install Modal MCP Toolbox for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@philipp-eisen/modal-mcp-toolbox):
+
+```bash
+npx -y @smithery/cli install @philipp-eisen/modal-mcp-toolbox --client claude
+```

iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/RECORD

@@ -0,0 +1,9 @@
+modal_mcp_toolbox/__init__.py,sha256=7CI-2YSApcw-itJA6uABy_iL42CB_vFf2DKwK3qd8jk,857
+modal_mcp_toolbox/__main__.py,sha256=7pRdxSEidTQ4IciFf6qBuhweD8klMGdKTGiNxc6Nce0,43
+modal_mcp_toolbox/code.py,sha256=jCaTiQuJ4kBM6WmAQA51K2u3BwP7mxQuWw3t7Iepa7g,3012
+modal_mcp_toolbox/flux.py,sha256=zJyyhcSgWrBBQBd375hTgNrcgesQzd7b6sHjKE9zFlo,5396
+iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/METADATA,sha256=Gdz-SHxhD_0hfIdw6X71b2DoSM6mIxQPJ5z_8tfQPiw,2721
+iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/entry_points.txt,sha256=RLhgHKt9SLV7sY5yzLQkDXy8PYr9IKW3nDRSbOUGF58,61
+iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/licenses/LICENSE,sha256=n0FejJtmhOuaIfMIXu7XNk044eH1Kmh89jjHfYrHekQ,1070
+iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/RECORD,,

iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+modal-mcp-toolbox = modal_mcp_toolbox:main

iflow_mcp_modal_mcp_toolbox-0.1.12.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Philipp Eisen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

modal_mcp_toolbox/__init__.py

@@ -0,0 +1,29 @@
+import argparse
+import logging
+from importlib.metadata import version
+
+from mcp.server.fastmcp import FastMCP
+
+from modal_mcp_toolbox.code import run_python_code_in_sandbox
+from modal_mcp_toolbox.flux import generate_flux_image
+
+server = FastMCP("modal-toolbox")
+
+server.add_tool(run_python_code_in_sandbox)
+server.add_tool(generate_flux_image)
+
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """MCP Modal Sandbox: A sandbox for running python code in a safe environment."""
+    parser = argparse.ArgumentParser(description="A sandbox for running python code in a safe environment.")
+    parser.add_argument("--version", action="version", version=version("iflow-mcp_modal-mcp-toolbox"))
+    parser.parse_args()
+    server.run()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler()])
+    main()

modal_mcp_toolbox/__main__.py

@@ -0,0 +1,3 @@
+from modal_mcp_toolbox import main
+
+main()

modal_mcp_toolbox/code.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+from typing import Annotated
+
+import modal
+from mcp import ErrorData, McpError
+from mcp.types import INVALID_PARAMS, Annotations, TextContent
+from pydantic import Field
+
+
+async def run_python_code_in_sandbox(
+    code: Annotated[str, Field(description="The python code to run.")],
+    requirements: Annotated[list[str] | None, Field(description="The requirements to install.")] = None,
+    python_version: Annotated[str, Field(description="The python version to use. If not provided defaults to 3.13")] = "3.13",
+    mount_directory: Annotated[
+        str | None,
+        Field(
+            description="Allows you to make a local directory available at `/mounted-dir` for the code in `code`. Needs to be an absolute path. "
+            "Writes to this directory will NOT be reflected in the local directory."
+        ),
+    ] = None,
+    pull_files: Annotated[
+        list[tuple[str, str]] | None,
+        Field(
+            description="List of tuples (absolut_path_sandbox_file, absolute_path_local_file). "
+            "When provided downloads the file(s) from the sandbox to the local file(s)."
+        ),
+    ] = None,
+) -> TextContent:
+    """
+    Runs python code in a safe environment and returns the output.
+
+    Usage:
+       run_python_code_in_sandbox("print('Hello, world!')")
+       run_python_code_in_sandbox("import requests\nprint(requests.get('https://icanhazip.com').text)", requirements=["requests"])
+    """
+
+    app = modal.App.lookup("mcp-toolbox--code", create_if_missing=True)
+    image = modal.Image.debian_slim(python_version=python_version).pip_install(requirements or [])
+
+    mounts: list[modal.Mount] = []
+    if mount_directory:
+        mounts.append(modal.Mount.from_local_dir(mount_directory, remote_path="/mounted-dir"))
+
+    sb = modal.Sandbox.create(image=image, app=app, mounts=mounts)
+    try:
+        exc = sb.exec("python", "-c", code)
+        exc.wait()
+        if exc.returncode != 0:
+            stderr = exc.stderr.read()
+            raise McpError(
+                ErrorData(
+                    code=INVALID_PARAMS,
+                    message=f"Error running code:\n{stderr}",
+                )
+            )
+
+        if pull_files:
+            for remote_file, local_file in pull_files:
+                if not Path(local_file).parent.exists():
+                    Path(local_file).parent.mkdir(parents=True, exist_ok=True)
+
+                if Path(local_file).exists():
+                    raise McpError(
+                        ErrorData(
+                            code=INVALID_PARAMS,
+                            message=f"File {local_file} already exists.",
+                        )
+                    )
+                with sb.open(remote_file, "rb") as f:
+                    with open(local_file, "wb") as f2:
+                        f2.write(f.read())
+        return TextContent(type="text", text=exc.stdout.read(), annotations=Annotations(audience=["user", "assistant"], priority=0.5))
+
+    finally:
+        sb.terminate()

modal_mcp_toolbox/flux.py

@@ -0,0 +1,168 @@
+# based on https://github.com/modal-labs/modal-examples/blob/main/06_gpu_and_ml/stable_diffusion/flux.py
+import logging
+from importlib.metadata import PackageNotFoundError, version
+from io import BytesIO
+from typing import Annotated
+
+import modal
+from mcp.server.fastmcp import Context, Image
+from mcp.types import Annotations, ImageContent
+from modal.exception import NotFoundError
+from modal.runner import deploy_app
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+MINUTES = 60  # seconds
+VARIANT = "schnell"  # or "dev", but note [dev] requires you to accept terms and conditions on HF
+NUM_INFERENCE_STEPS = 4  # use ~50 for [dev], smaller for [schnell]
+IMAGE_FORMAT = "JPEG"
+
+
+cuda_version = "12.4.0"  # should be no greater than host CUDA version
+flavor = "devel"  # includes full CUDA toolkit
+operating_sys = "ubuntu22.04"
+tag = f"{cuda_version}-{flavor}-{operating_sys}"
+
+cuda_dev_image = modal.Image.from_registry(f"nvidia/cuda:{tag}", add_python="3.11").entrypoint([])
+diffusers_commit_sha = "81cf3b2f155f1de322079af28f625349ee21ec6b"
+
+flux_image = (
+    cuda_dev_image.apt_install(
+        "git",
+        "libglib2.0-0",
+        "libsm6",
+        "libxrender1",
+        "libxext6",
+        "ffmpeg",
+        "libgl1",
+    )
+    .pip_install(
+        "invisible_watermark==0.2.0",
+        "transformers==4.44.0",
+        "huggingface_hub[hf_transfer]==0.26.2",
+        "accelerate==0.33.0",
+        "safetensors==0.4.4",
+        "sentencepiece==0.2.0",
+        "torch==2.5.0",
+        f"git+https://github.com/huggingface/diffusers.git@{diffusers_commit_sha}",
+        "numpy<2",
+        # This is a bit of a hack to ensure that the the version modal-mcp-toolbox is the same as the local version.
+        # -- not really ideal
+        f"iflow-mcp_modal-mcp-toolbox=={version('iflow-mcp_modal-mcp-toolbox')}",
+    )
+    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1", "HF_HUB_CACHE": "/cache"})
+)
+
+
+flux_image = flux_image.env(
+    {
+        "TORCHINDUCTOR_CACHE_DIR": "/root/.inductor-cache",
+        "TORCHINDUCTOR_FX_GRAPH_CACHE": "1",
+    }
+)
+
+
+app_name = "mcp-toolbox--flux"
+app = modal.App(app_name, image=flux_image)
+
+with flux_image.imports():
+    import torch
+    from diffusers import FluxPipeline
+
+
+@app.cls(
+    gpu="L40S",
+    scaledown_window=5 * MINUTES,
+    image=flux_image,
+    volumes={
+        "/cache": modal.Volume.from_name("hf-hub-cache", create_if_missing=True),
+    },
+    enable_memory_snapshot=True,
+)
+class Model:
+    @modal.enter(snap=True)
+    def load(self):
+        print("🔄 loading model...")
+        pipe = FluxPipeline.from_pretrained(f"black-forest-labs/FLUX.1-{VARIANT}", torch_dtype=torch.bfloat16)
+        self.pipe = _optimize(pipe)
+
+    @modal.enter(snap=False)
+    def setup(self):
+        print("🔄 moving model to GPU...")
+        self.pipe = self.pipe.to("cuda")
+
+    @modal.method()
+    def inference(self, prompt: str) -> bytes:
+        print("🎨 generating image...")
+        out = self.pipe(
+            prompt,
+            output_type="pil",
+            num_inference_steps=NUM_INFERENCE_STEPS,
+        ).images[0]
+
+        byte_stream = BytesIO()
+        out.save(byte_stream, format=IMAGE_FORMAT)
+        return byte_stream.getvalue()
+
+
+@app.function(
+    # This is a bit of a hack to ensure that the the version modal-mcp-toolbox is the same as the local version.
+    # -- not really ideal
+    image=modal.Image.debian_slim().pip_install(f"iflow-mcp_modal-mcp-toolbox=={version('iflow-mcp_modal-mcp-toolbox')}"),
+    scaledown_window=5 * MINUTES,
+)
+def get_version():
+    try:
+        print("modal_mcp_toolbox version:", version("modal_mcp_toolbox"))
+        return version("modal_mcp_toolbox")
+    except PackageNotFoundError:
+        print("modal_mcp_toolbox version: unknown")
+        return "unknown"
+
+
+def _optimize(pipe):
+    # fuse QKV projections in Transformer and VAE
+    pipe.transformer.fuse_qkv_projections()
+    pipe.vae.fuse_qkv_projections()
+
+    # switch memory layout to Torch's preferred, channels_last
+    pipe.transformer.to(memory_format=torch.channels_last)
+    pipe.vae.to(memory_format=torch.channels_last)
+
+    return pipe
+
+
+async def _ensure_app_deployment_is_up_to_date(ctx: Context):
+    try:
+        fn = modal.Function.from_name(app_name, "get_version")
+        remote_version = await fn.remote.aio()
+
+        if remote_version != version("iflow-mcp_modal-mcp-toolbox"):
+            await ctx.info("App is out of date. Deploying ...")
+            logger.info("App is out of date. Deploying ...")
+            deploy_app(app)
+    except NotFoundError:
+        await ctx.info("App not found. Deploying...")
+        logger.info("App not found. Deploying...")
+        deploy_app(app)
+
+
+async def generate_flux_image(prompt: Annotated[str, Field(description="The prompt to generate an image for")], ctx: Context) -> ImageContent:
+    """Let's you generate an image using the Flux model."""
+    await _ensure_app_deployment_is_up_to_date(ctx)
+
+    cls = modal.Cls.from_name(app_name, Model.__name__)
+    image_bytes = await cls().inference.remote.aio(prompt)
+    image_content = Image(data=image_bytes, format=IMAGE_FORMAT).to_image_content()
+    image_content.annotations = Annotations(audience=["user", "assistant"], priority=0.5)
+    return image_content
+
+
+if __name__ == "__main__":
+    deploy_app(app)
+
+
+@app.local_entrypoint()
+async def main():
+    print(await get_version.remote.aio())