try to fix permission denied issue in community cloud

README.md

@@ -9,7 +9,7 @@ A tool for analyzing golf swings using computer vision and AI.
 - Pose estimation and tracking
 - Swing phase segmentation
 - Club and ball trajectory analysis
-- LLM-powered swing analysis and coaching tips
+- LLM-powered swing analysis and coaching tips (OpenAI GPT-4/3.5 or local Ollama models)
 - Annotated video generation
 - Side-by-side comparison with professional golfer
 - Improvement recommendations from AI analysis
@@ -29,10 +29,32 @@ A tool for analyzing golf swings using computer vision and AI.
    - Save a video of a professional golfer's swing as `pro_golfer.mp4` in the `downloads` directory
    - This will be used for the side-by-side comparison feature
 
-5. Set your OpenAI API key as an environment variable:
-   ```
-   export OPENAI_API_KEY="your-api-key"
-   ```
+5. Set up LLM services for analysis (optional):
+
+   **Option 1: OpenAI**
+   - Set your OpenAI API key in `.streamlit/secrets.toml`:
+     ```toml
+     [openai]
+     api_key = "your-openai-api-key-here"
+     ```
+
+   **Option 2: Ollama (Local LLM)**
+   - Install and run Ollama locally: https://ollama.ai/
+   - Configure in `.streamlit/secrets.toml`:
+     ```toml
+     [ollama]
+     base_url = "http://localhost:11434/v1"
+     model = "llama2"  # or your preferred model
+     ```
+
+   **Option 3: Both Services**
+   - Configure both in `.streamlit/secrets.toml` for automatic fallback
+   - The app will try Ollama first, then OpenAI if Ollama fails
+
+   **No Configuration**
+   - The app works without any LLM configuration using sample analysis mode
+
+   See `.streamlit/secrets.toml.example` for a complete configuration template.
 
 ## Running the Application
 
@@ -61,7 +83,7 @@ The application uses:
 - YOLOv8 for object detection
 - MediaPipe for pose estimation
 - OpenCV for video processing
-- OpenAI GPT-4 for swing analysis
+- OpenAI GPT-4/3.5 or Ollama for swing analysis
 - Streamlit for the web interface
 
 ## Directory Structure

app/models/llm_analyzer.py

@@ -8,6 +8,49 @@ from openai import OpenAI
 import streamlit as st
 
 
+def check_llm_services():
+    """
+    Check which LLM services are configured
+    
+    Returns:
+        dict: Dictionary with service availability and configuration
+    """
+    services = {
+        'ollama': {
+            'available': False,
+            'config': {}
+        },
+        'openai': {
+            'available': False,
+            'config': {}
+        }
+    }
+
+    # Check Ollama configuration
+    try:
+        ollama_url = st.secrets.get("ollama", {}).get("base_url", "")
+        ollama_model = st.secrets.get("ollama", {}).get("model", "")
+        if ollama_url and ollama_model:
+            services['ollama']['available'] = True
+            services['ollama']['config'] = {
+                'base_url': ollama_url,
+                'model': ollama_model
+            }
+    except (KeyError, FileNotFoundError, AttributeError):
+        pass
+
+    # Check OpenAI configuration
+    try:
+        openai_key = st.secrets.get("openai", {}).get("api_key", "")
+        if openai_key:
+            services['openai']['available'] = True
+            services['openai']['config'] = {'api_key': openai_key}
+    except (KeyError, FileNotFoundError, AttributeError):
+        pass
+
+    return services
+
+
 def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
     """
     Generate swing analysis and coaching tips using LLM
@@ -20,111 +63,162 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
     Returns:
         str: Detailed swing analysis and coaching tips
     """
-    # Check if OpenAI API key is available from secrets
-    try:
-        api_key = st.secrets["openai"]["api_key"]
-    except (KeyError, FileNotFoundError):
-        # Return a sample analysis instead of an error message
-        return """
-## Swing Analysis Summary
-
-Based on the video analysis, here are some observations about your swing:
-
-### Setup Phase
-- Your stance appears slightly wider than shoulder-width, which can provide good stability
-- Your posture shows a good spine angle, though you could bend slightly more from the hips
-- The ball position looks appropriate for the club you're using
-
-### Backswing
-- Your takeaway is smooth with good tempo
-- Your wrist hinge develops appropriately in the backswing
-- Your right elbow could be kept a bit closer to your body for better consistency
-
-### Downswing
-- Good weight transfer from back foot to front foot during the transition
-- Your hips are rotating well through impact
-- The swing plane looks consistent throughout the downswing
+    # Check available services
+    services = check_llm_services()
 
-### Impact
-- Club face alignment at impact appears slightly open
-- Your head position is stable through impact
-- The club path is on a good line toward the target
+    # If no services are available, return sample analysis
+    if not services['ollama']['available'] and not services['openai'][
+            'available']:
+        return get_sample_analysis()
 
-### Follow Through
-- Good balance maintained through the finish
-- Full extension of arms after impact
-- Complete rotation of the body toward the target
+    # Prepare data for LLM
+    analysis_data = prepare_data_for_llm(pose_data, swing_phases,
+                                         trajectory_data)
+    prompt = create_llm_prompt(analysis_data)
 
-## Areas for Improvement
+    # Try Ollama first if available
+    if services['ollama']['available']:
+        try:
+            analysis = call_ollama_service(prompt,
+                                           services['ollama']['config'])
+            if analysis:
+                return analysis
+        except Exception as e:
+            print(f"Error with Ollama: {str(e)}. Falling back to OpenAI...")
 
-1. **Club Face Control**: The slightly open club face at impact suggests you may be prone to slicing the ball. Focus on maintaining a square club face through impact.
+    # Try OpenAI if available
+    if services['openai']['available']:
+        try:
+            analysis = call_openai_service(prompt,
+                                           services['openai']['config'])
+            if analysis:
+                return analysis
+        except Exception as e:
+            print(
+                f"Error with OpenAI: {str(e)}. Using sample analysis instead.")
 
-2. **Right Elbow Position**: Keeping your right elbow closer to your body during the backswing will help create a more consistent swing plane.
+    # If both services failed, return sample analysis
+    return get_sample_analysis()
 
-3. **Hip Rotation**: While your hip rotation is good, increasing the speed of rotation could generate more power in your swing.
 
-4. **Wrist Release**: Your wrist release could be more active through impact to generate additional club head speed.
+def call_ollama_service(prompt, config):
+    """
+    Call Ollama service for analysis
+    
+    Args:
+        prompt (str): The analysis prompt
+        config (dict): Ollama configuration
+        
+    Returns:
+        str: Analysis result or None if failed
+    """
+    try:
+        # Create a custom httpx client
+        http_client = httpx.Client()
 
-These adjustments should help improve both consistency and distance in your swing.
-"""
+        # Initialize OpenAI client with Ollama endpoint
+        client = OpenAI(
+            base_url=config['base_url'],
+            api_key="ollama",  # Ollama doesn't need a real API key
+            http_client=http_client)
+
+        response = client.chat.completions.create(
+            model=config['model'],
+            messages=[{
+                "role":
+                "system",
+                "content":
+                "You are a professional golf coach with expertise in analyzing golf swings. Provide detailed, actionable feedback based on the swing data provided."
+            }, {
+                "role": "user",
+                "content": prompt
+            }],
+            temperature=0.7,
+            max_tokens=1000)
+
+        return response.choices[0].message.content
 
-    # Prepare data for LLM
-    analysis_data = prepare_data_for_llm(pose_data, swing_phases,
-                                         trajectory_data)
+    except Exception as e:
+        print(f"Ollama service error: {str(e)}")
+        return None
 
-    # Generate prompt for LLM
-    prompt = create_llm_prompt(analysis_data)
 
+def call_openai_service(prompt, config):
+    """
+    Call OpenAI service for analysis
+    
+    Args:
+        prompt (str): The analysis prompt
+        config (dict): OpenAI configuration
+        
+    Returns:
+        str: Analysis result or None if failed
+    """
     try:
         # Create a custom httpx client without proxies
         http_client = httpx.Client()
-        
-        # Initialize the OpenAI client with the custom http client
-        # This avoids any proxy settings that might be causing issues
-        client = OpenAI(
-            api_key=api_key,
-            http_client=http_client
-        )
-        
+
+        # Initialize the OpenAI client
+        client = OpenAI(api_key=config['api_key'], http_client=http_client)
+
         try:
             # Try with GPT-4 first
             response = client.chat.completions.create(
                 model="gpt-4-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a professional golf coach with expertise in analyzing golf swings. Provide detailed, actionable feedback based on the swing data provided."},
-                    {"role": "user", "content": prompt}
-                ],
+                messages=[{
+                    "role":
+                    "system",
+                    "content":
+                    "You are a professional golf coach with expertise in analyzing golf swings. Provide detailed, actionable feedback based on the swing data provided."
+                }, {
+                    "role": "user",
+                    "content": prompt
+                }],
                 temperature=0.7,
-                max_tokens=1000
-            )
-            
-            # Extract content from the response
-            analysis = response.choices[0].message.content
-            return analysis
-            
+                max_tokens=1000)
+
+            return response.choices[0].message.content
+
         except Exception as gpt4_error:
             # If there's an error with GPT-4 (like quota exceeded), try GPT-3.5
-            print(f"Error with GPT-4: {str(gpt4_error)}. Falling back to GPT-3.5-turbo...")
-            
+            print(
+                f"Error with GPT-4: {str(gpt4_error)}. Falling back to GPT-3.5-turbo..."
+            )
+
             try:
                 response = client.chat.completions.create(
                     model="gpt-3.5-turbo",
-                    messages=[
-                        {"role": "system", "content": "You are a professional golf coach with expertise in analyzing golf swings. Provide detailed, actionable feedback based on the swing data provided."},
-                        {"role": "user", "content": prompt}
-                    ],
+                    messages=[{
+                        "role":
+                        "system",
+                        "content":
+                        "You are a professional golf coach with expertise in analyzing golf swings. Provide detailed, actionable feedback based on the swing data provided."
+                    }, {
+                        "role": "user",
+                        "content": prompt
+                    }],
                     temperature=0.7,
-                    max_tokens=1000
-                )
-                
-                # Extract content from the response
-                analysis = response.choices[0].message.content
-                return analysis
-                
+                    max_tokens=1000)
+
+                return response.choices[0].message.content
+
             except Exception as gpt35_error:
-                # Both models failed, return the sample analysis
-                print(f"Error with GPT-3.5: {str(gpt35_error)}. Using sample analysis instead.")
-                return """
+                print(f"Error with GPT-3.5: {str(gpt35_error)}")
+                return None
+
+    except Exception as e:
+        print(f"OpenAI service error: {str(e)}")
+        return None
+
+
+def get_sample_analysis():
+    """
+    Return sample analysis when no LLM services are available
+    
+    Returns:
+        str: Sample swing analysis
+    """
+    return """
 ## Swing Analysis Summary
 
 Based on the video analysis, here are some observations about your swing:
@@ -167,9 +261,6 @@ Based on the video analysis, here are some observations about your swing:
 These adjustments should help improve both consistency and distance in your swing.
 """
 
-    except Exception as e:
-        return f"Error generating swing analysis: {str(e)}"
-
 
 def prepare_data_for_llm(pose_data, swing_phases, trajectory_data):
     """
@@ -214,18 +305,18 @@ def prepare_data_for_llm(pose_data, swing_phases, trajectory_data):
     # Calculate backswing and downswing durations if available
     backswing_frames = swing_phases.get("backswing", [])
     downswing_frames = swing_phases.get("downswing", [])
-    
+
     backswing_duration = None
     downswing_duration = None
-    
+
     if backswing_frames:
         # Assuming 30 fps video
         backswing_duration = len(backswing_frames) / 30.0
-    
+
     if downswing_frames:
         # Assuming 30 fps video
         downswing_duration = len(downswing_frames) / 30.0
-    
+
     # Calculate tempo ratio if both durations are available
     tempo_ratio = None
     if backswing_duration and downswing_duration and downswing_duration > 0:
@@ -241,32 +332,34 @@ def prepare_data_for_llm(pose_data, swing_phases, trajectory_data):
         "hip_rotation": 45,  # degrees
         "shoulder_rotation": 90,  # degrees
         "posture_score": 0.8,  # 0-1 scale
-        
+
         # Upper body mechanics
         "arm_extension": 0.8,  # 0-1 scale
         "wrist_hinge": 80,  # degrees
         "chest_rotation_efficiency": 0.75,  # 0-1 scale
         "head_movement_lateral": 2.5,  # inches
         "head_movement_vertical": 1.8,  # inches
-        
+
         # Lower body mechanics
         "knee_flexion_address": 25,  # degrees
         "knee_flexion_impact": 30,  # degrees
         "hip_thrust": 0.6,  # 0-1 scale
         "ground_force_efficiency": 0.7,  # 0-1 scale
-        
+
         # Club path and face metrics
-        "swing_path": 2.5,  # degrees (positive = out-to-in, negative = in-to-out)
+        "swing_path":
+        2.5,  # degrees (positive = out-to-in, negative = in-to-out)
         "clubface_angle": 2.1,  # degrees (positive = open, negative = closed)
-        "attack_angle": -4.2,  # degrees (negative = descending, positive = ascending)
+        "attack_angle":
+        -4.2,  # degrees (negative = descending, positive = ascending)
         "club_path_consistency": 0.78,  # 0-1 scale
-        
+
         # Tempo and timing metrics
         "transition_smoothness": 0.75,  # 0-1 scale
         "backswing_duration": backswing_duration or 0.9,  # seconds
         "downswing_duration": downswing_duration or 0.3,  # seconds
         "kinematic_sequence": 0.82,  # 0-1 scale
-        
+
         # Efficiency and power metrics
         "energy_transfer": 0.78,  # 0-1 scale
         "potential_distance": 240,  # yards
@@ -299,62 +392,89 @@ I've analyzed a golf swing and extracted the following data:
 
     # Add trajectory information
     prompt += "\n## Trajectory Data\n"
-    if "trajectory" in analysis_data and "club_speed_mph" in analysis_data["trajectory"]:
+    if "trajectory" in analysis_data and "club_speed_mph" in analysis_data[
+            "trajectory"]:
         prompt += f"- Club Speed: {analysis_data['trajectory']['club_speed_mph']:.1f} mph\n"
-    
+
     # Add detailed biomechanical metrics
     prompt += "\n## Swing Mechanics\n"
-    
+
     # Core body mechanics
     prompt += "\n### Body Mechanics\n"
-    prompt += "- Tempo Ratio (Backswing:Downswing): {:.1f}\n".format(analysis_data["metrics"].get("tempo_ratio", 0))
-    prompt += "- Hip Rotation (degrees): {}\n".format(analysis_data["metrics"].get("hip_rotation", 0))
-    prompt += "- Shoulder Rotation (degrees): {}\n".format(analysis_data["metrics"].get("shoulder_rotation", 0))
-    prompt += "- Posture Score: {}%\n".format(int(analysis_data["metrics"].get("posture_score", 0) * 100))
-    
+    prompt += "- Tempo Ratio (Backswing:Downswing): {:.1f}\n".format(
+        analysis_data["metrics"].get("tempo_ratio", 0))
+    prompt += "- Hip Rotation (degrees): {}\n".format(
+        analysis_data["metrics"].get("hip_rotation", 0))
+    prompt += "- Shoulder Rotation (degrees): {}\n".format(
+        analysis_data["metrics"].get("shoulder_rotation", 0))
+    prompt += "- Posture Score: {}%\n".format(
+        int(analysis_data["metrics"].get("posture_score", 0) * 100))
+
     # Upper body mechanics
     prompt += "\n### Upper Body Mechanics\n"
-    prompt += "- Arm Extension (impact): {}%\n".format(int(analysis_data["metrics"].get("arm_extension", 0.8) * 100))
-    prompt += "- Wrist Hinge (degrees): {}\n".format(analysis_data["metrics"].get("wrist_hinge", 0))
-    prompt += "- Shoulder Plane Consistency: {}%\n".format(int(analysis_data["metrics"].get("swing_plane_consistency", 0) * 100))
-    prompt += "- Chest Rotation Efficiency: {}%\n".format(int(analysis_data["metrics"].get("chest_rotation_efficiency", 0.75) * 100))
-    prompt += "- Head Movement (lateral): {}in\n".format(analysis_data["metrics"].get("head_movement_lateral", 2.5))
-    prompt += "- Head Movement (vertical): {}in\n".format(analysis_data["metrics"].get("head_movement_vertical", 1.8))
-    
+    prompt += "- Arm Extension (impact): {}%\n".format(
+        int(analysis_data["metrics"].get("arm_extension", 0.8) * 100))
+    prompt += "- Wrist Hinge (degrees): {}\n".format(
+        analysis_data["metrics"].get("wrist_hinge", 0))
+    prompt += "- Shoulder Plane Consistency: {}%\n".format(
+        int(analysis_data["metrics"].get("swing_plane_consistency", 0) * 100))
+    prompt += "- Chest Rotation Efficiency: {}%\n".format(
+        int(analysis_data["metrics"].get("chest_rotation_efficiency", 0.75) *
+            100))
+    prompt += "- Head Movement (lateral): {}in\n".format(
+        analysis_data["metrics"].get("head_movement_lateral", 2.5))
+    prompt += "- Head Movement (vertical): {}in\n".format(
+        analysis_data["metrics"].get("head_movement_vertical", 1.8))
+
     # Lower body mechanics
     prompt += "\n### Lower Body Mechanics\n"
-    prompt += "- Weight Shift (lead foot at impact): {}%\n".format(int(analysis_data["metrics"].get("weight_shift", 0) * 100))
-    prompt += "- Knee Flexion (address): {}°\n".format(analysis_data["metrics"].get("knee_flexion_address", 25))
-    prompt += "- Knee Flexion (impact): {}°\n".format(analysis_data["metrics"].get("knee_flexion_impact", 30))
-    prompt += "- Hip Thrust (impact): {}%\n".format(int(analysis_data["metrics"].get("hip_thrust", 0.6) * 100))
-    prompt += "- Ground Force Efficiency: {}%\n".format(int(analysis_data["metrics"].get("ground_force_efficiency", 0.7) * 100))
-    
+    prompt += "- Weight Shift (lead foot at impact): {}%\n".format(
+        int(analysis_data["metrics"].get("weight_shift", 0) * 100))
+    prompt += "- Knee Flexion (address): {}°\n".format(
+        analysis_data["metrics"].get("knee_flexion_address", 25))
+    prompt += "- Knee Flexion (impact): {}°\n".format(
+        analysis_data["metrics"].get("knee_flexion_impact", 30))
+    prompt += "- Hip Thrust (impact): {}%\n".format(
+        int(analysis_data["metrics"].get("hip_thrust", 0.6) * 100))
+    prompt += "- Ground Force Efficiency: {}%\n".format(
+        int(analysis_data["metrics"].get("ground_force_efficiency", 0.7) *
+            100))
+
     # Swing path and clubface metrics
     prompt += "\n### Club Path & Face Metrics\n"
     prompt += "- Swing Path (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("swing_path", 2.5),
-        "Out-to-In" if analysis_data["metrics"].get("swing_path", 0) > 0 else "In-to-Out")
+        analysis_data["metrics"].get("swing_path", 2.5), "Out-to-In"
+        if analysis_data["metrics"].get("swing_path", 0) > 0 else "In-to-Out")
     prompt += "- Clubface Angle (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("clubface_angle", 2.1),
-        "Open" if analysis_data["metrics"].get("clubface_angle", 0) > 0 else "Closed")
+        analysis_data["metrics"].get("clubface_angle", 2.1), "Open"
+        if analysis_data["metrics"].get("clubface_angle", 0) > 0 else "Closed")
     prompt += "- Attack Angle (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("attack_angle", -4.2),
-        "Descending" if analysis_data["metrics"].get("attack_angle", 0) < 0 else "Ascending")
-    prompt += "- Club Path Consistency: {}%\n".format(int(analysis_data["metrics"].get("club_path_consistency", 0.78) * 100))
-    
+        analysis_data["metrics"].get("attack_angle", -4.2), "Descending" if
+        analysis_data["metrics"].get("attack_angle", 0) < 0 else "Ascending")
+    prompt += "- Club Path Consistency: {}%\n".format(
+        int(analysis_data["metrics"].get("club_path_consistency", 0.78) * 100))
+
     # Tempo and timing metrics
     prompt += "\n### Tempo & Timing\n"
-    prompt += "- Transition Smoothness: {}%\n".format(int(analysis_data["metrics"].get("transition_smoothness", 0.75) * 100))
-    prompt += "- Backswing Duration: {} seconds\n".format(analysis_data["metrics"].get("backswing_duration", 0.9))
-    prompt += "- Downswing Duration: {} seconds\n".format(analysis_data["metrics"].get("downswing_duration", 0.3))
-    prompt += "- Sequential Kinematic Sequence: {}%\n".format(int(analysis_data["metrics"].get("kinematic_sequence", 0.82) * 100))
-    
+    prompt += "- Transition Smoothness: {}%\n".format(
+        int(analysis_data["metrics"].get("transition_smoothness", 0.75) * 100))
+    prompt += "- Backswing Duration: {} seconds\n".format(
+        analysis_data["metrics"].get("backswing_duration", 0.9))
+    prompt += "- Downswing Duration: {} seconds\n".format(
+        analysis_data["metrics"].get("downswing_duration", 0.3))
+    prompt += "- Sequential Kinematic Sequence: {}%\n".format(
+        int(analysis_data["metrics"].get("kinematic_sequence", 0.82) * 100))
+
     # Efficiency and power metrics
     prompt += "\n### Efficiency & Power Metrics\n"
-    prompt += "- Energy Transfer Efficiency: {}%\n".format(int(analysis_data["metrics"].get("energy_transfer", 0.78) * 100))
-    prompt += "- Potential Distance: {} yards\n".format(analysis_data["metrics"].get("potential_distance", 240))
-    prompt += "- Power Accumulation: {}%\n".format(int(analysis_data["metrics"].get("power_accumulation", 0.75) * 100))
-    prompt += "- Speed Generation Method: {}\n".format(analysis_data["metrics"].get("speed_generation", "Arms-dominant"))
+    prompt += "- Energy Transfer Efficiency: {}%\n".format(
+        int(analysis_data["metrics"].get("energy_transfer", 0.78) * 100))
+    prompt += "- Potential Distance: {} yards\n".format(
+        analysis_data["metrics"].get("potential_distance", 240))
+    prompt += "- Power Accumulation: {}%\n".format(
+        int(analysis_data["metrics"].get("power_accumulation", 0.75) * 100))
+    prompt += "- Speed Generation Method: {}\n".format(
+        analysis_data["metrics"].get("speed_generation", "Arms-dominant"))
 
     prompt += """
 

app/models/pose_estimator.py

@@ -15,7 +15,7 @@ class PoseEstimator:
         """Initialize the pose estimator"""
         self.mp_pose = mp.solutions.pose
         self.pose = self.mp_pose.Pose(static_image_mode=False,
-                                      model_complexity=2,
+                                      model_complexity=1,
                                       enable_segmentation=False,
                                       min_detection_confidence=0.5,
                                       min_tracking_confidence=0.5)

app/streamlit_app.py

@@ -21,7 +21,7 @@ from app.utils.video_downloader import download_youtube_video
 from app.utils.video_processor import process_video
 from app.models.pose_estimator import analyze_pose
 from app.models.swing_analyzer import segment_swing, analyze_trajectory
-from app.models.llm_analyzer import generate_swing_analysis, create_llm_prompt, prepare_data_for_llm
+from app.models.llm_analyzer import generate_swing_analysis, create_llm_prompt, prepare_data_for_llm, check_llm_services
 from app.utils.visualizer import create_annotated_video
 
 # Set page config
@@ -59,8 +59,7 @@ def display_video(video_path, width=300):
     # Create a container with custom width
     video_container = st.container()
     # Apply CSS to control the width and ensure it's centered
-    video_container.markdown(
-        f"""
+    video_container.markdown(f"""
         <style>
         .element-container:has(video) {{
             max-width: {width}px;
@@ -71,10 +70,9 @@ def display_video(video_path, width=300):
             height: auto !important;
         }}
         </style>
-        """, 
-        unsafe_allow_html=True
-    )
-    
+        """,
+                             unsafe_allow_html=True)
+
     # Display video using st.video with bytes
     with video_container:
         st.video(video_bytes)
@@ -109,37 +107,56 @@ def main():
     # Sidebar for configuration
     st.sidebar.title("Configuration")
 
+    # Check available LLM services
+    llm_services = check_llm_services()
+    any_service_available = llm_services['ollama'][
+        'available'] or llm_services['openai']['available']
+
     # Option to enable/disable GPT analysis with better explanation
-    st.sidebar.markdown("### GPT Analysis Settings")
-    enable_gpt = st.sidebar.checkbox(
-        "Enable GPT Analysis", 
-        value=False,  # Disabled by default
-        help="When enabled, uses OpenAI's API for personalized analysis. Requires API key."
-    )
-    
-    if enable_gpt:
-        # Check for OpenAI API key in Streamlit secrets
-        api_key_available = False
-        try:
-            if st.secrets["openai"]["api_key"]:
-                api_key_available = True
-                st.sidebar.success("✅ OpenAI API key configured in Streamlit secrets")
-        except (KeyError, FileNotFoundError):
-            # Fallback to environment variable
-            api_key = os.getenv("OPENAI_API_KEY")
-            if api_key:
-                api_key_available = True
-                st.sidebar.success("✅ OpenAI API key configured in environment variables")
-        
-        if not api_key_available:
-            st.sidebar.warning(
-                "⚠️ OpenAI API key not found. Add it to your .streamlit/secrets.toml file."
-            )
+    st.sidebar.markdown("### LLM Analysis Settings")
+
+    # Show service status
+    if llm_services['ollama']['available']:
+        st.sidebar.success(
+            f"✅ Ollama configured: {llm_services['ollama']['config']['model']}"
+        )
+
+    if llm_services['openai']['available']:
+        st.sidebar.success("✅ OpenAI configured")
+
+    if not any_service_available:
+        st.sidebar.info("ℹ️ No LLM services configured")
+
+    # Automatically enable if services are available, otherwise allow manual control
+    if any_service_available:
+        enable_gpt = st.sidebar.checkbox(
+            "Enable LLM Analysis",
+            value=True,  # Automatically enabled when services are available
+            help=
+            "Uses configured LLM services (Ollama/OpenAI) for personalized analysis."
+        )
     else:
-        st.sidebar.info(
-            "Using sample analysis mode (no API key required)"
+        enable_gpt = st.sidebar.checkbox(
+            "Enable LLM Analysis",
+            value=False,  # Disabled by default when no services
+            help="Configure Ollama or OpenAI in secrets to enable LLM analysis."
         )
 
+    if enable_gpt and not any_service_available:
+        st.sidebar.warning(
+            "⚠️ No LLM services configured. Configure Ollama or OpenAI in your .streamlit/secrets.toml file."
+        )
+    elif enable_gpt:
+        if llm_services['ollama']['available'] and llm_services['openai'][
+                'available']:
+            st.sidebar.info("🔄 Will try Ollama first, then OpenAI as fallback")
+        elif llm_services['ollama']['available']:
+            st.sidebar.info("🦙 Using Ollama for analysis")
+        elif llm_services['openai']['available']:
+            st.sidebar.info("🤖 Using OpenAI for analysis")
+    else:
+        st.sidebar.info("Using sample analysis mode (no LLM required)")
+
     # Frame skip rate for YOLO
     sample_rate = st.sidebar.slider(
         "Frame Skip Rate (YOLO)",
@@ -238,16 +255,20 @@ def main():
                 'analysis_data': analysis_data,
                 'prompt': prompt
             }
-            
+
             # Present the two options after analysis
             st.subheader("What would you like to do next?")
             options_col1, options_col2 = st.columns(2)
-            
+
             with options_col1:
-                st.info("**Option 1: Generate Annotated Video**\n\nCreate a video with visual feedback showing your swing phases, body positioning, and key metrics.")
-            
+                st.info(
+                    "**Option 1: Generate Annotated Video**\n\nCreate a video with visual feedback showing your swing phases, body positioning, and key metrics."
+                )
+
             with options_col2:
-                st.info("**Option 2: Generate Improvement Recommendations**\n\nGet AI-powered analysis of your swing with specific tips for improvement.")
+                st.info(
+                    "**Option 2: Generate Improvement Recommendations**\n\nGet AI-powered analysis of your swing with specific tips for improvement."
+                )
 
         except Exception as e:
             st.error(f"Error during analysis: {str(e)}")
@@ -264,7 +285,7 @@ def main():
                 with phase_cols[i]:
                     st.metric(label=phase.capitalize(),
                               value=f"{len(frames_in_phase)} frames")
-        
+
         # Display club speed if available
         if 'trajectory_data' in st.session_state.analysis_data and 'swing_phases' in st.session_state.analysis_data:
             trajectory_data = st.session_state.analysis_data['trajectory_data']
@@ -272,27 +293,34 @@ def main():
             impact_frames = swing_phases.get("impact", [])
             if impact_frames:
                 impact_frame = impact_frames[len(impact_frames) // 2]
-                if impact_frame in trajectory_data and trajectory_data[impact_frame].get("club_speed"):
+                if impact_frame in trajectory_data and trajectory_data[
+                        impact_frame].get("club_speed"):
                     st.subheader("Club Speed")
                     st.metric(
                         label="Estimated Club Speed",
-                        value=f"{trajectory_data[impact_frame]['club_speed']:.1f} mph"
+                        value=
+                        f"{trajectory_data[impact_frame]['club_speed']:.1f} mph"
                     )
-        
+
         # Display the GPT prompt in an expander
         if 'prompt' in st.session_state.analysis_data:
-            with st.expander("View GPT Prompt", expanded=False):
-                st.code(st.session_state.analysis_data['prompt'], language="text")
-        
+            with st.expander("View LLM Prompt", expanded=False):
+                st.code(st.session_state.analysis_data['prompt'],
+                        language="text")
+
         # Create columns for the two action buttons
         button_col1, button_col2 = st.columns(2)
-        
+
         with button_col1:
-            annotated_video_clicked = st.button("Generate Annotated Video", key="create_annotated", use_container_width=True)
-        
+            annotated_video_clicked = st.button("Generate Annotated Video",
+                                                key="create_annotated",
+                                                use_container_width=True)
+
         with button_col2:
-            improvements_clicked = st.button("Generate Improvements", key="gpt_recommendations", use_container_width=True)
-        
+            improvements_clicked = st.button("Generate Improvements",
+                                             key="gpt_recommendations",
+                                             use_container_width=True)
+
         # Handle annotated video creation
         if annotated_video_clicked:
             try:
@@ -320,68 +348,79 @@ def main():
 
                     # Store the annotated video path in session state
                     st.session_state.annotated_video_path = output_path
-                
+
                 # Display success message and video after spinner completes
                 st.success("Annotated video created successfully!")
                 display_video(output_path, width=400)
-                
+
                 # Show download button
                 with open(output_path, "rb") as file:
                     video_bytes = file.read()
-                    st.download_button(
-                        label="Download Annotated Video",
-                        data=video_bytes,
-                        file_name=os.path.basename(output_path),
-                        mime="video/mp4"
-                    )
+                    st.download_button(label="Download Annotated Video",
+                                       data=video_bytes,
+                                       file_name=os.path.basename(output_path),
+                                       mime="video/mp4")
 
             except Exception as e:
                 st.error(f"Error creating annotated video: {str(e)}")
                 st.error(
                     "Please check if the downloads directory exists and is writable"
                 )
-        
+
         # Handle improvement recommendations generation
         if improvements_clicked:
-            with st.spinner("Analyzing your swing and generating recommendations..."):
+            with st.spinner(
+                    "Analyzing your swing and generating recommendations..."):
                 # Get data from session state
                 data = st.session_state.analysis_data
                 pose_data = data['pose_data']
                 swing_phases = data['swing_phases']
                 trajectory_data = data['trajectory_data']
-                
+
                 # Generate detailed analysis with recommendations
-                analysis = generate_swing_analysis(pose_data, swing_phases, trajectory_data)
-                
+                analysis = generate_swing_analysis(pose_data, swing_phases,
+                                                   trajectory_data)
+
                 # Display the analysis
                 st.subheader("Swing Analysis and Recommendations")
-                
-                # Check if we're using the sample analysis (no API key)
-                api_key_available = False
-                try:
-                    if st.secrets["openai"]["api_key"]:
-                        api_key_available = True
-                except (KeyError, FileNotFoundError):
-                    api_key = os.getenv("OPENAI_API_KEY")
-                    if api_key:
-                        api_key_available = True
-                
-                if not api_key_available and not enable_gpt:
-                    st.info("ℹ️ **Using sample analysis mode**. The recommendations below are general examples and not personalized to your specific swing.")
-                
+
+                # Check available services to show appropriate message
+                llm_services = check_llm_services()
+                any_service_available = llm_services['ollama'][
+                    'available'] or llm_services['openai']['available']
+
+                if not any_service_available or not enable_gpt:
+                    st.info(
+                        "ℹ️ **Using sample analysis mode**. The recommendations below are general examples and not personalized to your specific swing."
+                    )
+                else:
+                    if llm_services['ollama']['available'] and llm_services[
+                            'openai']['available']:
+                        st.info(
+                            "🔄 **Analysis generated using available LLM services** (tried Ollama first, OpenAI as fallback)"
+                        )
+                    elif llm_services['ollama']['available']:
+                        st.info("🦙 **Analysis generated using Ollama**")
+                    elif llm_services['openai']['available']:
+                        st.info("🤖 **Analysis generated using OpenAI**")
+
                 st.markdown(analysis)
-                
+
                 # Add some example drills based on the analysis
                 if "Error:" not in analysis:  # Only show drills if analysis was successful
                     st.subheader("Recommended Drills")
                     drill1, drill2 = st.columns(2)
-                    
+
                     with drill1:
                         st.markdown("**Posture Drill**")
                         st.markdown("- Stand with your back against a wall")
-                        st.markdown("- Take your golf stance while maintaining contact")
-                        st.markdown("- Practice maintaining this posture during your swing")
-                    
+                        st.markdown(
+                            "- Take your golf stance while maintaining contact"
+                        )
+                        st.markdown(
+                            "- Practice maintaining this posture during your swing"
+                        )
+
                     with drill2:
                         st.markdown("**Tempo Drill**")
                         st.markdown("- Count '1-2-3' for your backswing")