Update app.py

app.py

@@ -1,7 +1,8 @@
+
 #!/usr/bin/env python
 """
-PowerPoint MCP Server - Fixed Complete Implementation
-Supports both MCP STDIO transport and Gradio web interface
+PowerPoint MCP Server with Gradio interface and Streamable HTTP transport
+Integrated with existing tool structure from ppt_mcp_server.py
 """
 import os
 import json
@@ -11,417 +12,367 @@ import uuid
 import logging
 import gradio as gr
 from threading import Thread
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional
+from mcp.server.fastmcp import FastMCP
 import asyncio
-import sys
-
+# Import all your existing tools registration functions
+from tools import (
+    register_presentation_tools,
+    register_content_tools,
+    register_structural_tools,
+    register_professional_tools,
+    register_template_tools,
+    register_hyperlink_tools,
+    register_chart_tools,
+    register_connector_tools,
+    register_master_tools,
+    register_transition_tools
+)
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-
-# Global state for presentations
+# Initialize the FastMCP server for streamable HTTP
+mcp_app = FastMCP(
+    name="ppt-mcp-server"
+)
+# Global state to store presentations in memory (from original)
 presentations = {}
 current_presentation_id = None
-
-# Check for dependencies
-MCP_AVAILABLE = False
-PPTX_AVAILABLE = False
-
-# PowerPoint imports
-try:
-    from pptx import Presentation
-    from pptx.util import Inches, Pt
-    from pptx.enum.text import PP_ALIGN
-    from pptx.enum.shapes import MSO_SHAPE
-    from pptx.enum.chart import XL_CHART_TYPE
-    PPTX_AVAILABLE = True
-    print("✅ python-pptx loaded successfully")
-except ImportError:
-    PPTX_AVAILABLE = False
-    print("❌ python-pptx not available. Install with: pip install python-pptx")
-
-# MCP imports
-try:
-    from mcp.server import Server
-    from mcp.server.stdio import stdio_server
-    import mcp.types as types
-    MCP_AVAILABLE = True
-    print("✅ MCP loaded successfully")
-except ImportError:
-    MCP_AVAILABLE = False
-    print("❌ MCP not available. Install with: pip install mcp")
-
-# Always initialize server (even if MCP not available for web mode)
-server = None
-if MCP_AVAILABLE:
-    server = Server("powerpoint-mcp-server")
-
-# Helper Functions
+# Template configuration (from original)
+def get_template_search_directories():
+    """
+    Get list of directories to search for templates.
+    Uses environment variable PPT_TEMPLATE_PATH if set, otherwise uses default directories.
+    """
+    template_env_path = os.environ.get('PPT_TEMPLATE_PATH')
+    
+    if template_env_path:
+        import platform
+        separator = ';' if platform.system() == "Windows" else ':'
+        env_dirs = [path.strip() for path in template_env_path.split(separator) if path.strip()]
+        
+        valid_env_dirs = []
+        for dir_path in env_dirs:
+            expanded_path = os.path.expanduser(dir_path)
+            if os.path.exists(expanded_path) and os.path.isdir(expanded_path):
+                valid_env_dirs.append(expanded_path)
+        
+        if valid_env_dirs:
+            return valid_env_dirs + ['.', './templates', './assets', './resources']
+        else:
+            print(f"Warning: PPT_TEMPLATE_PATH directories not found: {template_env_path}")
+    
+    return ['.', './templates', './assets', './resources']
+# Helper Functions (from original)
 def get_current_presentation():
-    """Get the current presentation or create a new one."""
-    global current_presentation_id
+    """Get the current presentation object or raise an error if none is loaded."""
     if current_presentation_id is None or current_presentation_id not in presentations:
-        # Create a default presentation
-        if PPTX_AVAILABLE:
-            prs = Presentation()
-            current_presentation_id = str(uuid.uuid4())
-            presentations[current_presentation_id] = prs
-        else:
-            raise ValueError("python-pptx not available")
+        raise ValueError("No presentation is currently loaded. Please create or open a presentation first.")
     return presentations[current_presentation_id]
-
-def create_presentation_sync(title="New Presentation"):
-    """Create a new presentation synchronously."""
-    if not PPTX_AVAILABLE:
-        return None, "python-pptx not available"
+def get_current_presentation_id():
+    """Get the current presentation ID."""
+    return current_presentation_id
+def set_current_presentation_id(pres_id):
+    """Set the current presentation ID."""
+    global current_presentation_id
+    current_presentation_id = pres_id
+def validate_parameters(params):
+    """Validate parameters against constraints."""
+    for param_name, (value, constraints) in params.items():
+        for constraint_func, error_msg in constraints:
+            if not constraint_func(value):
+                return False, f"Parameter '{param_name}': {error_msg}"
+    return True, None
+def is_positive(value):
+    """Check if a value is positive."""
+    return value > 0
+def is_non_negative(value):
+    """Check if a value is non-negative."""
+    return value >= 0
+def is_in_range(min_val, max_val):
+    """Create a function that checks if a value is in a range."""
+    return lambda x: min_val <= x <= max_val
+def is_in_list(valid_list):
+    """Create a function that checks if a value is in a list."""
+    return lambda x: x in valid_list
+def is_valid_rgb(color_list):
+    """Check if a color list is a valid RGB tuple."""
+    if not isinstance(color_list, list) or len(color_list) != 3:
+        return False
+    return all(isinstance(c, int) and 0 <= c <= 255 for c in color_list)
+def add_shape_direct(slide, shape_type: str, left: float, top: float, width: float, height: float) -> Any:
+    """Add an auto shape to a slide using direct integer values."""
+    from pptx.util import Inches
+    
+    shape_type_map = {
+        'rectangle': 1,
+        'rounded_rectangle': 2, 
+        'oval': 9,
+        'diamond': 4,
+        'triangle': 5,
+        'right_triangle': 6,
+        'pentagon': 56,
+        'hexagon': 10,
+        'heptagon': 11,
+        'octagon': 12,
+        'star': 12,
+        'arrow': 13,
+        'cloud': 35,
+        'heart': 21,
+        'lightning_bolt': 22,
+        'sun': 23,
+        'moon': 24,
+        'smiley_face': 17,
+        'no_symbol': 19,
+        'flowchart_process': 112,
+        'flowchart_decision': 114,
+        'flowchart_data': 115,
+        'flowchart_document': 119
+    }
+    
+    shape_type_lower = str(shape_type).lower()
+    if shape_type_lower not in shape_type_map:
+        available_shapes = ', '.join(sorted(shape_type_map.keys()))
+        raise ValueError(f"Unsupported shape type: '{shape_type}'. Available shape types: {available_shapes}")
+    
+    shape_value = shape_type_map[shape_type_lower]
+    
+    try:
+        shape = slide.shapes.add_shape(
+            shape_value, Inches(left), Inches(top), Inches(width), Inches(height)
+        )
+        return shape
+    except Exception as e:
+        raise ValueError(f"Failed to create '{shape_type}' shape using direct value {shape_value}: {str(e)}")
+# Custom presentation management wrapper (from original)
+class PresentationManager:
+    """Wrapper to handle presentation state updates."""
+    
+    def __init__(self, presentations_dict):
+        self.presentations = presentations_dict
+    
+    def store_presentation(self, pres, pres_id):
+        """Store a presentation and set it as current."""
+        self.presentations[pres_id] = pres
+        set_current_presentation_id(pres_id)
+        return pres_id
+# Create presentation manager wrapper
+presentation_manager = PresentationManager(presentations)
+# Register all tool modules (from original)
+register_presentation_tools(
+    mcp_app, 
+    presentations, 
+    get_current_presentation_id, 
+    get_template_search_directories
+)
+register_content_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id,
+    validate_parameters,
+    is_positive,
+    is_non_negative,
+    is_in_range,
+    is_valid_rgb
+)
+register_structural_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id,
+    validate_parameters,
+    is_positive,
+    is_non_negative,
+    is_in_range,
+    is_valid_rgb,
+    add_shape_direct
+)
+register_professional_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id
+)
+register_template_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id
+)
+register_hyperlink_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id,
+    validate_parameters,
+    is_positive,
+    is_non_negative,
+    is_in_range,
+    is_valid_rgb
+)
+register_chart_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id,
+    validate_parameters,
+    is_positive,
+    is_non_negative,
+    is_in_range,
+    is_valid_rgb
+)
+register_connector_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id,
+    validate_parameters,
+    is_positive,
+    is_non_negative,
+    is_in_range,
+    is_valid_rgb
+)
+register_master_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id,
+    validate_parameters,
+    is_positive,
+    is_non_negative,
+    is_in_range,
+    is_valid_rgb
+)
+register_transition_tools(
+    mcp_app,
+    presentations,
+    get_current_presentation_id,
+    validate_parameters,
+    is_positive,
+    is_non_negative,
+    is_in_range,
+    is_valid_rgb
+)
+# Additional Utility Tools (from original)
+@mcp_app.tool()
+def list_presentations() -> Dict:
+    """List all loaded presentations."""
+    return {
+        "presentations": [
+            {
+                "id": pres_id,
+                "slide_count": len(pres.slides),
+                "is_current": pres_id == current_presentation_id
+            }
+            for pres_id, pres in presentations.items()
+        ],
+        "current_presentation_id": current_presentation_id,
+        "total_presentations": len(presentations)
+    }
+@mcp_app.tool()
+def switch_presentation(presentation_id: str) -> Dict:
+    """Switch to a different loaded presentation."""
+    if presentation_id not in presentations:
+        return {
+            "error": f"Presentation '{presentation_id}' not found. Available presentations: {list(presentations.keys())}"
+        }
+    
+    global current_presentation_id
+    old_id = current_presentation_id
+    current_presentation_id = presentation_id
+    
+    return {
+        "message": f"Switched from presentation '{old_id}' to '{presentation_id}'",
+        "previous_presentation_id": old_id,
+        "current_presentation_id": current_presentation_id
+    }
+@mcp_app.tool()
+def get_server_info() -> Dict:
+    """Get information about the MCP server."""
+    return {
+        "name": "PowerPoint MCP Server - Enhanced Edition",
+        "version": "2.1.0",
+        "total_tools": 32,
+        "loaded_presentations": len(presentations),
+        "current_presentation": current_presentation_id,
+        "transport": "streamable-http",
+        "features": [
+            "Presentation Management (7 tools)",
+            "Content Management (6 tools)", 
+            "Template Operations (7 tools)",
+            "Structural Elements (4 tools)",
+            "Professional Design (3 tools)",
+            "Specialized Features (5 tools)"
+        ]
+    }
+# Direct tool usage functions for Gradio (using internal MCP mechanisms)
+def create_test_presentation():
+    """Create a test presentation using MCP tools directly"""
+    from pptx import Presentation
+    from pptx.util import Inches
+    import uuid
     
     try:
+        # Create presentation directly
         prs = Presentation()
         presentation_id = str(uuid.uuid4())
         presentations[presentation_id] = prs
+        set_current_presentation_id(presentation_id)
         
-        global current_presentation_id
-        current_presentation_id = presentation_id
-        
-        logger.info(f"Created presentation '{title}' with ID: {presentation_id}")
-        return presentation_id, f"Created presentation '{title}' with ID: {presentation_id}"
+        return presentation_id, "✅ Test presentation created successfully"
     except Exception as e:
-        logger.error(f"Error creating presentation: {str(e)}")
-        return None, f"Error creating presentation: {str(e)}"
-
-def add_slide_sync(title="New Slide", content="", layout_idx=1):
-    """Add a slide synchronously."""
+        return None, f"❌ Error creating presentation: {str(e)}"
+def add_test_slide(presentation_id, title="Test Slide", content="Test content"):
+    """Add a test slide"""
     try:
-        prs = get_current_presentation()
-        slide_layout = prs.slide_layouts[layout_idx]
+        if presentation_id not in presentations:
+            return False, "Presentation not found"
+        
+        prs = presentations[presentation_id]
+        
+        # Add slide with title and content layout
+        slide_layout = prs.slide_layouts[1]  # Title and content layout
         slide = prs.slides.add_slide(slide_layout)
         
-        # Set title if available
+        # Set title
         if slide.shapes.title:
             slide.shapes.title.text = title
         
-        # Set content if available and layout supports it
-        if content and len(slide.placeholders) > 1:
+        # Set content
+        if len(slide.placeholders) > 1:
             slide.placeholders[1].text = content
         
-        slide_number = len(prs.slides)
-        logger.info(f"Added slide {slide_number}: '{title}'")
-        return True, f"Added slide {slide_number}: '{title}'"
+        return True, f"Slide added: {title}"
     except Exception as e:
-        logger.error(f"Error adding slide: {str(e)}")
         return False, f"Error adding slide: {str(e)}"
-
-def save_presentation_sync(filename=None):
-    """Save presentation synchronously."""
+def save_test_presentation(presentation_id):
+    """Save test presentation to file"""
     try:
-        if not current_presentation_id or current_presentation_id not in presentations:
-            return None, "No active presentation to save"
-        
-        prs = presentations[current_presentation_id]
-        
-        if filename is None:
-            filename = f"presentation_{current_presentation_id[:8]}.pptx"
+        if presentation_id not in presentations:
+            return None, "Presentation not found"
         
-        if not filename.endswith('.pptx'):
-            filename += '.pptx'
+        prs = presentations[presentation_id]
+        temp_file = tempfile.NamedTemporaryFile(suffix='.pptx', delete=False)
+        prs.save(temp_file.name)
         
-        # Save to temp directory for web access
-        temp_dir = tempfile.gettempdir()
-        filepath = os.path.join(temp_dir, filename)
-        prs.save(filepath)
-        
-        logger.info(f"Presentation saved to: {filepath}")
-        return filepath, f"Presentation saved to: {filepath}"
+        return temp_file.name, "✅ Presentation saved successfully"
     except Exception as e:
-        logger.error(f"Error saving presentation: {str(e)}")
-        return None, f"Error saving presentation: {str(e)}"
-
-# MCP Server Implementation - Only if MCP is available
-if MCP_AVAILABLE and server is not None:
-    @server.list_tools()
-    async def handle_list_tools() -> List[types.Tool]:
-        """List all available MCP tools."""
-        return [
-            types.Tool(
-                name="create_presentation",
-                description="Create a new PowerPoint presentation",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "title": {
-                            "type": "string", 
-                            "description": "Title for the presentation",
-                            "default": "New Presentation"
-                        }
-                    }
-                }
-            ),
-            types.Tool(
-                name="add_slide",
-                description="Add a new slide to the current presentation",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "title": {
-                            "type": "string", 
-                            "description": "Title for the slide"
-                        },
-                        "content": {
-                            "type": "string", 
-                            "description": "Content/body text for the slide"
-                        },
-                        "layout": {
-                            "type": "integer",
-                            "description": "Layout index (0=Title, 1=Title+Content, 2=Section Header, etc.)",
-                            "default": 1
-                        }
-                    },
-                    "required": ["title"]
-                }
-            ),
-            types.Tool(
-                name="save_presentation",
-                description="Save the current presentation to a file",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "filename": {
-                            "type": "string", 
-                            "description": "Filename for the presentation (without extension)"
-                        }
-                    }
-                }
-            ),
-            types.Tool(
-                name="get_presentation_info",
-                description="Get information about the current presentation",
-                inputSchema={"type": "object", "properties": {}}
-            ),
-            types.Tool(
-                name="add_bullet_slide",
-                description="Add a slide with bullet points",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "title": {"type": "string", "description": "Slide title"},
-                        "bullets": {
-                            "type": "array",
-                            "items": {"type": "string"},
-                            "description": "List of bullet points"
-                        }
-                    },
-                    "required": ["title", "bullets"]
-                }
-            ),
-            types.Tool(
-                name="create_presentation_from_outline",
-                description="Create a complete presentation from a structured outline",
-                inputSchema={
-                    "type": "object",
-                    "properties": {
-                        "title": {"type": "string", "description": "Presentation title"},
-                        "slides": {
-                            "type": "array",
-                            "items": {
-                                "type": "object",
-                                "properties": {
-                                    "title": {"type": "string"},
-                                    "content": {"type": "string"},
-                                    "type": {"type": "string", "enum": ["title", "content", "bullets", "section"], "default": "content"}
-                                }
-                            }
-                        }
-                    },
-                    "required": ["title", "slides"]
-                }
-            )
-        ]
-
-    @server.call_tool()
-    async def handle_call_tool(name: str, arguments: dict) -> List[types.TextContent]:
-        """Handle tool execution."""
-        try:
-            if not PPTX_AVAILABLE:
-                return [types.TextContent(
-                    type="text", 
-                    text="Error: python-pptx library not available. Please install it with: pip install python-pptx"
-                )]
-
-            if name == "create_presentation":
-                return await create_presentation_tool(arguments)
-            elif name == "add_slide":
-                return await add_slide_tool(arguments)
-            elif name == "save_presentation":
-                return await save_presentation_tool(arguments)
-            elif name == "get_presentation_info":
-                return await get_presentation_info_tool(arguments)
-            elif name == "add_bullet_slide":
-                return await add_bullet_slide_tool(arguments)
-            elif name == "create_presentation_from_outline":
-                return await create_presentation_from_outline_tool(arguments)
-            else:
-                return [types.TextContent(type="text", text=f"Unknown tool: {name}")]
-                
-        except Exception as e:
-            logger.error(f"Error in tool {name}: {str(e)}")
-            return [types.TextContent(type="text", text=f"Error executing {name}: {str(e)}")]
-
-    # Tool implementations
-    async def create_presentation_tool(args: dict) -> List[types.TextContent]:
-        """Create a new presentation tool."""
-        title = args.get("title", "New Presentation")
-        presentation_id, message = create_presentation_sync(title)
-        return [types.TextContent(type="text", text=message)]
-
-    async def add_slide_tool(args: dict) -> List[types.TextContent]:
-        """Add slide tool."""
-        title = args.get("title", "New Slide")
-        content = args.get("content", "")
-        layout_idx = args.get("layout", 1)
-        
-        success, message = add_slide_sync(title, content, layout_idx)
-        return [types.TextContent(type="text", text=message)]
-
-    async def save_presentation_tool(args: dict) -> List[types.TextContent]:
-        """Save presentation tool."""
-        filename = args.get("filename")
-        filepath, message = save_presentation_sync(filename)
-        return [types.TextContent(type="text", text=message)]
-
-    async def get_presentation_info_tool(args: dict) -> List[types.TextContent]:
-        """Get presentation info tool."""
-        try:
-            if not current_presentation_id or current_presentation_id not in presentations:
-                return [types.TextContent(type="text", text="No active presentation")]
-            
-            prs = presentations[current_presentation_id]
-            info = {
-                "presentation_id": current_presentation_id,
-                "slide_count": len(prs.slides),
-                "slide_layouts_available": len(prs.slide_layouts),
-                "core_properties": {
-                    "title": prs.core_properties.title or "Untitled",
-                    "author": prs.core_properties.author or "Unknown",
-                    "subject": prs.core_properties.subject or "",
-                }
-            }
-            
-            return [types.TextContent(type="text", text=json.dumps(info, indent=2))]
-        except Exception as e:
-            return [types.TextContent(type="text", text=f"Error getting info: {str(e)}")]
-
-    async def add_bullet_slide_tool(args: dict) -> List[types.TextContent]:
-        """Add a slide with bullet points."""
-        try:
-            prs = get_current_presentation()
-            slide_layout = prs.slide_layouts[1]  # Title and content layout
-            slide = prs.slides.add_slide(slide_layout)
-            
-            title = args.get("title", "Bullet Points")
-            bullets = args.get("bullets", [])
-            
-            # Set title
-            if slide.shapes.title:
-                slide.shapes.title.text = title
-            
-            # Add bullet points
-            if len(slide.placeholders) > 1 and bullets:
-                text_frame = slide.placeholders[1].text_frame
-                text_frame.text = bullets[0]  # First bullet
-                
-                # Add additional bullets
-                for bullet in bullets[1:]:
-                    p = text_frame.add_paragraph()
-                    p.text = bullet
-                    p.level = 0  # Main bullet level
-            
-            return [types.TextContent(type="text", text=f"Added bullet slide: '{title}' with {len(bullets)} points")]
-        except Exception as e:
-            return [types.TextContent(type="text", text=f"Error adding bullet slide: {str(e)}")]
-
-    async def create_presentation_from_outline_tool(args: dict) -> List[types.TextContent]:
-        """Create a complete presentation from outline."""
-        try:
-            # Create new presentation
-            title = args.get("title", "New Presentation")
-            presentation_id, create_msg = create_presentation_sync(title)
-            
-            if not presentation_id:
-                return [types.TextContent(type="text", text=create_msg)]
-            
-            slides_data = args.get("slides", [])
-            created_slides = 0
-            
-            for slide_info in slides_data:
-                slide_title = slide_info.get("title", "Untitled Slide")
-                slide_content = slide_info.get("content", "")
-                slide_type = slide_info.get("type", "content")
-                
-                if slide_type == "title":
-                    success, msg = add_slide_sync(slide_title, slide_content, 0)  # Title layout
-                elif slide_type == "section":
-                    success, msg = add_slide_sync(slide_title, slide_content, 2)  # Section header
-                elif slide_type == "bullets":
-                    # Convert content to bullet points
-                    bullets = slide_content.split('\n') if slide_content else ["Bullet point"]
-                    result = await add_bullet_slide_tool({"title": slide_title, "bullets": bullets})
-                    success = True
-                else:  # content
-                    success, msg = add_slide_sync(slide_title, slide_content, 1)  # Title and content
-                
-                if success:
-                    created_slides += 1
-            
-            # Save the presentation
-            filepath, save_msg = save_presentation_sync(f"{title.replace(' ', '_')}")
-            
-            final_message = f"Created presentation '{title}' with {created_slides} slides. {save_msg}"
-            return [types.TextContent(type="text", text=final_message)]
-            
-        except Exception as e:
-            return [types.TextContent(type="text", text=f"Error creating presentation from outline: {str(e)}")]
-
+        return None, f"❌ Error saving presentation: {str(e)}"
 # Gradio Interface Functions
-def create_presentation_gradio(title):
-    """Create presentation for Gradio interface."""
-    if not title:
-        title = "New Presentation"
-    
-    presentation_id, message = create_presentation_sync(title)
-    return f"✅ {message}" if presentation_id else f"❌ {message}"
-
-def add_slide_gradio(title, content):
-    """Add slide for Gradio interface."""
-    if not title:
-        return "❌ Please provide a slide title"
-    
-    success, message = add_slide_sync(title, content or "")
-    return f"✅ {message}" if success else f"❌ {message}"
-
-def create_from_json_gradio(json_data):
-    """Create presentation from JSON data."""
+def create_presentation_from_json(slides_data):
+    """Create PowerPoint from JSON data (for Gradio testing)"""
     try:
-        if isinstance(json_data, str):
-            data = json.loads(json_data)
+        if isinstance(slides_data, str):
+            data = json.loads(slides_data)
         else:
-            data = json_data
+            data = slides_data
         
         # Create presentation
-        title = data.get("title", "JSON Presentation")
-        presentation_id, create_message = create_presentation_sync(title)
-        
+        presentation_id, create_message = create_test_presentation()
         if not presentation_id:
-            return None, f"❌ {create_message}"
+            return None, create_message
         
         # Add slides
-        slides_data = data.get("slides", [])
         slide_count = 0
-        
-        for slide_info in slides_data:
-            slide_title = slide_info.get("title", f"Slide {slide_count + 1}")
-            slide_content = slide_info.get("content", "")
-            
-            success, message = add_slide_sync(slide_title, slide_content)
+        for slide_info in data.get("slides", []):
+            success, message = add_test_slide(
+                presentation_id,
+                slide_info.get("title", f"Slide {slide_count + 1}"),
+                slide_info.get("content", "Sample content")
+            )
             if success:
                 slide_count += 1
         
@@ -429,235 +380,158 @@ def create_from_json_gradio(json_data):
             return None, "❌ No slides were created successfully"
         
         # Save presentation
-        filename = f"{title.replace(' ', '_')}_gradio"
-        filepath, save_message = save_presentation_sync(filename)
+        file_path, save_message = save_test_presentation(presentation_id)
         
-        if filepath:
-            return filepath, f"✅ Created presentation with {slide_count} slides. {save_message}"
+        if file_path:
+            return file_path, f"✅ Presentation created with {slide_count} slides"
         else:
-            return None, f"❌ {save_message}"
+            return None, save_message
             
-    except json.JSONDecodeError as e:
-        return None, f"❌ Invalid JSON: {str(e)}"
     except Exception as e:
+        logger.error(f"Error creating presentation: {str(e)}")
         return None, f"❌ Error: {str(e)}"
-
 def get_server_status():
-    """Get current server status."""
-    mcp_status = "✅ Available" if MCP_AVAILABLE else "❌ Not installed"
-    pptx_status = "✅ Available" if PPTX_AVAILABLE else "❌ Not installed"
-    
+    """Get current server status for display"""
     return f"""
 🟢 **Server Status**: Running
-📦 **MCP Library**: {mcp_status}
-📊 **PowerPoint Library**: {pptx_status}
-🔧 **Transport**: STDIO  
-⚡ **Tools Available**: 6 (create_presentation, add_slide, save_presentation, etc.)
+🔧 **Transport**: Streamable HTTP  
+📦 **Tools Available**: 32+ (All modules registered)
+🎯 **MCP Version**: 2024-11-05
+⚡ **Server Version**: 2.1.0
 📊 **Presentations Loaded**: {len(presentations)}
-🎮 **Current Presentation**: {current_presentation_id[-8:] if current_presentation_id else 'None'}
-📁 **Temp Directory**: {tempfile.gettempdir()}
-    """
-
-# Gradio Interface
+🎮 **Current Presentation**: {current_presentation_id or 'None'}
+"""
+# Create Gradio Interface
 def create_gradio_interface():
-    """Create the Gradio web interface."""
+    """Create the main Gradio interface"""
     
-    with gr.Blocks(title="PowerPoint MCP Server", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(title="PowerPoint MCP Server - Streamable HTTP", theme=gr.themes.Soft()) as demo:
         gr.Markdown("# 🎯 PowerPoint MCP Server")
-        gr.Markdown("**Complete MCP implementation with PowerPoint generation capabilities**")
+        gr.Markdown("**Transport**: Streamable HTTP | **Endpoint**: `/mcp` | **Tools**: 32+ available")
         
-        with gr.Tab("🚀 Quick Test"):
+        with gr.Tab("🚀 Test Interface"):
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("### Create New Presentation")
-                    title_input = gr.Textbox(
-                        label="Presentation Title",
-                        value="My Test Presentation",
-                        placeholder="Enter presentation title"
+                    gr.Markdown("### Create Presentation from JSON")
+                    slides_input = gr.Textbox(
+                        label="Slides Data (JSON)",
+                        value='{"slides": [{"title": "Welcome", "content": "This is slide 1"}, {"title": "About Us", "content": "This is slide 2"}]}',
+                        lines=12,
+                        placeholder='{"slides": [{"title": "Slide Title", "content": "Slide content"}]}'
                     )
-                    create_btn = gr.Button("📁 Create Presentation", variant="primary")
-                    create_output = gr.Textbox(label="Status", interactive=False)
+                    create_btn = gr.Button("🚀 Create Presentation", variant="primary", size="lg")
                 
                 with gr.Column():
-                    gr.Markdown("### Add Slide")
-                    slide_title = gr.Textbox(
-                        label="Slide Title",
-                        value="Welcome",
-                        placeholder="Enter slide title"
+                    status_output = gr.Textbox(
+                        label="Creation Status", 
+                        interactive=False,
+                        lines=3
                     )
-                    slide_content = gr.Textbox(
-                        label="Slide Content",
-                        value="This is my first slide content",
-                        lines=3,
-                        placeholder="Enter slide content"
-                    )
-                    add_slide_btn = gr.Button("➕ Add Slide", variant="secondary")
-                    slide_output = gr.Textbox(label="Status", interactive=False)
-            
-            with gr.Row():
-                save_btn = gr.Button("💾 Save Presentation", variant="primary", size="lg")
-                download_btn = gr.DownloadButton("📥 Download PowerPoint", visible=False, size="lg")
-                save_output = gr.Textbox(label="Save Status", interactive=False)
-        
-        with gr.Tab("📝 JSON Creator"):
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Create from JSON Structure")
-                    json_input = gr.Textbox(
-                        label="JSON Data",
-                        value='{\n  "title": "Sample Presentation",\n  "slides": [\n    {\n      "title": "Introduction",\n      "content": "Welcome to our presentation"\n    },\n    {\n      "title": "Main Points",\n      "content": "Point 1\\nPoint 2\\nPoint 3"\n    },\n    {\n      "title": "Conclusion",\n      "content": "Thank you for your attention"\n    }\n  ]\n}',
-                        lines=15,
-                        placeholder='{"title": "My Presentation", "slides": [...]}'
-                    )
-                    json_create_btn = gr.Button("🚀 Create from JSON", variant="primary", size="lg")
-                
-                with gr.Column():
-                    json_output = gr.Textbox(
-                        label="Creation Status",
-                        lines=5,
-                        interactive=False
-                    )
-                    json_download_btn = gr.DownloadButton(
-                        "📥 Download JSON Presentation",
+                    download_btn = gr.DownloadButton(
+                        label="📥 Download PowerPoint",
                         visible=False,
                         size="lg"
                     )
         
         with gr.Tab("🔧 MCP Configuration"):
-            gr.Markdown("## MCP Server Configuration")
+            gr.Markdown("## MCP Server Settings for Your Chatbot")
             
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("### For Claude Desktop")
-                    claude_config = '''{
-  "mcpServers": {
-    "powerpoint": {
-      "command": "python",
-      "args": ["path/to/your/app.py", "mcp"],
-      "env": {
-        "MCP_MODE": "stdio"
-      }
-    }
-  }
-}'''
-                    gr.Code(claude_config, language="json")
+                    gr.Markdown("### Configuration Details")
+                    config_code = f"""**Name**: PowerPoint Creator
+**Description**: AI-powered PowerPoint presentation generator with 32 professional tools and streamable HTTP transport
+**URL**: https://brucewayne1-auxoppt.hf.space/mcp
+**Transport**: Stream"""
+                    gr.Code(config_code, language="yaml")
                 
                 with gr.Column():
-                    gr.Markdown("### Command Line Usage")
-                    commands = '''# Run as MCP server
-python app.py mcp
-
-# Or with environment variable
-MCP_MODE=stdio python app.py
-
-# Run web interface (current mode)
-python app.py'''
-                    gr.Code(commands, language="shell")
-            
-            gr.Markdown("### Available MCP Tools")
-            tools_list = """
-- **create_presentation**: Create a new PowerPoint presentation
-- **add_slide**: Add slides with title and content
-- **save_presentation**: Save presentation to file
-- **get_presentation_info**: Get presentation details
-- **add_bullet_slide**: Add slide with bullet points
-- **create_presentation_from_outline**: Create complete presentation from structured data
-            """
-            gr.Markdown(tools_list)
+                    gr.Markdown("### Quick Copy")
+                    gr.Textbox(
+                        value="https://brucewayne1-auxoppt.hf.space/mcp",
+                        label="MCP Server URL",
+                        interactive=True
+                    )
+                    gr.Textbox(
+                        value="Stream",
+                        label="Transport Type",
+                        interactive=False
+                    )
         
         with gr.Tab("📊 Server Status"):
-            status_display = gr.Textbox(
+            status_text = gr.Textbox(
                 value=get_server_status(),
                 label="Server Information",
-                lines=12,
+                lines=10,
                 interactive=False
             )
-            refresh_btn = gr.Button("🔄 Refresh Status")
-            refresh_btn.click(fn=get_server_status, outputs=[status_display])
+            
+            refresh_btn = gr.Button("🔄 Refresh Status", variant="secondary")
+            
+            refresh_btn.click(
+                fn=get_server_status,
+                outputs=[status_text]
+            )
+        
+        with gr.Tab("📖 Available Tools"):
+            gr.Markdown("## All Available MCP Tools")
+            
+            tools_info = """
+### 🎯 Presentation Management (7 tools)
+• create_presentation • create_presentation_from_template • open_presentation
+• save_presentation • get_presentation_info • get_template_file_info • set_core_properties
+### 📝 Content Management (6 tools) 
+• add_slide • get_slide_info • extract_slide_text • extract_presentation_text
+• populate_placeholder • add_bullet_points • manage_text • manage_image
+### 🎨 Template Operations (7 tools)
+• list_slide_templates • apply_slide_template • create_slide_from_template
+• create_presentation_from_templates • get_template_info • auto_generate_presentation • optimize_slide_text
+### 🏗️ Structural Elements (4 tools)
+• add_table • format_table_cell • add_shape • add_chart
+### ✨ Professional Design (3 tools)
+• apply_professional_design • apply_picture_effects • manage_fonts
+### 🔧 Specialized Features (5 tools)
+• manage_hyperlinks • manage_slide_masters • add_connector • update_chart_data • manage_slide_transitions
+            """
+            gr.Markdown(tools_info)
         
         # Event handlers
         create_btn.click(
-            fn=create_presentation_gradio,
-            inputs=[title_input],
-            outputs=[create_output]
-        )
-        
-        add_slide_btn.click(
-            fn=add_slide_gradio,
-            inputs=[slide_title, slide_content],
-            outputs=[slide_output]
-        )
-        
-        def save_and_prepare_download():
-            filepath, message = save_presentation_sync()
-            if filepath:
-                return filepath, message, gr.update(visible=True)
-            else:
-                return None, message, gr.update(visible=False)
-        
-        save_btn.click(
-            fn=save_and_prepare_download,
-            outputs=[download_btn, save_output, download_btn]
-        )
-        
-        json_create_btn.click(
-            fn=create_from_json_gradio,
-            inputs=[json_input],
-            outputs=[json_download_btn, json_output]
+            fn=create_presentation_from_json,
+            inputs=[slides_input],
+            outputs=[download_btn, status_output]
         ).then(
             fn=lambda x: gr.update(visible=bool(x)),
-            inputs=[json_download_btn],
-            outputs=[json_download_btn]
+            inputs=[download_btn],
+            outputs=[download_btn]
         )
     
     return demo
-
-# MCP Server runner
-async def run_mcp_server():
-    """Run the MCP server with STDIO transport."""
-    if not MCP_AVAILABLE or server is None:
-        print("Error: MCP library not available or server not initialized.")
-        return
-    
-    async with stdio_server() as (read_stream, write_stream):
-        await server.run(
-            read_stream,
-            write_stream,
-            server.create_initialization_options()
-        )
-
+# MCP Server startup function
+def start_mcp_server():
+    """Start the MCP server with streamable HTTP transport"""
+    try:
+        logger.info("Starting MCP Server with streamable HTTP transport...")
+        # Use streamable HTTP transport on port 8000
+        mcp_app.run(transport='streamable-http', port=8000)
+    except Exception as e:
+        logger.error(f"Failed to start MCP server: {str(e)}")
 # Main execution
-def main():
-    """Main entry point."""
-    print(f"🔍 Dependency Check:")
-    print(f"  - MCP: {'✅' if MCP_AVAILABLE else '❌'}")
-    print(f"  - python-pptx: {'✅' if PPTX_AVAILABLE else '❌'}")
-    
-    # Check command line arguments and environment
-    if len(sys.argv) > 1 and sys.argv[1] == "mcp":
-        # Run as MCP server
-        print("Starting PowerPoint MCP Server with STDIO transport...")
-        if not MCP_AVAILABLE:
-            print("Error: MCP library not available. Install with: pip install mcp")
-            sys.exit(1)
-        asyncio.run(run_mcp_server())
-    elif os.getenv("MCP_MODE") == "stdio":
-        # Run as MCP server via environment variable
-        print("Starting PowerPoint MCP Server (via MCP_MODE env var)...")
-        if not MCP_AVAILABLE:
-            print("Error: MCP library not available. Install with: pip install mcp")
-            sys.exit(1)
-        asyncio.run(run_mcp_server())
-    else:
-        # Run Gradio web interface
-        print("Starting PowerPoint MCP Server with Gradio web interface...")
-        demo = create_gradio_interface()
-        demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=True,
-            show_error=True
-        )
-
 if __name__ == "__main__":
-    main()
+    # Start MCP server in background thread
+    mcp_thread = Thread(target=start_mcp_server, daemon=True)
+    mcp_thread.start()
+    
+    # Wait for MCP server to start
+    time.sleep(3)
+    logger.info("MCP Server started on port 8000 with streamable HTTP transport")
+    
+    # Launch Gradio interface
+    demo = create_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True,
+        show_api=False
+    )