media-agent-mcp 0.1.0__py3-none-any.whl

media_agent_mcp/__init__.py

@@ -0,0 +1,7 @@
+"""Media Agent MCP Server - A Model Context Protocol server for media processing."""
+
+from . import ai_models, media_selectors, storage, video
+from .server import main
+
+__version__ = "0.1.0"
+__all__ = ['ai_models', 'selectors', 'storage', 'video', 'main']

media_agent_mcp/ai_models/__init__.py

@@ -0,0 +1,17 @@
+"""AI models module for Media Agent MCP.
+
+This module provides AI model functionality including image generation,
+video generation, character maintenance, and vision-language tasks.
+"""
+
+from .seedream import generate_image
+from .seedance import generate_video
+from .seededit import seededit
+from .seed16 import process_vlm_task
+
+__all__ = [
+    'generate_image',
+    'generate_video', 
+    'seededit',
+    'process_vlm_task'
+]

media_agent_mcp/ai_models/seed16.py

@@ -0,0 +1,151 @@
+"""Seed1.6 VLM module.
+
+This module provides functionality for vision-language tasks using the Seed1.6 model.
+Based on ModelArk Chat API documentation with blocking requests.
+"""
+
+import json
+import logging
+import os
+from typing import Dict, Any, List
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+def process_vlm_task(messages: List[Dict[str, Any]], max_tokens: int = 4096,
+                    temperature: float = 0.7, top_p: float = 0.9, is_json: bool = False, **kwargs) -> Dict[str, Any]:
+    """Process a vision-language task using Seed1.6 model with blocking request.
+    
+    Args:
+        messages: List of messages in OpenAI format
+        max_tokens: Maximum tokens to generate
+        temperature: Sampling temperature (0-2)
+        top_p: Nucleus sampling parameter (0-1)
+        **kwargs: Additional parameters
+        
+    Returns:
+        JSON response with status, data (response text), and message
+    """
+    try:
+        # Get API configuration from environment
+        api_key = os.getenv('ARK_API_KEY')
+        vlm_ep = os.getenv('VLM_EP', 'seed-1-6-250615')
+        if not api_key and not vlm_ep:
+            raise ValueError("ARK_API_KEY environment variable must be set")
+        
+        # API endpoint for chat completions
+        endpoint = "https://ark.ap-southeast.bytepluses.com/api/v3/chat/completions"
+        
+        headers = {
+            'Authorization': f'Bearer {api_key}',
+            'Content-Type': 'application/json'
+        }
+        
+        # Prepare request payload according to API documentation
+        payload = {
+            'model': vlm_ep,
+            'messages': messages,
+            'max_tokens': max_tokens,
+            'temperature': temperature,
+            'top_p': top_p,
+            'stream': False  # Blocking request
+        }
+
+        if is_json:
+            payload['response_format'] = {'type': 'json_object'}
+        
+        logger.info(f"Processing VLM task with Seed1.6: {len(messages)} messages")
+        
+        # Make blocking API request
+        response = requests.post(
+            endpoint,
+            headers=headers,
+            json=payload,
+            timeout=120  # Longer timeout for VLM tasks
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            
+            # Extract response text
+            if 'choices' in result and len(result['choices']) > 0:
+                choice = result['choices'][0]
+                if 'message' in choice and 'content' in choice['message']:
+                    response_text = choice['message']['content']
+                    logger.info(f"VLM task completed successfully")
+                    return {
+                        "status": "success",
+                        "data": {"response": response_text},
+                        "message": "VLM task completed successfully"
+                    }
+                else:
+                    return {
+                        "status": "error",
+                        "data": None,
+                        "message": "No content in response message"
+                    }
+            else:
+                return {
+                    "status": "error",
+                    "data": None,
+                    "message": "No choices in response"
+                }
+        else:
+            error_msg = f"API request failed with status {response.status_code}: {response.text}"
+            logger.error(error_msg)
+            return {
+                "status": "error",
+                "data": None,
+                "message": error_msg
+            }
+            
+    except requests.exceptions.Timeout:
+        error_msg = "Request timeout - VLM task took too long"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+    except requests.exceptions.RequestException as e:
+        error_msg = f"Network error: {str(e)}"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+    except Exception as e:
+        error_msg = f"Unexpected error in Seed1.6 VLM task: {str(e)}"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+
+
+if __name__ == '__main__':
+    # Example usage
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "Describe the image in detail."
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": "https://carey.tos-ap-southeast-1.bytepluses.com/Art%20Portrait/Art%20Portrait/Art%20Portrait/Art%20Portrait%20(2).jpg"
+                    }
+                }
+            ]
+            }
+        ]
+
+    response = process_vlm_task(messages)
+    print(response)

media_agent_mcp/ai_models/seedance.py

@@ -0,0 +1,258 @@
+"""Seedance video generation module.
+
+This module provides functionality for generating videos using the Seedance AI model.
+Based on ModelArk Video Generation API documentation with async polling.
+"""
+
+import json
+import logging
+import os
+import time
+from typing import Dict, Any
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+def generate_video(prompt: str = "", first_frame_image: str = None, last_frame_image: str = None, 
+                  duration: int = 5, resolution: str = "720p",
+                  fps: int = 24, seed: int = -1, **kwargs) -> Dict[str, Any]:
+    """Generate a video using Seedance model with first/last frame images.
+    
+    Args:
+        prompt: Text prompt for video generation (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: Video duration in seconds (5 or 10)
+        resolution: Video resolution (480p, 720p, 1080p)
+        ratio: Aspect ratio (21:9, 16:9, 4:3, 1:1, 3:4, 9:16, 9:21, adaptive)
+        fps: Frames per second (24)
+        seed: Random seed for reproducibility (-1 for random)
+        **kwargs: Additional parameters
+        
+    Returns:
+        JSON response with status, data (video URL), and message
+    """
+    try:
+        # Get API configuration from environment
+        api_key = os.getenv('ARK_API_KEY')
+        seedance_ep = os.getenv('SEEDANCE_EP', 'seedance-1-0-lite-i2v-250428')
+        if not api_key or not seedance_ep:
+            raise ValueError("ARK_API_KEY environment variable must be set")
+        
+        # API endpoint for video generapyttion tasks
+        endpoint = "https://ark.ap-southeast.bytepluses.com/api/v3/contents/generations/tasks"
+
+        headers = {
+            'Authorization': f'Bearer {api_key}',
+            'Content-Type': 'application/json'
+        }
+        
+        # Determine model based on input type
+        model = os.getenv('SEEDANCE_EP', 'seedance-1-0-lite-i2v-250428')
+        
+        # Prepare content array for the request
+        content = []
+        
+        # Add text content if prompt is provided
+        if prompt:
+            text_content = prompt
+            # Add parameters to the prompt
+            text_content += f" --rs {resolution} --dur {duration} --fps {fps}"
+            if seed != -1:
+                text_content += f" --seed {seed}"
+            
+            content.append({
+                "type": "text",
+                "text": text_content
+            })
+        
+        # Add first frame image if provided
+        if first_frame_image:
+            content.append({
+                "role": "first_frame",
+                "type": "image_url",
+                "image_url": {
+                    "url": first_frame_image
+                }
+            })
+        
+        if last_frame_image and first_frame_image:
+            content.append({
+                "role": "last_frame",
+                "type": "image_url", 
+                "image_url": {
+                    "url": last_frame_image
+                }
+            })
+        
+        # Prepare request payload according to API documentation
+        payload = {
+            'model': model,
+            'content': content
+        }
+        
+        logger.info(f"Starting video generation with Seedance: {prompt[:100]}...")
+        
+        # Make initial API request to start video generation
+        response = requests.post(
+            endpoint,
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code != 200:
+            error_msg = f"API request failed with status {response.status_code}: {response.text}"
+            logger.error(error_msg)
+            return {
+                "status": "error",
+                "data": None,
+                "message": error_msg
+            }
+        
+        result = response.json()
+        
+        # Extract task ID for polling
+        if 'id' not in result:
+            return {
+                "status": "error",
+                "data": None,
+                "message": "No task ID in response"
+            }
+        
+        task_id = result['id']
+        logger.info(f"Video generation task started with ID: {task_id}")
+        
+        # Poll for completion
+        return _poll_video_status(task_id, api_key)
+        
+    except requests.exceptions.Timeout:
+        error_msg = "Request timeout - video generation request took too long"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+    except requests.exceptions.RequestException as e:
+        error_msg = f"Network error: {str(e)}"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+    except Exception as e:
+        error_msg = f"Unexpected error in Seedance generation: {str(e)}"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+
+
+def _poll_video_status(task_id: str, api_key: str, max_wait_time: int = 90) -> Dict[str, Any]:
+    """Poll video generation status until completion.
+    
+    Args:
+        task_id: The task ID to poll
+        api_key: API key for authentication
+        max_wait_time: Maximum time to wait in seconds
+        
+    Returns:
+        JSON response with status, data (video URL), and message
+    """
+    query_endpoint = f"https://ark.ap-southeast.bytepluses.com/api/v3/contents/generations/tasks/{task_id}"
+    
+    headers = {
+        'Authorization': f'Bearer {api_key}',
+        'Content-Type': 'application/json'
+    }
+    
+    start_time = time.time()
+    
+    while time.time() - start_time < max_wait_time:
+        try:
+            response = requests.get(query_endpoint, headers=headers, timeout=30)
+            
+            if response.status_code != 200:
+                logger.error(f"Status query failed: {response.status_code} - {response.text}")
+                time.sleep(5)
+                continue
+            
+            result = response.json()
+            status = result.get('status')
+            
+            logger.info(f"Video generation status: {status}")
+            
+            if status == 'succeeded':
+                # Extract video URL from response
+                if 'content' in result and 'video_url' in result['content']:
+                    video_url = result['content']['video_url']
+                    if video_url:
+                        logger.info(f"Video generated successfully: {video_url}")
+                        return {
+                            "status": "success",
+                            "data": {"video_url": video_url},
+                            "message": "Video generated successfully"
+                        }
+                    else:
+                        return {
+                            "status": "error",
+                            "data": None,
+                            "message": "No video URL in completed response"
+                        }
+                else:
+                    return {
+                        "status": "error",
+                        "data": None,
+                        "message": "No video content in completed response"
+                    }
+            
+            elif status == 'failed':
+                error_detail = result.get('error', {}).get('message', 'Unknown error')
+                return {
+                    "status": "error",
+                    "data": None,
+                    "message": f"Video generation failed - {error_detail}"
+                }
+            
+            elif status in ['queued', 'running']:
+                # Continue polling
+                time.sleep(5)
+                continue
+            
+            else:
+                logger.warning(f"Unknown status: {status}")
+                time.sleep(5)
+                continue
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error polling status: {str(e)}")
+            time.sleep(5)
+            continue
+        except Exception as e:
+            logger.error(f"Unexpected error polling status: {str(e)}")
+            time.sleep(5)
+            continue
+    
+    return f"Error: Video generation timed out after {max_wait_time} seconds"
+
+
+if __name__ == '__main__':
+    # Example usage
+    video_url = generate_video(
+        prompt="the woman slowly moves",
+        first_frame_image="https://carey.tos-ap-southeast-1.bytepluses.com/Art%20Portrait/Art%20Portrait/Art%20Portrait/Art%20Portrait%20(1).jpg",
+        # last_frame_image="https://carey.tos-ap-southeast-1.bytepluses.com/Art%20Portrait/Art%20Portrait/Art%20Portrait/Art%20Portrait%20(2).jpg",
+        duration=5,
+        resolution="720p",
+        ratio="16:9",
+        fps=24,
+        seed=42
+    )
+
+    print(f"Generated video URL: {video_url}")

media_agent_mcp/ai_models/seededit.py

@@ -0,0 +1,94 @@
+import os
+from typing import Dict, Any
+from volcengine.visual.VisualService import VisualService
+
+
+def parse_seededit_response(response) -> Dict[str, Any]:
+    """
+    Parse the seededit API response and extract the image URL.
+    
+    :param response: The API response dictionary
+    :return: JSON response with status, data (image URL), and message
+    """
+    try:
+        # Handle both possible response formats
+        if 'data' in response and 'image_urls' in response['data']:
+            # Format 1: {'data': {'image_urls': [...]}}
+            image_urls = response['data']['image_urls']
+        elif 'image_urls' in response:
+            # Format 2: {'image_urls': [...]}
+            image_urls = response['image_urls']
+        else:
+            raise ValueError("No image_urls found in response")
+        
+        if not image_urls or len(image_urls) == 0:
+            raise ValueError("Empty image_urls list")
+        
+        # Get the first URL and clean it
+        url = image_urls[0]
+        # Remove leading/trailing whitespace and backticks
+        url = url.strip().strip('`').strip()
+        
+        return {
+            "status": "success",
+            "data": {"image_url": url},
+            "message": "Image URL parsed successfully"
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "data": None,
+            "message": f"Failed to parse response: {e}"
+        }
+
+
+def seededit(image_url, prompt, charactor_keep=False, return_url=True, scale=1, seed=-1) -> Dict[str, Any]:
+    """
+    Perform image editing using the VisualService.
+
+    :param image_url: URL of the input image.
+    :param prompt: The editing prompt.
+    :param charactor_keep: Whether to keep the main character in the image.
+    :param return_url: Whether to return image URL or base64 string.
+    :param scale: Text influence scale (0.1-1.0).
+    :param seed: Random seed for reproducibility.
+    :return: JSON response with status, data (image URL), and message.
+    """
+    try:
+        visual_service = VisualService()
+
+        # call below method if you don't set ak and sk in $HOME/.volc/config
+        ak = os.getenv('VOLC_AK')
+        sk = os.getenv('VOLC_SK')
+
+        if not ak or not sk:
+            return {
+                "status": "error",
+                "data": None,
+                "message": "VOLC_AK and VOLC_SK environment variables must be set"
+            }
+
+        visual_service.set_ak(ak)
+        visual_service.set_sk(sk)
+
+        form = {
+            "req_key": "seed3l_single_ip" if charactor_keep else "seededit_v3.0",
+            "image_urls": [image_url],
+            'prompt': prompt,
+            'return_url': return_url,
+            'scale': scale,
+            'seed': seed,
+        }
+
+        response = visual_service.cv_process(form)
+        return parse_seededit_response(response)
+    except Exception as e:
+        return {
+            "status": "error",
+            "data": None,
+            "message": f"Error in seededit: {str(e)}"
+        }
+
+
+if __name__ == '__main__':
+    print(seededit('https://carey.tos-ap-southeast-1.bytepluses.com/Art%20Portrait/Art%20Portrait/Art%20Portrait/Art%20Portrait%20(1).jpg', prompt='在和边钓鱼', charactor_keep=False))

media_agent_mcp/ai_models/seedream.py

@@ -0,0 +1,136 @@
+"""Seedream image generation module.
+
+This module provides functionality for generating images using the Seedream AI model.
+Based on ModelArk Image Generation API documentation.
+"""
+
+import json
+import logging
+import os
+from typing import Dict, Any
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+def generate_image(prompt: str, size: str = "1024x1024", guidance_scale: float = 2.5, 
+                  watermark: bool = True, seed: int = -1, **kwargs) -> Dict[str, Any]:
+    """Generate an image using Seedream model.
+    
+    Args:
+        prompt: Text prompt for image generation
+        size: Image size (e.g., "1024x1024", "864x1152", etc.), Must be between [512x512, 2048x2048]
+        guidance_scale: Controls prompt alignment (1-10)
+        watermark: Whether to add watermark
+        seed: Random seed for reproducibility (-1 for random)
+        **kwargs: Additional parameters
+        
+    Returns:
+        JSON response with status, data (image URL), and message
+    """
+    try:
+        # Get API configuration from environment
+        api_key = os.getenv('ARK_API_KEY')
+        seedream_ep = os.getenv('SEEDREAM_EP', 'seedream-3-0-t2i-250415')
+
+        if not api_key or not seedream_ep:
+            raise ValueError("ARK_API_KEY environment variable must be set")
+        
+        # API endpoint for image generation
+        endpoint = "https://ark.ap-southeast.bytepluses.com/api/v3/images/generations"
+        
+        headers = {
+            'Authorization': f'Bearer {api_key}',
+            'Content-Type': 'application/json'
+        }
+        
+        # Prepare request payload according to API documentation
+        payload = {
+            'model': seedream_ep,
+            'prompt': prompt,
+            'response_format': 'url',
+            'size': size,
+            'guidance_scale': guidance_scale,
+            'watermark': watermark
+        }
+        
+        # Add seed if specified
+        if seed != -1:
+            payload['seed'] = seed
+        
+        logger.info(f"Generating image with Seedream: {prompt[:100]}...")
+        
+        # Make API request
+        response = requests.post(
+            endpoint,
+            headers=headers,
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            
+            # Extract image URL from response
+            if 'data' in result and len(result['data']) > 0:
+                image_url = result['data'][0].get('url')
+                if image_url:
+                    logger.info(f"Image generated successfully: {image_url}")
+                    return {
+                        "status": "success",
+                        "data": {"image_url": image_url},
+                        "message": "Image generated successfully"
+                    }
+                else:
+                    return {
+                        "status": "error",
+                        "data": None,
+                        "message": "No image URL in response"
+                    }
+            else:
+                return {
+                    "status": "error",
+                    "data": None,
+                    "message": "No image data in response"
+                }
+        else:
+            error_msg = f"API request failed with status {response.status_code}: {response.text}"
+            logger.error(error_msg)
+            return {
+                "status": "error",
+                "data": None,
+                "message": error_msg
+            }
+            
+    except requests.exceptions.Timeout:
+        error_msg = "Request timeout - image generation took too long"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+    except requests.exceptions.RequestException as e:
+        error_msg = f"Network error: {str(e)}"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+    except Exception as e:
+        error_msg = f"Unexpected error in Seedream generation: {str(e)}"
+        logger.error(error_msg)
+        return {
+            "status": "error",
+            "data": None,
+            "message": error_msg
+        }
+
+
+if __name__ == "__main__":
+    # Test the function
+    prompt = "A serene landscape with mountains and a lake"
+    image_url = generate_image(prompt)
+    print(image_url)

media_agent_mcp/media_selectors/__init__.py

@@ -0,0 +1,9 @@
+"""Selectors module for Media Agent MCP.
+
+This module provides selection functionality for images and videos.
+"""
+
+from .image_selector import select_best_image
+from .video_selector import select_best_video
+
+__all__ = ['select_best_image', 'select_best_video']