media-agent-mcp 0.3.2__tar.gz → 0.3.4__tar.gz

{media_agent_mcp-0.3.2 → media_agent_mcp-0.3.4}/PKG-INFO

@@ -1,27 +1,27 @@
 Metadata-Version: 2.4
 Name: media-agent-mcp
-Version: 0.3.2
+Version: 0.3.4
 Summary: A Model Context Protocol server for media processing with AI tools
 Author-email: Media Agent Team <team@mediaagent.com>
-Keywords: ai,image,mcp,media,processing,video
+Keywords: mcp,ai,media,video,image,processing
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.12
+Description-Content-Type: text/markdown
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: mcp[cli]>=1.12.2
-Requires-Dist: numpy>=1.24.0
 Requires-Dist: opencv-python>=4.12.0.88
 Requires-Dist: pillow>=11.3.0
-Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: requests>=2.32.4
 Requires-Dist: tos>=2.7.1
 Requires-Dist: uvicorn>=0.32.1
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: volcengine-python-sdk>=1.0.0
 Requires-Dist: volcengine>=1.0.194
-Description-Content-Type: text/markdown
 
 # Media Agent MCP
 
@@ -492,4 +492,4 @@ MIT License
 **版本**: 0.1.0  
 **状态**: Alpha  
 **Python要求**: >= 3.12  
-**维护者**: Media Agent Team
+**维护者**: Media Agent Team

{media_agent_mcp-0.3.2 → media_agent_mcp-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "media-agent-mcp"
-version = "0.3.2"
+version = "0.3.4"
 description = "A Model Context Protocol server for media processing with AI tools"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -30,11 +30,4 @@ dependencies = [
 ]
 
 [project.scripts]
-media-agent-mcp = "media_agent_mcp.server:main"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/media_agent_mcp"]
+media-agent-mcp = "media_agent_mcp.async_server:main"

media_agent_mcp-0.3.4/setup.cfg

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

{media_agent_mcp-0.3.2 → media_agent_mcp-0.3.4}/src/media_agent_mcp/__init__.py

@@ -2,6 +2,8 @@
 
 from . import ai_models, media_selectors, storage, video
 from .server import main
+from .async_server import main as async_main
+from . import async_wrapper
 
 __version__ = "0.1.0"
-__all__ = ['ai_models', 'selectors', 'storage', 'video', 'main']
+__all__ = ['ai_models', 'media_selectors', 'storage', 'video', 'main', 'async_main', 'async_wrapper']

media_agent_mcp-0.3.4/src/media_agent_mcp/async_server.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""Async Media Agent MCP Server - A Model Context Protocol server for media processing with async support.
+
+This server provides 9 async tools for media processing using threading:
+1. TOS - Save content as URL
+2. Video Concat - Concatenate two videos
+3. Video Last Frame - Get the last frame from a video
+4. Seedream - Creating images (AI model)
+5. Seedance (lite & pro) - Creating videos (AI model)
+6. Seededit - Maintain the main character (AI model)
+7. Seed1.6 (VLM) - Do vision tasks in workflow (AI model)
+8. Image Selector - Choose the best one from images
+9. Video Selector - Choose the best video from videos
+
+All tools are wrapped with threading to provide async functionality without modifying original functions.
+"""
+
+import argparse
+import asyncio
+import logging
+from typing import List, Optional
+import json
+from dotenv import load_dotenv
+import uvicorn
+
+from mcp.server.fastmcp import FastMCP
+
+# Import async wrappers
+from media_agent_mcp.async_wrapper import (
+    async_video_concat_tool,
+    async_video_last_frame_tool,
+    async_seedream_generate_image_tool,
+    async_seedance_generate_video_tool,
+    async_seededit_tool,
+    async_vlm_vision_task_tool,
+    async_image_selector_tool,
+    async_video_selector_tool,
+    async_tos_save_content_tool,
+    cleanup_executor
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize FastMCP server (will be configured in main function)
+load_dotenv()
+mcp = FastMCP("Media-Agent-MCP-Async")
+
+
+@mcp.tool()
+async def video_concat_tool_async(video_urls: List[str]) -> str:
+    """
+    Asynchronously concatenate multiple videos from URLs and upload to TOS.
+    
+    Args:
+        video_urls: List of video URLs to concatenate in order
+    
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_video_concat_tool(video_urls)
+
+
+@mcp.tool()
+async def video_last_frame_tool_async(video_url: str) -> str:
+    """
+    Asynchronously extract the last frame from a video file and upload to TOS.
+    
+    Args:
+        video_url: URL or path to the video file
+        
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_video_last_frame_tool(video_url)
+
+
+@mcp.tool()
+async def seedream_generate_image_tool_async(prompt: str, size: str = "1024x1024") -> str:
+    """
+    Asynchronously generate an image using Seedream AI model.
+    
+    Args:
+        prompt: Text description of the image to generate
+        size: Size of the image (e.g., "1024x1024")
+    
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_seedream_generate_image_tool(prompt, size)
+
+
+@mcp.tool()
+async def seedance_generate_video_tool_async(prompt: str, first_frame_image: str, 
+                                            last_frame_image: str = None, duration: int = 5, 
+                                            resolution: str = "720p") -> str:
+    """
+    Asynchronously generate a video using Seedance AI model with first/last frame images.
+    
+    Args:
+        prompt: Text description of the video to generate (optional for image-to-video)
+        first_frame_image: URL or base64 of the first frame image
+        last_frame_image: URL or base64 of the last frame image (optional)
+        duration: Duration of the video in seconds (5 or 10)
+        resolution: Video resolution (480p, 720p)
+    
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_seedance_generate_video_tool(prompt, first_frame_image, last_frame_image, duration, resolution)
+
+
+@mcp.tool()
+async def seededit_tool_async(image_url: str, prompt: str, seed: int = -1, 
+                             scale: float = 0.5, charactor_keep: bool = False) -> str:
+    """
+    Asynchronously edit an image using Seededit model.
+    
+    Args:
+        image_url: Input image URL for editing
+        prompt: Text prompt for image editing
+        seed: Random seed for reproducibility (-1 for random)
+        scale: Influence degree of text description (0-1)
+        charactor_keep: whether to keep the main character in this image, if you wanna change the main character, please keep False
+        
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_seededit_tool(image_url, prompt, seed, scale, charactor_keep)
+
+
+@mcp.tool()
+async def vlm_vision_task_tool_async(messages: List) -> str:
+    """
+    Asynchronously perform vision-language tasks using VLM model.
+    
+    Args:
+        messages: OpenAI-compatible messages format
+        
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_vlm_vision_task_tool(messages)
+
+
+@mcp.tool()
+async def image_selector_tool_async(image_paths: List[str], prompt: str) -> str:
+    """
+    Asynchronously select the best image from multiple options using VLM model.
+    
+    Args:
+        image_paths: List of paths to image files
+        prompt: Selection criteria prompt
+        
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_image_selector_tool(image_paths, prompt)
+
+
+@mcp.tool()
+async def video_selector_tool_async(video_paths: List[str], prompt: str) -> str:
+    """
+    Asynchronously select the best video from multiple options using VLM model.
+    
+    Args:
+        video_paths: List of paths to videos to choose from
+        prompt: Selection criteria prompt
+    
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_video_selector_tool(video_paths, prompt)
+
+
+@mcp.tool()
+async def tos_save_content_tool_async(content: str, file_extension: str = "txt", 
+                                     object_key: Optional[str] = None) -> str:
+    """
+    Asynchronously save content to TOS and return URL.
+    
+    Args:
+        content: Content to save
+        file_extension: File extension for the content (default: txt)
+        object_key: Optional key to use for the object in TOS
+        
+    Returns:
+        JSON string with status, data, and message
+    """
+    return await async_tos_save_content_tool(content, file_extension, object_key)
+
+
+# Utility function for concurrent execution
+async def run_multiple_tools_concurrently(*coroutines):
+    """
+    Run multiple async tools concurrently.
+    
+    Args:
+        *coroutines: Variable number of coroutines to run concurrently
+        
+    Returns:
+        List of results from all coroutines
+    """
+    return await asyncio.gather(*coroutines, return_exceptions=True)
+
+
+# Example usage function
+async def example_concurrent_usage():
+    """
+    Example of how to use multiple tools concurrently.
+    """
+    # Example: Generate image and process video concurrently
+    image_task = seedream_generate_image_tool_async("A beautiful sunset", "1024x1024")
+    video_task = video_last_frame_tool_async("https://example.com/video.mp4")
+    
+    # Run both tasks concurrently
+    results = await run_multiple_tools_concurrently(image_task, video_task)
+    
+    return results
+
+
+def main():
+    """Main entry point for the Async MCP server."""
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='Async Media Agent MCP Server')
+    parser.add_argument('--transport', type=str, choices=['sse', 'stdio'], default='sse',
+                        help='Transport method: sse or stdio (default: sse)')
+    parser.add_argument('--host', type=str, default='127.0.0.1',
+                        help='Host for SSE transport (default: 127.0.0.1)')
+    parser.add_argument('--port', type=int, default=8000,
+                        help='Port for SSE transport (default: 8001)')
+    parser.add_argument('--version', action='store_true',
+                        help='Show version information')
+    
+    args = parser.parse_args()
+    
+    if args.version:
+        print("Async Media Agent MCP Server v0.1.0")
+        return
+    
+    logger.info("Starting Async Media Agent MCP Server...")
+    logger.info(f"Transport: {args.transport}")
+    if args.transport == 'sse':
+        logger.info(f"SSE Server will run on {args.host}:{args.port}")
+    
+    logger.info("Available async tools:")
+    logger.info("  1. video_last_frame_tool_async - Extract last frame from video and upload to TOS")
+    logger.info("  2. video_concat_tool_async - Concatenate two videos")
+    logger.info("  3. seedream_generate_image_tool_async - Generate images with AI (async)")
+    logger.info("  4. seedance_generate_video_tool_async - Generate videos with AI (async)")
+    logger.info("  5. seededit_tool_async - Edit images while maintaining character (async)")
+    logger.info("  6. vlm_vision_task_tool_async - Perform vision tasks with OpenAI-compatible messages (async)")
+    logger.info("  7. image_selector_tool_async - Select best image using VLM model (async)")
+    logger.info("  8. video_selector_tool_async - Select best video using VLM model (async)")
+    logger.info("  9. tos_save_content_tool_async - Save content to TOS and return URL (async)")
+    logger.info("")
+    logger.info("All tools support concurrent execution using asyncio.gather() or run_multiple_tools_concurrently()")
+    
+    try:
+        # Start the server with specified transport
+        if args.transport == 'sse':
+            logger.info(f"Starting async SSE server on {args.host}:{args.port}")
+            mcp.settings.host = args.host
+            mcp.settings.port = args.port
+            mcp.run(transport="sse")
+        else:
+            # Default stdio transport
+            mcp.run(transport="stdio")
+    finally:
+        # Clean up thread pool executor on shutdown
+        logger.info("Cleaning up thread pool executor...")
+        cleanup_executor()
+
+
+if __name__ == "__main__":
+    main()

media_agent_mcp-0.3.4/src/media_agent_mcp/async_wrapper.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""Async wrapper module for MCP tools using threading.
+
+This module provides async wrappers for all MCP tools without modifying the original functions.
+It uses threading to make synchronous functions asynchronous.
+"""
+
+import asyncio
+import concurrent.futures
+import functools
+import json
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+# Import original functions
+from media_agent_mcp.storage import upload_to_tos
+from media_agent_mcp.video import concat_videos, extract_last_frame
+from media_agent_mcp.ai_models.seedream import generate_image
+from media_agent_mcp.ai_models.seedance import generate_video
+from media_agent_mcp.ai_models.seededit import seededit
+from media_agent_mcp.media_selectors.image_selector import select_best_image
+from media_agent_mcp.media_selectors.video_selector import select_best_video
+
+logger = logging.getLogger(__name__)
+
+# Thread pool executor for running sync functions
+_executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
+
+
+def async_wrapper(sync_func: Callable) -> Callable:
+    """Decorator to wrap synchronous functions as async using threading.
+    
+    Args:
+        sync_func: The synchronous function to wrap
+        
+    Returns:
+        Async version of the function
+    """
+    @functools.wraps(sync_func)
+    async def wrapper(*args, **kwargs):
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(_executor, sync_func, *args, **kwargs)
+    return wrapper
+
+
+def json_response_wrapper(func: Callable) -> Callable:
+    """Wrapper to ensure consistent JSON response format.
+    
+    Args:
+        func: Function to wrap
+        
+    Returns:
+        Function that returns JSON string
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            result = func(*args, **kwargs)
+            if isinstance(result, dict):
+                return json.dumps(result)
+            else:
+                # Handle legacy string returns
+                if result.startswith("Error:"):
+                    return json.dumps({
+                        "status": "error",
+                        "data": None,
+                        "message": result
+                    })
+                else:
+                    return json.dumps({
+                        "status": "success",
+                        "data": {"url": result},
+                        "message": "Operation completed successfully"
+                    })
+        except Exception as e:
+            logger.error(f"Error in {func.__name__}: {str(e)}")
+            return json.dumps({
+                "status": "error",
+                "data": None,
+                "message": f"Error: {str(e)}"
+            })
+    return wrapper
+
+
+# Async wrapped functions
+@async_wrapper
+@json_response_wrapper
+def _sync_video_concat(video_urls: List[str]) -> str:
+    """Synchronous video concatenation wrapper."""
+    return concat_videos(video_urls)
+
+
+@async_wrapper
+@json_response_wrapper
+def _sync_video_last_frame(video_url: str) -> str:
+    """Synchronous video last frame extraction wrapper."""
+    return extract_last_frame(video_url)
+
+
+@async_wrapper
+@json_response_wrapper
+def _sync_seedream_generate_image(prompt: str, size: str = "1024x1024") -> str:
+    """Synchronous image generation wrapper."""
+    return generate_image(prompt, size=size)
+
+
+@async_wrapper
+@json_response_wrapper
+def _sync_seedance_generate_video(prompt: str, first_frame_image: str, 
+                                 last_frame_image: str = None, duration: int = 5, 
+                                 resolution: str = "720p") -> str:
+    """Synchronous video generation wrapper."""
+    if not prompt and not first_frame_image:
+        return json.dumps({
+            "status": "error",
+            "data": None,
+            "message": "Error: Either prompt or first_frame_image must be provided"
+        })
+    
+    return generate_video(
+        prompt=prompt,
+        first_frame_image=first_frame_image,
+        last_frame_image=last_frame_image,
+        duration=duration,
+        resolution=resolution
+    )
+
+
+@async_wrapper
+@json_response_wrapper
+def _sync_seededit(image_url: str, prompt: str, seed: int = -1, 
+                  scale: float = 0.5, charactor_keep: bool = False) -> str:
+    """Synchronous image editing wrapper."""
+    return seededit(
+        image_url=image_url,
+        prompt=prompt,
+        charactor_keep=charactor_keep,
+        return_url=True,
+        scale=scale,
+        seed=seed
+    )
+
+
+@async_wrapper
+@json_response_wrapper
+def _sync_vlm_vision_task(messages: List) -> str:
+    """Synchronous VLM vision task wrapper."""
+    from media_agent_mcp.ai_models.seed16 import process_vlm_task
+    return process_vlm_task(messages)
+
+
+@async_wrapper
+def _sync_image_selector(image_paths: List[str], prompt: str) -> str:
+    """Synchronous image selector wrapper."""
+    try:
+        result = select_best_image(image_paths, prompt)
+        return json.dumps({
+            "status": "success",
+            "data": result,
+            "message": "Image selection completed successfully"
+        })
+    except Exception as e:
+        return json.dumps({
+            "status": "error",
+            "data": None,
+            "message": f"Image selection failed: {str(e)}"
+        })
+
+
+@async_wrapper
+def _sync_video_selector(video_paths: List[str], prompt: str) -> str:
+    """Synchronous video selector wrapper."""
+    try:
+        result = select_best_video(video_paths, prompt)
+        return json.dumps({
+            "status": "success",
+            "data": result,
+            "message": "Video selection completed successfully"
+        })
+    except Exception as e:
+        return json.dumps({
+            "status": "error",
+            "data": None,
+            "message": f"Video selection failed: {str(e)}"
+        })
+
+
+@async_wrapper
+def _sync_tos_save_content(content: str, file_extension: str = "txt", 
+                          object_key: Optional[str] = None) -> str:
+    """Synchronous TOS content save wrapper."""
+    import tempfile
+    import os
+    
+    try:
+        # Create temporary file with content
+        with tempfile.NamedTemporaryFile(mode='w', suffix=f'.{file_extension}', delete=False) as temp_file:
+            temp_file.write(content)
+            temp_file_path = temp_file.name
+        
+        try:
+            # Upload to TOS
+            result = upload_to_tos(temp_file_path, object_key)
+            return json.dumps(result)
+        finally:
+            # Clean up temporary file
+            if os.path.exists(temp_file_path):
+                os.unlink(temp_file_path)
+                
+    except Exception as e:
+        return json.dumps({
+            "status": "error",
+            "data": None,
+            "message": f"TOS save failed: {str(e)}"
+        })
+
+
+# Public async API
+async def async_video_concat_tool(video_urls: List[str]) -> str:
+    """Async video concatenation tool."""
+    return await _sync_video_concat(video_urls)
+
+
+async def async_video_last_frame_tool(video_url: str) -> str:
+    """Async video last frame extraction tool."""
+    return await _sync_video_last_frame(video_url)
+
+
+async def async_seedream_generate_image_tool(prompt: str, size: str = "1024x1024") -> str:
+    """Async image generation tool."""
+    return await _sync_seedream_generate_image(prompt, size)
+
+
+async def async_seedance_generate_video_tool(prompt: str, first_frame_image: str, 
+                                            last_frame_image: str = None, duration: int = 5, 
+                                            resolution: str = "720p") -> str:
+    """Async video generation tool."""
+    return await _sync_seedance_generate_video(prompt, first_frame_image, last_frame_image, duration, resolution)
+
+
+async def async_seededit_tool(image_url: str, prompt: str, seed: int = -1, 
+                             scale: float = 0.5, charactor_keep: bool = False) -> str:
+    """Async image editing tool."""
+    return await _sync_seededit(image_url, prompt, seed, scale, charactor_keep)
+
+
+async def async_vlm_vision_task_tool(messages: List) -> str:
+    """Async VLM vision task tool."""
+    return await _sync_vlm_vision_task(messages)
+
+
+async def async_image_selector_tool(image_paths: List[str], prompt: str) -> str:
+    """Async image selector tool."""
+    return await _sync_image_selector(image_paths, prompt)
+
+
+async def async_video_selector_tool(video_paths: List[str], prompt: str) -> str:
+    """Async video selector tool."""
+    return await _sync_video_selector(video_paths, prompt)
+
+
+async def async_tos_save_content_tool(content: str, file_extension: str = "txt", 
+                                     object_key: Optional[str] = None) -> str:
+    """Async TOS content save tool."""
+    return await _sync_tos_save_content(content, file_extension, object_key)
+
+
+def cleanup_executor():
+    """Clean up the thread pool executor."""
+    global _executor
+    if _executor:
+        _executor.shutdown(wait=True)
+        _executor = None

{media_agent_mcp-0.3.2 → media_agent_mcp-0.3.4}/src/media_agent_mcp/server.py

@@ -39,9 +39,6 @@ logger = logging.getLogger(__name__)
 load_dotenv()
 mcp = FastMCP("Media-Agent-MCP")
 
-def create_sse_app():
-    return mcp.sse_app()
-
 
 @mcp.tool()
 def video_concat_tool(video_urls: list[str]) -> str:
@@ -373,8 +370,6 @@ def main():
                         help='Host for SSE transport (default: 127.0.0.1)')
     parser.add_argument('--port', type=int, default=8000,
                         help='Port for SSE transport (default: 8000)')
-    parser.add_argument('--workers', type=int, default=4,
-                        help='Number of worker processes for SSE (default: 4)')
 
     parser.add_argument('--version', action='store_true',
                         help='Show version information')
@@ -404,7 +399,11 @@ def main():
     # Start the server with specified transport
     if args.transport == 'sse':
         logger.info(f"Starting SSE server on {args.host}:{args.port} with {args.workers} workers")
-        uvicorn.run("media_agent_mcp.server:create_sse_app", host=args.host, port=args.port, workers=args.workers)
+        mcp.settings.host = args.host
+        mcp.settings.port = args.port
+
+        mcp.run(transport="sse")
+
     else:
         # Default stdio transport
         mcp.run(transport="stdio")