linked the backend back

README.md

@@ -44,74 +44,178 @@ Author: Csaba (BladeSzaSza)
 """
 
 import gradio as gr
-
-
-# ── 3.  Dummy backend for local dev (replace with real fn) ───────
-def process_video_standard(video, model, viz, kp):
-    """Return empty JSON + passthrough video placeholder."""
-    return {}, video
+import os
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+
+# Import agent API if available
+# Initialize agent API if available
+agent_api = None
+try:
+    from gradio_labanmovementanalysis.agent_api import (
+        LabanAgentAPI,
+        PoseModel,
+        MovementDirection,
+        MovementIntensity
+    )
+    HAS_AGENT_API = True
+    
+    try:
+        agent_api = LabanAgentAPI()
+    except Exception as e:
+        print(f"Warning: Agent API not available: {e}")
+        agent_api = None
+except ImportError:
+    HAS_AGENT_API = False
+# Initialize components
+try:
+    analyzer = LabanMovementAnalysis(
+        enable_visualization=True
+    )
+    print("✅ Core features initialized successfully")
+except Exception as e:
+    print(f"Warning: Some features may not be available: {e}")
+    analyzer = LabanMovementAnalysis()
+
+
+def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
+    """Enhanced video processing with all new features."""
+    if not video_input:
+        return {"error": "No video provided"}, None
+    
+    try:
+        # Handle both file upload and URL input
+        video_path = video_input.name if hasattr(video_input, 'name') else video_input
+        
+        json_result, viz_result = analyzer.process_video(
+            video_path,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_result, viz_result
+    except Exception as e:
+        error_result = {"error": str(e)}
+        return error_result, None
+
+def process_video_standard(video, model, enable_viz, include_keypoints):
+    """Standard video processing function."""
+    if video is None:
+        return None, None
+    
+    try:
+        json_output, video_output = analyzer.process_video(
+            video,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_output, video_output
+    except Exception as e:
+        return {"error": str(e)}, None
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
     with gr.Blocks(
-        title="Laban Movement Analysis – Complete Suite",
+        title="Laban Movement Analysis",
         theme='gstaff/sketch',
         fill_width=True,
     ) as demo:
 
         # ── Hero banner ──
-        gr.HTML(
+        gr.Markdown(
             """
-            <div class="main-header">
-              <h1>🎭 Laban Movement Analysis – Complete Suite</h1>
-              <p>Pose estimation • AI action recognition • Real-time agents</p>
-              <p style="font-size:.85rem;opacity:.85">v0.01-beta • 20+ pose models • MCP</p>
-            </div>
+            # 🎭 Laban Movement Analysis – Complete Suite
+            
+            Pose estimation • AI action recognition 
             """
         )
-
-        # ── Workspace ──
-        with gr.Row(equal_height=True):
-            # Input column
-            with gr.Column(scale=1, min_width=260):
-                video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
-                model_sel = gr.Dropdown(
-                    ["mediapipe", "movenet", "yolo"], value="mediapipe", label="Pose Model"
+        with gr.Tabs():
+            # Tab 1: Standard Analysis
+            with gr.Tab("🎬 Standard Analysis"):
+                gr.Markdown("""
+                ### Classic Laban Movement Analysis
+                Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
+                """)
+                # ── Workspace ──
+                with gr.Row(equal_height=True):
+                    # Input column
+                    with gr.Column(scale=1, min_width=260):
+                        
+                        video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
+                        # URL input option
+                        url_input_enh = gr.Textbox(
+                            label="Or Enter Video URL",
+                            placeholder="YouTube URL, Vimeo URL, or direct video URL",
+                            info="Leave file upload empty to use URL"
+                        )
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mp4"],
+                                ["https://www.youtube.com/shorts/RX9kH2l3L8U"],
+                                ["https://vimeo.com/815392738"]
+                            ],
+                            inputs=url_input_enh,
+                            label="Examples"
+                        )
+                        gr.Markdown("**Model Selection**")
+                        
+                        model_sel = gr.Dropdown(
+                            choices=[
+                                # MediaPipe variants
+                                "mediapipe-lite", "mediapipe-full", "mediapipe-heavy",
+                                # MoveNet variants
+                                "movenet-lightning", "movenet-thunder",
+                                # YOLO v8 variants
+                                "yolo-v8-n", "yolo-v8-s", "yolo-v8-m", "yolo-v8-l", "yolo-v8-x",
+                                # YOLO v11 variants
+                                "yolo-v11-n", "yolo-v11-s", "yolo-v11-m", "yolo-v11-l", "yolo-v11-x"
+                            ],
+                            value="mediapipe-full",
+                            label="Advanced Pose Models",
+                            info="15 model variants available"
+                        )
+
+                        gr.Markdown("**Analysis Options**")
+                        
+                        with gr.Accordion("Options", open=False):
+                            enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
+                            include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
+                        analyze_btn_enh = gr.Button("🚀 Enhanced Analysis", variant="primary", size="lg")
+
+                    # Output column
+                    with gr.Column(scale=2, min_width=320):
+                        viz_out = gr.Video(label="Annotated Video")
+                        with gr.Accordion("Raw JSON", open=False):
+                            json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
+
+                # Wiring
+                def process_enhanced_input(file_input, url_input, model, enable_viz, include_keypoints):
+                    """Process either file upload or URL input."""
+                    video_source = file_input if file_input else url_input
+                    return process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                
+                analyze_btn_enh.click(
+                    fn=process_enhanced_input,
+                    inputs=[video_in, url_input_enh, model_sel, enable_viz, include_kp],
+                    outputs=[json_out, viz_out],
+                    api_name="analyze_enhanced"
                 )
-                with gr.Accordion("Options", open=False):
-                    enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
-                    include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
-                analyze_btn = gr.Button("Analyze Movement", variant="primary")
-
-            # Output column
-            with gr.Column(scale=2, min_width=320):
-                viz_out = gr.Video(label="Annotated Video")
-                with gr.Accordion("Raw JSON", open=False):
-                    json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
-
-        # Wiring
-        analyze_btn.click(
-            fn=process_video_standard,
-            inputs=[video_in, model_sel, enable_viz, include_kp],
-            outputs=[json_out, viz_out],
-        )
 
         # Footer
-        gr.HTML(
-            """
-            <div class="author-info">
-              Built by Csaba Bolyós •
-              <a href="https://github.com/bladeszasza" target="_blank">GitHub</a> •
-              <a href="https://huggingface.co/BladeSzaSza" target="_blank">HF</a>
-            </div>
-            """
-        )
+        with gr.Row():
+            gr.Markdown(
+                """
+                **Built by Csaba Bolyós**  
+                [GitHub](https://github.com/bladeszasza) • [HF](https://huggingface.co/BladeSzaSza)
+                """
+            )
     return demo
-    
+  
 if __name__ == "__main__":
-        print("🚀 Starting Laban Movement Analysis...")
-        demo = create_demo()
-        
+    demo = create_demo()
+    demo.launch(server_name="0.0.0.0",
+                server_port=int(os.getenv("PORT", 7860)),
+                mcp_server=True) 
 
 ```
 
@@ -170,6 +274,11 @@ bool
 
 
 
+```python
+bool
+```
+
+
 
 <tr>
 <td align="left"><code>label</code></td>

demo/app.py

@@ -6,17 +6,78 @@ Author: Csaba (BladeSzaSza)
 
 import gradio as gr
 import os
+from gradio_labanmovementanalysis import LabanMovementAnalysis
 
+# Import agent API if available
+# Initialize agent API if available
+agent_api = None
+try:
+    from gradio_labanmovementanalysis.agent_api import (
+        LabanAgentAPI,
+        PoseModel,
+        MovementDirection,
+        MovementIntensity
+    )
+    HAS_AGENT_API = True
+    
+    try:
+        agent_api = LabanAgentAPI()
+    except Exception as e:
+        print(f"Warning: Agent API not available: {e}")
+        agent_api = None
+except ImportError:
+    HAS_AGENT_API = False
+# Initialize components
+try:
+    analyzer = LabanMovementAnalysis(
+        enable_visualization=True
+    )
+    print("✅ Core features initialized successfully")
+except Exception as e:
+    print(f"Warning: Some features may not be available: {e}")
+    analyzer = LabanMovementAnalysis()
 
-# ── 3.  Dummy backend for local dev (replace with real fn) ───────
-def process_video_standard(video, model, viz, kp):
-    """Return empty JSON + passthrough video placeholder."""
-    return {}, video
+
+def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
+    """Enhanced video processing with all new features."""
+    if not video_input:
+        return {"error": "No video provided"}, None
+    
+    try:
+        # Handle both file upload and URL input
+        video_path = video_input.name if hasattr(video_input, 'name') else video_input
+        
+        json_result, viz_result = analyzer.process_video(
+            video_path,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_result, viz_result
+    except Exception as e:
+        error_result = {"error": str(e)}
+        return error_result, None
+
+def process_video_standard(video, model, enable_viz, include_keypoints):
+    """Standard video processing function."""
+    if video is None:
+        return None, None
+    
+    try:
+        json_output, video_output = analyzer.process_video(
+            video,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_output, video_output
+    except Exception as e:
+        return {"error": str(e)}, None
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
     with gr.Blocks(
-        title="Laban Movement Analysis – Complete Suite",
+        title="Laban Movement Analysis",
         theme='gstaff/sketch',
         fill_width=True,
     ) as demo:
@@ -26,36 +87,80 @@ def create_demo() -> gr.Blocks:
             """
             # 🎭 Laban Movement Analysis – Complete Suite
             
-            Pose estimation • AI action recognition • Real-time agents  
-            **v0.01-beta • 20+ pose models • MCP**
+            Pose estimation • AI action recognition 
             """
         )
+        with gr.Tabs():
+            # Tab 1: Standard Analysis
+            with gr.Tab("🎬 Standard Analysis"):
+                gr.Markdown("""
+                ### Classic Laban Movement Analysis
+                Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
+                """)
+                # ── Workspace ──
+                with gr.Row(equal_height=True):
+                    # Input column
+                    with gr.Column(scale=1, min_width=260):
+                        
+                        video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
+                        # URL input option
+                        url_input_enh = gr.Textbox(
+                            label="Or Enter Video URL",
+                            placeholder="YouTube URL, Vimeo URL, or direct video URL",
+                            info="Leave file upload empty to use URL"
+                        )
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mp4"],
+                                ["https://www.youtube.com/shorts/RX9kH2l3L8U"],
+                                ["https://vimeo.com/815392738"]
+                            ],
+                            inputs=url_input_enh,
+                            label="Examples"
+                        )
+                        gr.Markdown("**Model Selection**")
+                        
+                        model_sel = gr.Dropdown(
+                            choices=[
+                                # MediaPipe variants
+                                "mediapipe-lite", "mediapipe-full", "mediapipe-heavy",
+                                # MoveNet variants
+                                "movenet-lightning", "movenet-thunder",
+                                # YOLO v8 variants
+                                "yolo-v8-n", "yolo-v8-s", "yolo-v8-m", "yolo-v8-l", "yolo-v8-x",
+                                # YOLO v11 variants
+                                "yolo-v11-n", "yolo-v11-s", "yolo-v11-m", "yolo-v11-l", "yolo-v11-x"
+                            ],
+                            value="mediapipe-full",
+                            label="Advanced Pose Models",
+                            info="15 model variants available"
+                        )
 
-        # ── Workspace ──
-        with gr.Row(equal_height=True):
-            # Input column
-            with gr.Column(scale=1, min_width=260):
-                video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
-                model_sel = gr.Dropdown(
-                    ["mediapipe", "movenet", "yolo"], value="mediapipe", label="Pose Model"
-                )
-                with gr.Accordion("Options", open=False):
-                    enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
-                    include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
-                analyze_btn = gr.Button("Analyze Movement", variant="primary")
+                        gr.Markdown("**Analysis Options**")
+                        
+                        with gr.Accordion("Options", open=False):
+                            enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
+                            include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
+                        analyze_btn_enh = gr.Button("🚀 Enhanced Analysis", variant="primary", size="lg")
 
-            # Output column
-            with gr.Column(scale=2, min_width=320):
-                viz_out = gr.Video(label="Annotated Video")
-                with gr.Accordion("Raw JSON", open=False):
-                    json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
+                    # Output column
+                    with gr.Column(scale=2, min_width=320):
+                        viz_out = gr.Video(label="Annotated Video")
+                        with gr.Accordion("Raw JSON", open=False):
+                            json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
 
-        # Wiring
-        analyze_btn.click(
-            fn=process_video_standard,
-            inputs=[video_in, model_sel, enable_viz, include_kp],
-            outputs=[json_out, viz_out],
-        )
+                # Wiring
+                def process_enhanced_input(file_input, url_input, model, enable_viz, include_keypoints):
+                    """Process either file upload or URL input."""
+                    video_source = file_input if file_input else url_input
+                    return process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                
+                analyze_btn_enh.click(
+                    fn=process_enhanced_input,
+                    inputs=[video_in, url_input_enh, model_sel, enable_viz, include_kp],
+                    outputs=[json_out, viz_out],
+                    api_name="analyze_enhanced"
+                )
 
         # Footer
         with gr.Row():

demo/space.py

@@ -1,4 +1,6 @@
+
 import gradio as gr
+from app import demo as app
 import os
 
 _docs = {'LabanMovementAnalysis': {'description': 'Gradio component for video-based pose analysis with Laban Movement Analysis metrics.', 'members': {'__init__': {'default_model': {'type': 'str', 'default': '"mediapipe"', 'description': 'Default pose estimation model ("mediapipe", "movenet", "yolo")'}, 'enable_visualization': {'type': 'bool', 'default': 'True', 'description': 'Whether to generate visualization video by default'}, 'include_keypoints': {'type': 'bool', 'default': 'False', 'description': 'Whether to include raw keypoints in JSON output'}, 'enable_webrtc': {'type': 'bool', 'default': 'False', 'description': 'Whether to enable WebRTC real-time analysis'}, 'label': {'type': 'typing.Optional[str][str, None]', 'default': 'None', 'description': 'Component label'}, 'every': {'type': 'typing.Optional[float][float, None]', 'default': 'None', 'description': None}, 'show_label': {'type': 'typing.Optional[bool][bool, None]', 'default': 'None', 'description': None}, 'container': {'type': 'bool', 'default': 'True', 'description': None}, 'scale': {'type': 'typing.Optional[int][int, None]', 'default': 'None', 'description': None}, 'min_width': {'type': 'int', 'default': '160', 'description': None}, 'interactive': {'type': 'typing.Optional[bool][bool, None]', 'default': 'None', 'description': None}, 'visible': {'type': 'bool', 'default': 'True', 'description': None}, 'elem_id': {'type': 'typing.Optional[str][str, None]', 'default': 'None', 'description': None}, 'elem_classes': {'type': 'typing.Optional[typing.List[str]][\n    typing.List[str][str], None\n]', 'default': 'None', 'description': None}, 'render': {'type': 'bool', 'default': 'True', 'description': None}}, 'postprocess': {'value': {'type': 'typing.Any', 'description': 'Analysis results'}}, 'preprocess': {'return': {'type': 'typing.Dict[str, typing.Any][str, typing.Any]', 'description': 'Processed data for analysis'}, 'value': None}}, 'events': {}}, '__meta__': {'additional_interfaces': {}, 'user_fn_refs': {'LabanMovementAnalysis': []}}}
@@ -18,8 +20,9 @@ with gr.Blocks(
 
 A Gradio 5 component for video movement analysis using Laban Movement Analysis (LMA) with MCP support for AI agents
 """, elem_classes=["md-custom"], header_links=True)
+    app.render()
     gr.Markdown(
-'''
+"""
 ## Installation
 
 ```bash
@@ -36,74 +39,181 @@ Author: Csaba (BladeSzaSza)
 \"\"\"
 
 import gradio as gr
-
-
-# ── 3.  Dummy backend for local dev (replace with real fn) ───────
-def process_video_standard(video, model, viz, kp):
-    \"\"\"Return empty JSON + passthrough video placeholder.\"\"\"
-    return {}, video
+import os
+from gradio_labanmovementanalysis import LabanMovementAnalysis
+
+# Import agent API if available
+# Initialize agent API if available
+agent_api = None
+try:
+    from gradio_labanmovementanalysis.agent_api import (
+        LabanAgentAPI,
+        PoseModel,
+        MovementDirection,
+        MovementIntensity
+    )
+    HAS_AGENT_API = True
+    
+    try:
+        agent_api = LabanAgentAPI()
+    except Exception as e:
+        print(f"Warning: Agent API not available: {e}")
+        agent_api = None
+except ImportError:
+    HAS_AGENT_API = False
+# Initialize components
+try:
+    analyzer = LabanMovementAnalysis(
+        enable_visualization=True
+    )
+    print("✅ Core features initialized successfully")
+except Exception as e:
+    print(f"Warning: Some features may not be available: {e}")
+    analyzer = LabanMovementAnalysis()
+
+
+def process_video_enhanced(video_input, model, enable_viz, include_keypoints):
+    \"\"\"Enhanced video processing with all new features.\"\"\"
+    if not video_input:
+        return {"error": "No video provided"}, None
+    
+    try:
+        # Handle both file upload and URL input
+        video_path = video_input.name if hasattr(video_input, 'name') else video_input
+        
+        json_result, viz_result = analyzer.process_video(
+            video_path,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_result, viz_result
+    except Exception as e:
+        error_result = {"error": str(e)}
+        return error_result, None
+
+def process_video_standard(video, model, enable_viz, include_keypoints):
+    \"\"\"Standard video processing function.\"\"\"
+    if video is None:
+        return None, None
+    
+    try:
+        json_output, video_output = analyzer.process_video(
+            video,
+            model=model,
+            enable_visualization=enable_viz,
+            include_keypoints=include_keypoints
+        )
+        return json_output, video_output
+    except Exception as e:
+        return {"error": str(e)}, None
 
 # ── 4.  Build UI ─────────────────────────────────────────────────
 def create_demo() -> gr.Blocks:
     with gr.Blocks(
-        title="Laban Movement Analysis – Complete Suite",
+        title="Laban Movement Analysis",
         theme='gstaff/sketch',
         fill_width=True,
     ) as demo:
 
         # ── Hero banner ──
         gr.Markdown(
-            """
+            \"\"\"
             # 🎭 Laban Movement Analysis – Complete Suite
             
-            Pose estimation • AI action recognition • Real-time agents  
-            **v0.01-beta • 20+ pose models • MCP**
-            """
+            Pose estimation • AI action recognition 
+            \"\"\"
         )
-
-        # ── Workspace ──
-        with gr.Row(equal_height=True):
-            # Input column
-            with gr.Column(scale=1, min_width=260):
-                video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
-                model_sel = gr.Dropdown(
-                    ["mediapipe", "movenet", "yolo"], value="mediapipe", label="Pose Model"
+        with gr.Tabs():
+            # Tab 1: Standard Analysis
+            with gr.Tab("🎬 Standard Analysis"):
+                gr.Markdown(\"\"\"
+                ### Classic Laban Movement Analysis
+                Upload a video file to analyze movement using traditional LMA metrics with pose estimation.
+                \"\"\")
+                # ── Workspace ──
+                with gr.Row(equal_height=True):
+                    # Input column
+                    with gr.Column(scale=1, min_width=260):
+                        
+                        video_in = gr.Video(label="Upload Video", sources=["upload"], format="mp4")
+                        # URL input option
+                        url_input_enh = gr.Textbox(
+                            label="Or Enter Video URL",
+                            placeholder="YouTube URL, Vimeo URL, or direct video URL",
+                            info="Leave file upload empty to use URL"
+                        )
+                        gr.Examples(
+                            examples=[
+                                ["examples/balette.mp4"],
+                                ["https://www.youtube.com/shorts/RX9kH2l3L8U"],
+                                ["https://vimeo.com/815392738"]
+                            ],
+                            inputs=url_input_enh,
+                            label="Examples"
+                        )
+                        gr.Markdown("**Model Selection**")
+                        
+                        model_sel = gr.Dropdown(
+                            choices=[
+                                # MediaPipe variants
+                                "mediapipe-lite", "mediapipe-full", "mediapipe-heavy",
+                                # MoveNet variants
+                                "movenet-lightning", "movenet-thunder",
+                                # YOLO v8 variants
+                                "yolo-v8-n", "yolo-v8-s", "yolo-v8-m", "yolo-v8-l", "yolo-v8-x",
+                                # YOLO v11 variants
+                                "yolo-v11-n", "yolo-v11-s", "yolo-v11-m", "yolo-v11-l", "yolo-v11-x"
+                            ],
+                            value="mediapipe-full",
+                            label="Advanced Pose Models",
+                            info="15 model variants available"
+                        )
+
+                        gr.Markdown("**Analysis Options**")
+                        
+                        with gr.Accordion("Options", open=False):
+                            enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
+                            include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
+                        analyze_btn_enh = gr.Button("🚀 Enhanced Analysis", variant="primary", size="lg")
+
+                    # Output column
+                    with gr.Column(scale=2, min_width=320):
+                        viz_out = gr.Video(label="Annotated Video")
+                        with gr.Accordion("Raw JSON", open=False):
+                            json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
+
+                # Wiring
+                def process_enhanced_input(file_input, url_input, model, enable_viz, include_keypoints):
+                    \"\"\"Process either file upload or URL input.\"\"\"
+                    video_source = file_input if file_input else url_input
+                    return process_video_enhanced(video_source, model, enable_viz, include_keypoints)
+                
+                analyze_btn_enh.click(
+                    fn=process_enhanced_input,
+                    inputs=[video_in, url_input_enh, model_sel, enable_viz, include_kp],
+                    outputs=[json_out, viz_out],
+                    api_name="analyze_enhanced"
                 )
-                with gr.Accordion("Options", open=False):
-                    enable_viz = gr.Radio([("Yes", 1), ("No", 0)], value=1, label="Visualization")
-                    include_kp = gr.Radio([("Yes", 1), ("No", 0)], value=0, label="Raw Keypoints")
-                analyze_btn = gr.Button("Analyze Movement", variant="primary")
-
-            # Output column
-            with gr.Column(scale=2, min_width=320):
-                viz_out = gr.Video(label="Annotated Video")
-                with gr.Accordion("Raw JSON", open=False):
-                    json_out = gr.JSON(label="Movement Analysis", elem_classes=["json-output"])
-
-        # Wiring
-        analyze_btn.click(
-            fn=process_video_standard,
-            inputs=[video_in, model_sel, enable_viz, include_kp],
-            outputs=[json_out, viz_out],
-        )
 
         # Footer
         with gr.Row():
             gr.Markdown(
-                """
+                \"\"\"
                 **Built by Csaba Bolyós**  
                 [GitHub](https://github.com/bladeszasza) • [HF](https://huggingface.co/BladeSzaSza)
-                """
+                \"\"\"
             )
     return demo
-    
+  
 if __name__ == "__main__":
-        print("🚀 Starting Laban Movement Analysis...")
-        demo = create_demo()
-        
+    demo = create_demo()
+    demo.launch(server_name="0.0.0.0",
+                server_port=int(os.getenv("PORT", 7860)),
+                mcp_server=True) 
 
 ```
-''', elem_classes=["md-custom"], header_links=True)
+""", elem_classes=["md-custom"], header_links=True)
 
 
     gr.Markdown("""

pyproject.toml

@@ -5,7 +5,7 @@ description = "A Gradio 5 component for video movement analysis using Laban Move
 readme = "README.md"
 license = "apache-2.0"
 authors = [{ name = "Csaba Bolyós", email = "bladeszasza@gmail.com" }]
-keywords = ["gradio-custom-component", "gradio-5", "laban-movement-analysis", "LMA", "pose-estimation", "movement-analysis", "mcp", "ai-agents", "webrtc"]
+keywords = ["gradio-custom-component", "gradio-5", "laban-movement-analysis", "LMA", "pose-estimation", "movement-analysis", "mcp", "ai-agents"]
 # Core dependencies
 requires-python = ">=3.10"
 dependencies = [

version.py

@@ -24,7 +24,6 @@ RELEASE_NOTES = """
 🌟 Core Features:
 - 17+ Pose Estimation Models (MediaPipe, MoveNet, YOLO v8/v11 with x variants)
 - YouTube & Vimeo URL Support
-- Real-time WebRTC Camera Analysis
 - Agent API with MCP Integration
 - Batch Processing & Movement Filtering
 - Professional VIRIDIAN UI Theme
@@ -32,7 +31,6 @@ RELEASE_NOTES = """
 🚀 Technical Stack:
 - Gradio 5.0+ Frontend
 - OpenCV + MediaPipe + Ultralytics YOLO
-- WebRTC Streaming Technology
 - FastAPI Backend Integration
 
 ⚠️  Beta Status: