Update Par-ity Project with enhanced features

.gitattributes

@@ -0,0 +1 @@
+*.pt filter=lfs diff=lfs merge=lfs -text

README.md

@@ -8,113 +8,201 @@ app_file: app/streamlit_app.py
 pinned: false
 ---
 
+# Par-ity Project: Golf Swing Analysis with AI Assistant ⛳🏌️‍♀️
 
-# Golf Swing Analysis
-
-A tool for analyzing golf swings using computer vision and AI.
+A comprehensive golf swing analysis platform that combines computer vision-based swing analysis with an AI-powered technique assistant. This integrated system provides both automated video analysis and expert knowledge retrieval for improving your golf swing.
 
 ## Features
 
+### 🎥 Video Analysis
 - Upload or provide YouTube links to golf swing videos
 - Automated swing analysis using computer vision
 - Pose estimation and tracking
-- Swing phase segmentation
+- Swing phase segmentation (setup, backswing, downswing, follow-through)
 - Club and ball trajectory analysis
-- LLM-powered swing analysis and coaching tips (OpenAI GPT-4/3.5 or local Ollama models)
-- Annotated video generation
-- Key position comparison with professional golfer (3 critical swing positions)
-- Detailed improvement recommendations with visual analysis
-
-## Setup
-
-1. Clone the repository
-2. Install the required packages:
-   ```
-   pip install -r requirements.txt
-   ```
-3. Set up the necessary directories:
-   ```
-   ./setup_directories.sh
-   ```
-4. Add a reference professional golfer video:
-   - 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 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
-
-Run the Streamlit app:
+- Annotated video generation with visual feedback
+- Key position comparison (setup, top of backswing, impact)
+- AI-powered improvement recommendations
+
+### 🤖 Golf Swing Technique Assistant (RAG)
+- **Expert Knowledge Base**: 2,000+ professional golf instruction articles
+- **Semantic Search**: Ask questions in natural language
+- **Contextual Answers**: Get detailed responses with source citations
+- **Interactive Chat**: Build conversations about your swing technique
+- **TPI Content**: Based on Titleist Performance Institute materials
+
+## What You Can Do
+
+### Video Analysis Options
+After uploading a video, you get 4 analysis options:
+
+1. **Generate Annotated Video** - Visual feedback showing swing phases and metrics
+2. **Generate Improvement Recommendations** - AI-powered personalized tips
+3. **Key Frame Analysis** - Detailed review of critical swing positions
+4. **Golf Swing Chatbot** - Ask specific technique questions
+
+### Example Questions for the AI Assistant
+- "What wrist motion happens during the downswing?"
+- "I'm having trouble with my slice, can you help?"
+- "What should I focus on to increase my driving distance?"
+- "How do I fix my inconsistent ball striking?"
+- "What physical limitations can affect my swing?"
+
+## Setup Instructions
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Directory Setup
+
+```bash
+./setup_directories.sh
+```
+
+### 3. OpenAI API Key (Optional)
+
+For enhanced AI responses, set up an OpenAI API key:
+
+**Option 1: Environment File**
+```bash
+cp .env.example .env
+# Edit .env and add your API key
+```
+
+**Option 2: Streamlit Secrets**
+Create `.streamlit/secrets.toml`:
+```toml
+[openai]
+api_key = "your-openai-api-key-here"
 ```
+
+**Option 3: Enter in App**
+You can also enter the API key directly in the Streamlit interface.
+
+### 4. Run the Application
+
+```bash
+cd app
+streamlit run streamlit_app.py
+```
+
+Or use the convenience script:
+```bash
 ./run_streamlit.sh
 ```
 
-Or manually:
+## How It Works
+
+### Video Analysis Pipeline
+1. **Video Processing**: Extracts frames and detects objects using YOLOv8
+2. **Pose Analysis**: Uses MediaPipe for detailed body positioning
+3. **Swing Segmentation**: Identifies swing phases automatically
+4. **Trajectory Analysis**: Tracks club and ball movement
+5. **AI Recommendations**: Generates personalized improvement tips
+
+### RAG (Retrieval-Augmented Generation) System
+1. **Knowledge Processing**: Loads and processes 2,000+ golf instruction articles
+2. **Semantic Embeddings**: Creates vector representations using Sentence Transformers
+3. **Smart Search**: Uses FAISS for fast similarity search
+4. **Response Generation**: Combines retrieved knowledge with AI (GPT-3.5) or fallback mode
+
+## File Structure
+
 ```
-streamlit run app/streamlit_app.py
+Golf_Swing_Analysis/
+├── app/                                # Main application
+│   ├── streamlit_app.py               # Integrated Streamlit app
+│   ├── golf_swing_rag.py             # RAG system
+│   ├── models/                        # Analysis models
+│   ├── utils/                         # Utility functions
+│   └── components/                    # UI components
+├── golf_swing_articles_complete.csv   # Knowledge base (2,000+ articles)
+├── requirements.txt                   # Python dependencies
+├── .env.example                       # Environment variables template
+├── test_rag_integration.py           # Integration test script
+└── Generated files (after first run):
+    ├── golf_swing_embeddings.pkl     # Cached embeddings
+    ├── golf_swing_index.faiss        # Vector search index
+    └── downloads/                     # Processed videos
 ```
 
-## Usage
+## Technical Details
+
+### Technologies Used
+- **Computer Vision**: YOLOv8, MediaPipe, OpenCV
+- **AI/ML**: OpenAI GPT-3.5/4, Ollama (local LLM option)
+- **RAG Stack**: Sentence Transformers, FAISS, LangChain
+- **Web Interface**: Streamlit
+- **Data Processing**: Pandas, NumPy
+
+### Performance Features
+- **Cached Embeddings**: First-time setup creates embeddings saved for future use
+- **Efficient Search**: FAISS enables fast similarity search over thousands of chunks
+- **Automatic Cleanup**: Temporary files are managed automatically
+- **Batch Processing**: Video frames and embeddings processed efficiently
 
-1. Upload a golf swing video or provide a YouTube URL
+## Usage Guide
+
+### 1. Video Analysis Workflow
+1. Choose input method (YouTube URL or file upload)
 2. Click "Analyze Swing" to process the video
-3. View the swing phase breakdown and metrics
-4. Generate an annotated video showing the analysis
-5. Compare your swing at 3 key positions with a professional golfer:
-   - Starting position (setup)
-   - Top of backswing
-   - Impact with ball
-6. Get detailed improvement recommendations for each swing phase
-7. Download comparison images and analysis results
+3. Select from 4 analysis options
+4. Download results and annotated videos
+
+### 2. AI Assistant Workflow
+1. Click "Golf Swing Chatbot" after video analysis (or use standalone)
+2. Ask questions about golf swing technique
+3. Review detailed answers with source citations
+4. Build conversations for comprehensive understanding
+
+## Example Use Cases
+
+### Video Analysis
+- **Beginner Golfer**: Upload practice swing video → Get annotated feedback → Learn proper positions
+- **Intermediate Player**: Analyze driver swing → Get AI recommendations → Focus on specific improvements
+- **Coach**: Use key frame analysis → Show students critical positions → Provide visual evidence
+
+### AI Assistant
+- **Technique Questions**: "How should my weight shift during the swing?"
+- **Problem Solving**: "I keep hitting fat shots with my irons, what's wrong?"
+- **Learning**: "Explain the biomechanics of the golf swing"
+- **Specific Issues**: "I have limited hip mobility, how does this affect my swing?"
+
+## Troubleshooting
+
+### First Run Setup
+- Initial embedding creation takes 5-10 minutes (one-time process)
+- Ensure adequate RAM (8GB+ recommended) for large knowledge base
+- Video processing time depends on length and resolution
+
+### Common Issues
+- **Missing Dependencies**: Run `pip install --upgrade -r requirements.txt`
+- **Import Errors**: Ensure you're running from the correct directory
+- **RAG Not Available**: Check that `golf_swing_articles_complete.csv` exists
+- **Video Issues**: Ensure videos are in supported formats (MP4, MOV, AVI)
+
+### Testing Integration
+Run the test script to verify everything works:
+```bash
+python3 test_rag_integration.py
+```
 
-## Technical Details
+## Contributing
+
+This system is designed to be extensible:
+
+1. **Video Analysis**: Add new computer vision models or metrics
+2. **Knowledge Base**: Include additional golf instruction sources
+3. **AI Models**: Experiment with different embedding models or LLMs
+4. **UI/UX**: Enhance the Streamlit interface with new features
+
+## License
+
+This project is for educational and personal use. The golf instruction content is sourced from publicly available articles and should be attributed to original sources.
+
+---
 
-The application uses:
-- YOLOv8 for object detection
-- MediaPipe for pose estimation
-- OpenCV for video processing
-- OpenAI GPT-4/3.5 or Ollama for swing analysis
-- Streamlit for the web interface
-
-## Directory Structure
-
-- `app/`: Main application code
-  - `models/`: Analysis models
-  - `utils/`: Utility functions
-  - `components/`: UI components
-  - `streamlit_app.py`: Main Streamlit application
-- `downloads/`: Downloaded and processed videos
-- `requirements.txt`: Required Python packages
-- `setup_directories.sh`: Script to set up required directories
-- `run_streamlit.sh`: Script to run the Streamlit app
-
-## Notes
-
-- For best results, use videos where the golfer is clearly visible
-- Side view videos work best for analysis
-- Processing time depends on video length and resolution 
+**Built with ❤️ to empower golfers with AI-powered analysis and expert knowledge** 

app/golf_swing_rag.py

@@ -0,0 +1,271 @@
+import pandas as pd
+import numpy as np
+import faiss
+from sentence_transformers import SentenceTransformer
+import streamlit as st
+import openai
+from dotenv import load_dotenv
+import os
+import json
+import pickle
+from typing import List, Dict, Tuple
+import re
+from datetime import datetime
+
+# Load environment variables
+load_dotenv()
+
+class GolfSwingRAG:
+    def __init__(self, csv_file_path: str = None):
+        """Initialize the Golf Swing RAG system"""
+        # Set default CSV path based on current working directory
+        if csv_file_path is None:
+            if os.path.exists("golf_swing_articles_complete.csv"):
+                csv_file_path = "golf_swing_articles_complete.csv"
+            elif os.path.exists("../golf_swing_articles_complete.csv"):
+                csv_file_path = "../golf_swing_articles_complete.csv"
+            else:
+                raise FileNotFoundError("golf_swing_articles_complete.csv not found in current or parent directory")
+        
+        self.csv_file_path = csv_file_path
+        self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.index = None
+        self.chunks = []
+        self.metadata = []
+        self.openai_client = None
+        
+        # Initialize OpenAI client using Streamlit secrets
+        try:
+            openai_key = st.secrets.get("openai", {}).get("api_key", "")
+            if openai_key:
+                self.openai_client = openai.OpenAI(api_key=openai_key)
+        except (KeyError, FileNotFoundError, AttributeError):
+            # Fallback to environment variable if secrets not available
+            if os.getenv("OPENAI_API_KEY"):
+                self.openai_client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        
+    def load_and_process_data(self):
+        """Load CSV data and process it for RAG"""
+        print("Loading golf swing data...")
+        
+        # Read CSV file
+        df = pd.read_csv(self.csv_file_path)
+        print(f"Loaded {len(df)} articles")
+        
+        # Process each article
+        all_chunks = []
+        all_metadata = []
+        
+        for idx, row in df.iterrows():
+            # Parse text chunks if they exist
+            text_chunks = []
+            if pd.notna(row['text_chunks']) and row['text_chunks'].strip():
+                try:
+                    # Parse the text_chunks column (it appears to be a list in string format)
+                    chunks_str = row['text_chunks']
+                    if chunks_str.startswith('[') and chunks_str.endswith(']'):
+                        # Remove brackets and split by quotes
+                        chunks_str = chunks_str[1:-1]  # Remove outer brackets
+                        # Split by quote patterns while preserving content
+                        text_chunks = [chunk.strip().strip("'\"") for chunk in chunks_str.split("', '") if chunk.strip()]
+                        if not text_chunks and chunks_str:
+                            text_chunks = [chunks_str.strip().strip("'\"")]
+                except:
+                    # Fallback: use cleaned_text if text_chunks parsing fails
+                    text_chunks = [row['cleaned_text']] if pd.notna(row['cleaned_text']) else []
+            
+            # If no chunks, create chunks from cleaned_text or text
+            if not text_chunks:
+                text_content = row['cleaned_text'] if pd.notna(row['cleaned_text']) else row['text']
+                if pd.notna(text_content):
+                    # Split into chunks of ~500 words
+                    words = text_content.split()
+                    chunk_size = 500
+                    text_chunks = [' '.join(words[i:i+chunk_size]) for i in range(0, len(words), chunk_size)]
+            
+            # Add each chunk with metadata
+            for chunk_idx, chunk in enumerate(text_chunks):
+                if chunk and len(chunk.strip()) > 50:  # Only process substantial chunks
+                    all_chunks.append(chunk)
+                    all_metadata.append({
+                        'title': row['title'],
+                        'url': row['url'],
+                        'source': row['source'],
+                        'publish_date': row['publish_date'],
+                        'authors': row['authors'],
+                        'chunk_index': chunk_idx,
+                        'article_index': idx
+                    })
+        
+        self.chunks = all_chunks
+        self.metadata = all_metadata
+        print(f"Created {len(all_chunks)} text chunks")
+        
+    def create_embeddings(self, force_recreate: bool = False):
+        """Create embeddings for all text chunks"""
+        # Determine the correct base directory for embeddings files
+        if os.path.exists("golf_swing_articles_complete.csv"):
+            # Running from project root
+            embeddings_file = "golf_swing_embeddings.pkl"
+            index_file = "golf_swing_index.faiss"
+        else:
+            # Running from app directory
+            embeddings_file = "../golf_swing_embeddings.pkl"
+            index_file = "../golf_swing_index.faiss"
+        
+        if not force_recreate and os.path.exists(embeddings_file) and os.path.exists(index_file):
+            print("Loading existing embeddings...")
+            with open(embeddings_file, 'rb') as f:
+                data = pickle.load(f)
+                self.chunks = data['chunks']
+                self.metadata = data['metadata']
+            self.index = faiss.read_index(index_file)
+            print(f"Loaded {len(self.chunks)} chunks with embeddings")
+            return
+        
+        print("Creating embeddings...")
+        if not self.chunks:
+            self.load_and_process_data()
+        
+        # Create embeddings in batches
+        batch_size = 32
+        all_embeddings = []
+        
+        for i in range(0, len(self.chunks), batch_size):
+            batch_chunks = self.chunks[i:i+batch_size]
+            batch_embeddings = self.embedding_model.encode(batch_chunks, show_progress_bar=True)
+            all_embeddings.append(batch_embeddings)
+            print(f"Processed {min(i+batch_size, len(self.chunks))}/{len(self.chunks)} chunks")
+        
+        # Combine all embeddings
+        embeddings = np.vstack(all_embeddings)
+        
+        # Create FAISS index
+        dimension = embeddings.shape[1]
+        self.index = faiss.IndexFlatIP(dimension)  # Inner product for cosine similarity
+        
+        # Normalize embeddings for cosine similarity
+        faiss.normalize_L2(embeddings)
+        self.index.add(embeddings)
+        
+        # Save embeddings and index
+        with open(embeddings_file, 'wb') as f:
+            pickle.dump({
+                'chunks': self.chunks,
+                'metadata': self.metadata
+            }, f)
+        faiss.write_index(self.index, index_file)
+        
+        print(f"Created and saved embeddings for {len(self.chunks)} chunks")
+    
+    def search_similar_chunks(self, query: str, top_k: int = 5) -> List[Dict]:
+        """Search for similar chunks using semantic similarity"""
+        # Create query embedding
+        query_embedding = self.embedding_model.encode([query])
+        faiss.normalize_L2(query_embedding)
+        
+        # Search in FAISS index
+        scores, indices = self.index.search(query_embedding, top_k)
+        
+        results = []
+        for score, idx in zip(scores[0], indices[0]):
+            if idx < len(self.chunks):  # Valid index
+                results.append({
+                    'chunk': self.chunks[idx],
+                    'metadata': self.metadata[idx],
+                    'similarity_score': float(score)
+                })
+        
+        return results
+    
+    def generate_response(self, query: str, context_chunks: List[Dict]) -> str:
+        """Generate response using OpenAI API with context"""
+        if not self.openai_client:
+            return self._generate_fallback_response(query, context_chunks)
+        
+        # Prepare context
+        context = "\n\n".join([f"Source: {chunk['metadata']['title']}\nContent: {chunk['chunk']}" 
+                              for chunk in context_chunks])
+        
+        # Create system prompt
+        system_prompt = """You are a golf swing technique expert assistant. You help golfers improve their swing by providing detailed, accurate advice based on professional golf instruction content.
+
+Instructions:
+- Answer questions about golf swing technique, mechanics, common problems, and solutions
+- Provide specific, actionable advice when possible
+- Reference relevant technical concepts when appropriate
+- Be encouraging and supportive
+- If asked about physical limitations or injuries, recommend consulting with a TPI certified professional
+- Always base your answers on the provided context from golf instruction materials
+
+Context from golf instruction database:
+{context}"""
+
+        user_prompt = f"""Based on the golf instruction content provided, please answer this question about golf swing technique:
+
+Question: {query}
+
+Please provide a helpful, detailed response that addresses the specific question while drawing from the relevant information in the context."""
+
+        try:
+            response = self.openai_client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": system_prompt.format(context=context)},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=1000,
+                temperature=0.7
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            print(f"OpenAI API error: {e}")
+            return self._generate_fallback_response(query, context_chunks)
+    
+    def _generate_fallback_response(self, query: str, context_chunks: List[Dict]) -> str:
+        """Generate a fallback response when OpenAI API is not available"""
+        if not context_chunks:
+            return "I couldn't find specific information about that topic in the golf swing database. Could you try rephrasing your question or being more specific?"
+        
+        # Create a simple response based on the most relevant chunk
+        best_chunk = context_chunks[0]
+        chunk_content = best_chunk['chunk']
+        title = best_chunk['metadata']['title']
+        
+        response = f"Based on the article '{title}', here's what I found:\n\n"
+        response += chunk_content[:500] + "..."
+        response += f"\n\nFor more detailed information, you can refer to the full article: {title}"
+        
+        return response
+    
+    def query(self, question: str, top_k: int = 5) -> Dict:
+        """Main query method that returns both response and sources"""
+        # Search for relevant chunks
+        relevant_chunks = self.search_similar_chunks(question, top_k)
+        
+        # Generate response
+        response = self.generate_response(question, relevant_chunks)
+        
+        return {
+            'response': response,
+            'sources': relevant_chunks,
+            'query': question,
+            'timestamp': datetime.now().isoformat()
+        }
+
+def main():
+    """Initialize and test the RAG system"""
+    rag = GolfSwingRAG()
+    rag.load_and_process_data()
+    rag.create_embeddings()
+    
+    # Test query
+    test_query = "What wrist motion happens during the downswing?"
+    result = rag.query(test_query)
+    
+    print(f"Query: {result['query']}")
+    print(f"Response: {result['response']}")
+    print(f"Number of sources: {len(result['sources'])}")
+
+if __name__ == "__main__":
+    main() 

app/models/llm_analyzer.py

@@ -392,29 +392,43 @@ Use these professional standards as your 100% reference for scoring. These repre
 - Energy Transfer: 88.0%, Power Accumulation: 100%, Potential Distance: 286 yards
 - Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 85%
 
+**Rose Zhang (LPGA Tour Professional):**
+- Hip Rotation: 90°, Shoulder Rotation: 120°, Posture Score: 98.0%
+- Weight Shift: 89.9%, Arm Extension: 79.5%, Wrist Hinge: 112.8°
+- Energy Transfer: 96.6%, Power Accumulation: 100%, Potential Distance: 296 yards
+- Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 85%
+- Speed Generation: Body-dominant
+
+**Lydia Ko (LPGA Tour Professional):**
+- Hip Rotation: 90°, Shoulder Rotation: 120°, Posture Score: 99.2%
+- Weight Shift: 66.2%, Arm Extension: 62.1%, Wrist Hinge: 120°
+- Energy Transfer: 88.7%, Power Accumulation: 100%, Potential Distance: 286 yards
+- Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 70%
+- Speed Generation: Body-dominant
+
 ### **PROFESSIONAL STANDARDS CALIBRATION (100% Level):**
 **Core Biomechanical Metrics:**
-- **Hip Rotation**: 60-90° (Exceptional body turn and flexibility)
-- **Shoulder Rotation**: 120° (Full shoulder coil for maximum power)
-- **Posture Score**: 95-98% (Exceptional spine angle consistency)
-- **Weight Shift**: 70-88% (Excellent weight transfer to lead side)
+- **Hip Rotation**: 25-90° (Professional range - multiple successful approaches)
+- **Shoulder Rotation**: 60-120° (Professional upper body coil range)
+- **Posture Score**: 95-99% (Exceptional spine angle consistency across all professionals)
+- **Weight Shift**: 53-90% (Professional range varies significantly by style)
 
 **Upper Body Excellence:**
-- **Arm Extension**: 96-100% (Near-perfect extension at impact)
-- **Wrist Hinge**: 95-120° (Optimal lag and release timing)
-- **Swing Plane Consistency**: 85% (Tour-level repeatability)
-- **Chest Rotation Efficiency**: 100% (Perfect coordination)
+- **Arm Extension**: 62-100% (Wide professional range - Lydia shows low extension can work)
+- **Wrist Hinge**: 93-120° (Optimal lag and release timing)
+- **Swing Plane Consistency**: 70-85% (Professional-level repeatability)
+- **Chest Rotation Efficiency**: 66-100% (Coordination varies by swing style)
 
 **Power & Efficiency Markers:**
-- **Energy Transfer Efficiency**: 88-96% (Elite power transfer)
-- **Power Accumulation**: 100% (Maximum power generation)
-- **Sequential Kinematic Sequence**: 100% (Perfect body sequencing)
-- **Potential Distance**: 285-295 yards (Tour-level power)
+- **Energy Transfer Efficiency**: 65-97% (Wide professional range - multiple successful approaches)
+- **Power Accumulation**: 84-100% (Power generation across all styles)
+- **Sequential Kinematic Sequence**: 69-100% (Professional coordination standards)
+- **Potential Distance**: 242-296 yards (Professional power range)
 
 **Movement Quality Standards:**
-- **Head Movement**: 2-8 inches (Controlled, minimal excessive movement)
-- **Ground Force Efficiency**: 70-88% (Excellent ground interaction)
-- **Hip Thrust**: 40-100% (Strong lower body drive)
+- **Head Movement**: 1-8 inches (Controlled movement varies by professional)
+- **Ground Force Efficiency**: 53-90% (Professional ground interaction range)
+- **Hip Thrust**: 30-100% (Lower body drive varies significantly)
 
 ### **AMATEUR REFERENCE EXAMPLES FOR CALIBRATION:**
 
@@ -427,24 +441,6 @@ Use these professional standards as your 100% reference for scoring. These repre
 - Head Movement: 8.0in lateral, 6.0in vertical (Excessive movement)
 - Speed Generation: Mixed
 
-**50-60% Level Amateur (Male #1 - Body-Dominant):**
-- Hip Rotation: 90°, Shoulder Rotation: 84.8° (Great hip turn, limited shoulder)
-- Posture Score: 90.7%, Weight Shift: 90.0% (Solid fundamentals)
-- Arm Extension: 100.0%, Wrist Hinge: 66.8° (Good extension and lag)
-- Energy Transfer: 91.8%, Power Accumulation: 100.0% (Strong power generation)
-- Potential Distance: 290 yards, Sequential Kinematic: 100.0%
-- Hip Thrust: 100.0%, Ground Force: 90.0% (Excellent lower body)
-- Speed Generation: Body-dominant
-
-**50-60% Level Amateur (Male #2 - Body-Dominant):**
-- Hip Rotation: 90°, Shoulder Rotation: 120° (Excellent rotation both)
-- Posture Score: 89.3%, Weight Shift: 90.0% (Good fundamentals)
-- Arm Extension: 99.6%, Wrist Hinge: 52.6° (Great extension, limited lag)
-- Energy Transfer: 96.7%, Power Accumulation: 100.0% (Excellent coordination)
-- Potential Distance: 296 yards, Sequential Kinematic: 100.0%
-- Tempo Issues: Very fast downswing (2.86 ratio vs ideal ~0.3)
-- Speed Generation: Body-dominant
-
 **50-60% Level Amateur (Female - Arms-Dominant):**
 - Hip Rotation: 25°, Shoulder Rotation: 60° (Limited body rotation)
 - Posture Score: 80.6%, Weight Shift: 50.0% (Needs improvement)
@@ -455,14 +451,19 @@ Use these professional standards as your 100% reference for scoring. These repre
 - Ground Force: 50.0%, Hip Thrust: 30.0% (Weak lower body)
 - Speed Generation: Arms-dominant
 
-**CRITICAL INSIGHTS FROM AMATEUR ANALYSIS:**
-1. **Hip Rotation Varies Significantly**: From 23-90° in amateurs vs 60-90° in professionals
-2. **Shoulder Rotation Range**: 60-120° in amateurs, professionals consistently at 120°
-3. **Wrist Hinge Compensation**: Some amateurs (116.6°) exceed professional standards to compensate for limited body rotation
-4. **Power Generation Methods**: Body-dominant amateurs can achieve near-professional distances despite technical limitations
-5. **Head Movement Control**: Varies dramatically (3-8 inches) - major differentiator
-6. **Energy Transfer Efficiency**: Ranges from 56.8-96.7% in amateurs vs 88-96% in professionals
-7. **Weight Transfer Issues**: Some amateurs struggle with weight shift (50% vs professional 70-88%)
+**CRITICAL INSIGHTS FROM PROFESSIONAL AND AMATEUR ANALYSIS:**
+1. **Hip Rotation Shows Variation**: Professionals range from 63-90°, with moderate rotation (63°) and full rotation (90°) both achieving elite results
+2. **Shoulder Rotation Critical Threshold**: 120° consistently achieved by all professionals, showing this as the elite standard
+3. **Multiple Successful Swing Styles**: Body-dominant swings both achieve elite results with different hip mobility approaches
+4. **Posture Consistency Universal**: All professionals maintain 95-99% posture scores regardless of swing style
+5. **Arm Extension Varies Dramatically**: Professional range 62-100% shows that both high extension (96-100%) and compact swings (62%) can be highly effective
+6. **Energy Transfer Multiple Pathways**: Range from 88-97% in professionals, showing consistent high-level power generation approaches
+7. **Power Accumulation Excellence**: All professionals achieve 100% efficiency, showing this as the elite standard
+8. **Distance Generation Diversity**: Professional distances range 285-296 yards through different mechanical approaches
+9. **Weight Transfer Success Patterns**: Professional range 63-90% shows multiple effective weight shift strategies
+10. **Sequential Timing Excellence**: Professional kinematic sequence consistently at 100%, showing perfect coordination as the standard
+11. **Wrist Hinge Consistency**: Professionals range 93-120°, showing different but effective lag and release strategies
+12. **Ground Force Utilization Excellence**: Range 63-90% with elite players achieving consistent high efficiency through proper lower body mechanics
 
 ## CURRENT SWING ANALYSIS
 
@@ -523,125 +524,72 @@ Use these professional standards as your 100% reference for scoring. These repre
 
 ## ANALYSIS INSTRUCTIONS
 
-Using the professional benchmarks above as your calibration reference, provide your analysis in the following EXACT structured format:
+**GOLF SWING ANALYSIS FORMAT**
+Use the benchmarks above to guide your evaluation. Follow this exact format:
 
-**PERFORMANCE_CLASSIFICATION:** [XX%] (where XX is a percentage from 10% to 100%)
+**PERFORMANCE_CLASSIFICATION:** [XX%]
+(XX = number from 10% to 100%)
 
 **STRENGTHS:**
-• [Specific strength with direct comparison to professional benchmarks - e.g. "Your shoulder rotation shows great upper body mobility during your backswing, similar to what we see in professional swings"]
-• [Another strength with benchmark comparison - e.g. "Your arm extension at impact is really strong, demonstrating excellent fundamentals"]
-• [Third strength with specific metric comparison to benchmarks - e.g. "Your weight transfer demonstrates solid fundamentals in shifting from back foot to front foot through impact"]
+List exactly 3 strengths. Each should:
+- Be qualitative (no numbers)
+- Compare to professional benchmarks
+- Highlight what's working well and when (e.g. during backswing, at impact)
+- Use a positive, supportive tone
 
-**WEAKNESSES:**
-• [Specific area describing impact without numbers - e.g. "Your hip rotation is less than optimal, which may be limiting your power generation and overall swing efficiency"]
-• [Another area with impact description - e.g. "Your head movement during the swing is more than ideal, which could be affecting your accuracy and consistency"]
-• [Third area with impact-focused description - e.g. "Your wrist action could use some work, which may be affecting your ability to generate lag and create powerful impact"]
+Example:
+• Your shoulder rotation during the backswing shows strong upper body mobility, similar to professional swings.
 
-**PRIORITY_IMPROVEMENTS:**
-1. Topic Name - Explain what to focus on and when in swing, with encouraging tone and clear benefit explanation
-2. Topic Name - What to work on with supportive guidance and positive reinforcement about potential improvements  
-3. Topic Name - Area to focus on with gentle direction and realistic goals
-
-**MANDATORY REQUIREMENTS FOR EACH SECTION:**
-
-**For STRENGTHS** - Must include:
-- EXACTLY 3 bullet points - no more, no less
-- Use encouraging, positive language 
-- NO numbers or statistics - focus on qualitative descriptions
-- Reference professional standards without mentioning specific metrics
-- Recognition when mechanics are working well
-- Explain timing in swing when relevant (during backswing, at impact, etc.)
-- Use supportive tone appropriate for young golfers
-
-**For WEAKNESSES** - Must include:
-- EXACTLY 3 bullet points - no more, no less
-- NO numbers, degrees, or specific measurements
-- Focus on the IMPACT of the issue (what it's affecting) rather than the measurement
-- Use phrases like "less than optimal" or "more than ideal" instead of specific amounts
-- Explain HOW the weakness affects performance (power, accuracy, consistency, etc.)
-- DO NOT provide improvement suggestions - save those for the Priority Improvements section
-- Frame as areas that may be affecting performance rather than deficiencies
-
-**For PRIORITY_IMPROVEMENTS** - Must include:
-- EXACTLY 3 numbered items - no more, no less
-- NO header formatting like [Most Critical], [Important], [Focus Area] in the descriptions
-- Use encouraging language like "try increasing" or "focus on" instead of "you need to"
-- When in the swing this should happen (during downswing, backswing, at impact, etc.)
-- Reference professional standards gently without excessive numerical comparisons
-- Clear explanation of benefits and positive outcomes
-- Maintain supportive, coaching tone throughout
-
-**EXAMPLE ANALYSIS STRUCTURE:**
-
-**STRENGTHS:**
-• Your shoulder rotation shows great upper body mobility during your backswing, matching what we see in professional swings
-• Your weight transfer demonstrates excellent fundamentals in shifting from your back foot to your front foot through impact
-• Your posture maintains good stability throughout most of your swing, showing solid foundational mechanics
+**WEAKNESSES:**
+List exactly 3 areas for improvement. Each should:
+- Use numbers when necessary, and only use 1 number per weakness (for example, the difference between your metric and the professional standard)
+- Describe the impact on power, accuracy, or consistency
+- Use phrases like "less than optimal" or "more than ideal"
+- Don't suggest fixes here—save those for the next section
 
-**WEAKNESSES:**  
-• Your hip rotation is less than optimal, which may be limiting your power generation and overall swing efficiency
-• Your head movement during the swing is more than ideal, which could be affecting your accuracy and consistency throughout your shots
-• Your wrist action could use some work, which may be affecting your ability to generate lag and create powerful impact
+Example:
+• Your hip rotation is less than optimal, which may reduce your power through the downswing.
 
 **PRIORITY_IMPROVEMENTS:**
-1. Hip Mobility Development - Try increasing your hip rotation during the downswing. This will help you engage your lower body more effectively and unlock substantial power gains in your swing.
-2. Head Stability Enhancement - Focus on keeping your head more stable throughout your swing. This improvement will help enhance your accuracy and consistency on every shot.
-3. Wrist Hinge Optimization - Work on creating more wrist angle during your backswing to improve lag and power transfer. This will help add distance and control to your shots.
-
-PERFORMANCE CLASSIFICATION SCALE:
-- **90-100%**: Professional/Tour level - Consistently meets or exceeds professional benchmarks across all metrics
-- **80-89%**: Advanced amateur - Meets most professional standards with minor gaps in 1-2 areas
-- **70-79%**: Skilled amateur - Solid fundamentals with some gaps from professional standards
-- **60-69%**: Intermediate - Good basic mechanics but several areas need improvement to reach professional level
-- **50-59%**: Developing intermediate - Basic swing structure present but multiple areas below professional standards
-- **40-49%**: Advanced beginner - Some fundamentals in place but significant gaps in most areas
-- **30-39%**: Beginner - Basic swing motion present but major improvements needed across most metrics
-- **20-29%**: Novice - Limited swing fundamentals, extensive work needed on basic mechanics
-- **10-19%**: Complete beginner - Minimal swing structure, needs comprehensive fundamental development
-
-IMPORTANT ANALYSIS PRIORITIES (Based on Real Professional Data):
-1. **PRIMARY FOCUS - Critical Biomechanical Differentiators**: 
-   - Hip Rotation (Professional: 60-90°, Amateur Range: 23-90°) - MOST IMPORTANT
-   - Shoulder Rotation (Professional: 120°, Amateur Range: 60-120°) - MOST IMPORTANT  
-   - Sequential Kinematic Sequence (Professional: 100%, Amateur Range: 66.8-100%)
-   - Energy Transfer Efficiency (Professional: 88-96%, Amateur Range: 56.8-96.7%)
-
-2. **SECONDARY FOCUS - Power Generation Mechanics**: 
-   - Power Accumulation (Professional: 100%, Amateur Range: 82.1-100%)
-   - Chest Rotation Efficiency (Professional: 100%, Amateur Range: 53.7-100%)
-   - Wrist Hinge (Professional: 95-120°, Amateur Range: 49.4-116.6°)
-   - Swing Plane Consistency (Professional: 85%, Amateur: 70-85%)
-
-3. **TERTIARY FOCUS - Refinement Metrics**: 
-   - Posture Score (Professional: 95-98%, Amateur Range: 80.6-90.7%)
-   - Arm Extension (Professional: 96-100%, Amateur Range: 94.8-100%)
-   - Weight Shift (Professional: 70-88%, Amateur Range: 50-90%)
-   - Ground Force Efficiency (Professional: 70-88%, Amateur Range: 50-90%)
-
-4. **DE-EMPHASIZE - Timing Variables**: Frame counts, tempo ratios, and duration metrics vary significantly based on video capture rates and personal style preferences
-
-**SCORING CALIBRATION GUIDELINES:**
-- **Hip/Shoulder Rotation Analysis**: Compare to professional minimums (60° hip, 120° shoulder)
-- **Energy Transfer <70%**: Score below 60%, reference professional range (88-96%)
-- **Sequential Kinematic <80%**: Score below 70%, reference professional standards (100%)
-- **Power Accumulation <90%**: Score below 80%, compare to professional benchmarks (100%)
-- **Head Movement >10 inches**: Major limitation, compare to professional standards (2-8in)
-- **Weight Shift <60%**: Significant weakness, reference professional range (70-88%)
-
-IMPORTANT FORMATTING RULES:
-- Use the exact headers shown above (PERFORMANCE_CLASSIFICATION, STRENGTHS, WEAKNESSES, PRIORITY_IMPROVEMENTS)
-- For performance classification, use format: [XX%] where XX is the percentage (10-100)
-- For strengths and weaknesses, use bullet points (•) 
-- For priority improvements, use numbered format (1., 2., 3.) with priority level in brackets
-- Each priority improvement must have: [Priority Level] Topic Name - Full description with professional benchmark comparisons
-- **MANDATORY**: Include specific metric values and professional benchmark comparisons in every strength, weakness, and improvement
-- **MANDATORY**: Reference professional standards in analysis content
-- Provide clear directional guidance (more/less rotation, when in swing) rather than overly technical numerical comparisons
-- Focus analysis on biomechanical consistency rather than timing variations
-- **CRITICAL**: Every analysis point must tie back to the professional benchmarks provided
-- Avoid absolute language like "perfect" or "flawless" - use terms like "very good" or "meets standards"
-
-Remember: Use the professional benchmarks (Atthaya Thitikul: 63.4° hip, 120° shoulder, 96.1% energy transfer, etc.) as the foundation for ALL analysis content, not just the percentage classification. Every strength, weakness, and improvement recommendation must include specific comparisons to professional standards with clear, actionable guidance on what needs to improve and when in the swing.
+List exactly 3 improvement areas. Each should:
+- Include the topic name
+- Explain what to improve and when in the swing
+- Reference benchmarks when relevant, without being too technical
+- Use coaching-style language (e.g. "try increasing...")
+- Emphasize benefits
+
+Example:
+Hip Mobility: Try increasing your hip rotation during the downswing to unlock more lower body power.
+
+**SCORING GUIDELINES (Use to help decide % score)**
+
+| Metric | Professional Standard | Note |
+|--------|----------------------|------|
+| Hip Rotation | 25°–90° | <25° is weak |
+| Shoulder Rotation | 60°–120° | <60° is weak |
+| Energy Transfer | 65–97% | <65% = score <60% |
+| Sequential Kinematics | 69–100% | <69% = score <70% |
+| Weight Shift | 53–90% | <53% = weakness |
+| Head Movement | 1–8 in | >8 in = major issue |
+| Arm Extension | 62–100% | <62% = weakness |
+| Power Accumulation | 84–100% | <84% = weakness |
+
+**Classification Bands:**
+- **90–100%**: Tour-level
+- **80–89%**: Advanced amateur
+- **70–79%**: Skilled
+- **60–69%**: Intermediate
+- **50–59%**: Developing
+- **40–49%**: Beginner
+- **10–39%**: Novice
+
+**STYLE & FORMATTING RULES:**
+- Use these headers: PERFORMANCE_CLASSIFICATION, STRENGTHS, WEAKNESSES, PRIORITY_IMPROVEMENTS
+- Avoid statistics in strengths/weaknesses (okay in improvements if helpful)
+- Tie all points to professional standards
+- Use a positive, coaching tone throughout
+- Avoid saying "perfect" — say "strong" or "meets standards"
+- Focus on biomechanics, not timing (e.g. tempo, frame count)
 """
 
     return prompt
@@ -707,22 +655,63 @@ def parse_and_format_analysis(raw_analysis):
     priority_match = re.search(r'\*\*PRIORITY_IMPROVEMENTS:\*\*\s*(.*?)$', raw_analysis, re.IGNORECASE | re.DOTALL)
     if priority_match:
         priority_text = priority_match.group(1)
-        # Extract numbered items with priority levels and descriptions
-        priority_items = re.findall(r'(\d+)\.\s*\[(.*?)\]\s*(.*?)(?=\d+\.\s*\[|\Z)', priority_text, re.DOTALL)
-        for num, priority_level, description in priority_items[:3]:  # Limit to 3
-            # Clean up the description
-            description = description.strip()
-            # Remove any trailing incomplete sentences
-            if description.endswith('...') or len(description.split('.')[-1].strip()) < 5:
-                sentences = description.split('.')
-                if len(sentences) > 1:
-                    description = '.'.join(sentences[:-1]) + '.'
-            
-            formatted_analysis['priority_improvements'].append({
-                'rank': int(num),
-                'priority_level': priority_level.strip(),
-                'description': f"[{priority_level.strip()}] {description}"
-            })
+        # First try to parse numbered format: "1. Topic: Description"
+        numbered_items = re.findall(r'(\d+)\.\s*([^1-9\n]*?)(?=\d+\.|$)', priority_text, re.DOTALL)
+        
+        if numbered_items:
+            for num, description in numbered_items[:3]:  # Limit to 3
+                description = description.strip()
+                if description and len(description) > 10:  # Only add if meaningful content
+                    formatted_analysis['priority_improvements'].append({
+                        'rank': int(num),
+                        'description': description
+                    })
+        else:
+            # Try to parse simple format without numbers: "Topic: Description"
+            # Split by lines and look for patterns like "Topic: Description"
+            lines = [line.strip() for line in priority_text.split('\n') if line.strip()]
+            for i, line in enumerate(lines[:3]):  # Limit to 3
+                if ':' in line and len(line) > 15:  # Has colon and meaningful length
+                    formatted_analysis['priority_improvements'].append({
+                        'rank': i + 1,
+                        'description': line
+                    })
+    
+    # Ensure exactly 3 priority improvements with distinct topics
+    if len(formatted_analysis['priority_improvements']) < 3:
+        # Define 3 distinct improvement areas
+        common_improvements = [
+            "Hip Mobility: Try increasing your hip rotation during the downswing to unlock more lower body power and improve overall swing efficiency.",
+            "Arm Extension: Focus on achieving better arm extension at impact to improve power transfer and ball striking consistency.",
+            "Weight Transfer: Work on shifting your weight more effectively from back foot to front foot during the swing to enhance balance and power generation."
+        ]
+        
+        # Get existing topics to avoid duplicates
+        existing_topics = set()
+        for improvement in formatted_analysis['priority_improvements']:
+            topic = improvement['description'].split(':')[0].strip().lower()
+            existing_topics.add(topic)
+        
+        # Add missing improvements, avoiding duplicates
+        current_count = len(formatted_analysis['priority_improvements'])
+        for improvement in common_improvements:
+            if current_count >= 3:
+                break
+            topic = improvement.split(':')[0].strip().lower()
+            if topic not in existing_topics:
+                formatted_analysis['priority_improvements'].append({
+                    'rank': current_count + 1,
+                    'description': improvement
+                })
+                existing_topics.add(topic)
+                current_count += 1
+    
+    # Ensure we have exactly 3 (trim if too many)
+    formatted_analysis['priority_improvements'] = formatted_analysis['priority_improvements'][:3]
+    
+    # Re-rank to ensure proper numbering
+    for i, improvement in enumerate(formatted_analysis['priority_improvements']):
+        improvement['rank'] = i + 1
     
     # Fallback parsing if structured format wasn't used
     if not formatted_analysis['strengths']:
@@ -794,27 +783,27 @@ def parse_and_format_analysis(raw_analysis):
         percentage = formatted_analysis['classification']
         if percentage >= 80:
             formatted_analysis['priority_improvements'] = [
-                {'rank': 1, 'description': '[Most Critical] Technical Refinement - Fine-tune specific mechanics to achieve consistency at the highest level.'},
-                {'rank': 2, 'description': '[Important] Performance Optimization - Focus on maximizing efficiency and power transfer.'},
-                {'rank': 3, 'description': '[Focus Area] Competitive Preparation - Enhance mental game and course management skills.'}
+                {'rank': 1, 'description': 'Technical Refinement: Fine-tune specific mechanics to achieve consistency at the highest level.'},
+                {'rank': 2, 'description': 'Performance Optimization: Focus on maximizing efficiency and power transfer.'},
+                {'rank': 3, 'description': 'Competitive Preparation: Enhance mental game and course management skills.'}
             ]
         elif percentage >= 60:
             formatted_analysis['priority_improvements'] = [
-                {'rank': 1, 'description': '[Most Critical] Kinematic Sequence Enhancement - Improve body rotation coordination to generate more power and consistency.'},
-                {'rank': 2, 'description': '[Important] Clubface Control - Enhance swing path consistency for better ball striking accuracy.'},
-                {'rank': 3, 'description': '[Focus Area] Energy Transfer Efficiency - Optimize power transfer throughout the swing to maximize distance.'}
+                {'rank': 1, 'description': 'Kinematic Sequence Enhancement: Improve body rotation coordination to generate more power and consistency.'},
+                {'rank': 2, 'description': 'Clubface Control: Enhance swing path consistency for better ball striking accuracy.'},
+                {'rank': 3, 'description': 'Energy Transfer Efficiency: Optimize power transfer throughout the swing to maximize distance.'}
             ]
         elif percentage >= 40:
             formatted_analysis['priority_improvements'] = [
-                {'rank': 1, 'description': '[Most Critical] Fundamental Mechanics - Establish consistent posture, grip, and setup positions.'},
-                {'rank': 2, 'description': '[Important] Body Rotation Development - Improve hip and shoulder turn coordination.'},
-                {'rank': 3, 'description': '[Focus Area] Weight Transfer - Develop proper weight shift from back foot to front foot during swing.'}
+                {'rank': 1, 'description': 'Fundamental Mechanics: Establish consistent posture, grip, and setup positions.'},
+                {'rank': 2, 'description': 'Body Rotation Development: Improve hip and shoulder turn coordination.'},
+                {'rank': 3, 'description': 'Weight Transfer: Develop proper weight shift from back foot to front foot during swing.'}
             ]
         else:  # Below 40%
             formatted_analysis['priority_improvements'] = [
-                {'rank': 1, 'description': '[Most Critical] Basic Setup and Posture - Focus on establishing proper spine angle and athletic stance.'},
-                {'rank': 2, 'description': '[Important] Fundamental Swing Motion - Develop basic backswing and downswing mechanics.'},
-                {'rank': 3, 'description': '[Focus Area] Balance and Stability - Improve overall balance throughout the swing motion.'}
+                {'rank': 1, 'description': 'Basic Setup and Posture: Focus on establishing proper spine angle and athletic stance.'},
+                {'rank': 2, 'description': 'Fundamental Swing Motion: Develop basic backswing and downswing mechanics.'},
+                {'rank': 3, 'description': 'Balance and Stability: Improve overall balance throughout the swing motion.'}
             ]
     
     return formatted_analysis
@@ -951,68 +940,15 @@ def display_formatted_analysis(analysis_data):
         rank = priority['rank']
         description = priority['description']
         
-        # Better extraction of improvement area and description
-        area = ""
-        desc = description
-        
-        # Try different patterns to extract the main topic
-        if '[Most Critical]' in description or '[Important]' in description or '[Focus Area]' in description:
-            # Pattern: [Priority Level] Topic - Description
-            pattern = r'\[(.*?)\]\s*(.*?)(?:\s*-\s*(.*))?$'
-            match = re.search(pattern, description)
-            if match:
-                priority_level = match.group(1)
-                area = match.group(2).strip()
-                desc = match.group(3).strip() if match.group(3) else ""
-        elif ':' in description:
-            # Pattern: Topic: Description
+        # For simple "Topic: Description" format, just display it cleanly
+        if ':' in description:
             parts = description.split(':', 1)
-            area = parts[0].strip()
-            desc = parts[1].strip()
-        elif ' - ' in description:
-            # Pattern: Topic - Description
-            parts = description.split(' - ', 1)
-            area = parts[0].strip()
+            topic = parts[0].strip()
             desc = parts[1].strip()
+            st.markdown(f"**{rank}. {topic}:** {desc}")
         else:
-            # Try to extract first meaningful phrase as area
-            words = description.split()
-            if len(words) > 5:
-                # Take first 3-5 words as the area
-                area = ' '.join(words[:4])
-                desc = ' '.join(words[4:])
-            else:
-                area = description
-                desc = ""
-        
-        # Clean up area and description
-        area = area.replace('[Most Critical]', '').replace('[Important]', '').replace('[Focus Area]', '').strip()
-        
-        # Ensure we have meaningful content
-        if not area or len(area) < 5:
-            area = f"Priority {rank} Improvement"
-        
-        if not desc or len(desc) < 10:
-            # Provide a more complete description based on the area
-            if 'posture' in area.lower():
-                desc = "Try working on maintaining proper spine angle and athletic stance throughout the swing for better consistency and power transfer."
-            elif 'tempo' in area.lower() or 'timing' in area.lower():
-                desc = "Focus on developing a smooth, consistent rhythm that allows for proper sequencing of body movements."
-            elif 'rotation' in area.lower():
-                desc = "Try improving the coordination and range of motion in your body turn to generate more power and accuracy."
-            elif 'weight' in area.lower() or 'shift' in area.lower():
-                desc = "Practice transferring weight from back foot to front foot during the swing for better balance and power."
-            elif 'knee' in area.lower():
-                desc = "Work on maintaining proper knee flex and stability throughout the swing for better foundation and consistency."
-            elif 'hip' in area.lower():
-                desc = "Focus on improving hip mobility and rotation during the downswing to enhance power generation and sequencing."
-            elif 'chest' in area.lower():
-                desc = "Try improving chest rotation efficiency to better coordinate upper body movement with the swing sequence."
-            else:
-                desc = description  # Use the full description if we can't categorize it
-        
-        # Display using simple bullet points instead of colored boxes
-        st.markdown(f"**{rank}. {area}:** {desc}")
+            # Fallback for other formats
+            st.markdown(f"**{rank}. {description}**")
         
         st.write("")  # Add spacing between items
 
@@ -1028,7 +964,43 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
     Returns:
         dict: Calculated biomechanical metrics
     """
-    metrics = {}
+    # Initialize default metrics that will be returned even if calculations fail
+    metrics = {
+        "hip_rotation": 25,
+        "shoulder_rotation": 60,
+        "weight_shift": 0.5,
+        "posture_score": 0.6,
+        "arm_extension": 0.6,
+        "wrist_hinge": 60,
+        "head_movement_lateral": 3.0,
+        "head_movement_vertical": 2.0,
+        "knee_flexion_address": 25,
+        "knee_flexion_impact": 30,
+        "swing_plane_consistency": 0.6,
+        "chest_rotation_efficiency": 0.6,
+        "hip_thrust": 0.5,
+        "ground_force_efficiency": 0.6,
+        "transition_smoothness": 0.6,
+        "kinematic_sequence": 0.6,
+        "energy_transfer": 0.6,
+        "power_accumulation": 0.6,
+        "potential_distance": 200,
+        "speed_generation": "Mixed"
+    }
+    
+    def safe_get_keypoint(keypoints, index, default_pos=[0.0, 0.0]):
+        """Safely get a keypoint position with bounds checking"""
+        try:
+            if index < len(keypoints) and keypoints[index] is not None:
+                kp = keypoints[index]
+                # Handle different keypoint formats
+                if isinstance(kp, (list, tuple)) and len(kp) >= 2:
+                    return [float(kp[0]), float(kp[1])]
+                elif hasattr(kp, 'x') and hasattr(kp, 'y'):
+                    return [float(kp.x), float(kp.y)]
+            return default_pos
+        except (IndexError, TypeError, AttributeError):
+            return default_pos
     
     # Get key frames for analysis
     setup_frames = swing_phases.get("setup", [])
@@ -1055,64 +1027,58 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
             setup_keypoints = pose_data[setup_frame]
             backswing_keypoints = pose_data[top_backswing_frame]
             
-            if len(setup_keypoints) >= 33 and len(backswing_keypoints) >= 33:
+            if len(setup_keypoints) >= 25 and len(backswing_keypoints) >= 25:
                 # Hip rotation calculation using hip landmarks
-                setup_left_hip = np.array(setup_keypoints[23][:2])
-                setup_right_hip = np.array(setup_keypoints[24][:2])
-                backswing_left_hip = np.array(backswing_keypoints[23][:2])
-                backswing_right_hip = np.array(backswing_keypoints[24][:2])
+                setup_left_hip = np.array(safe_get_keypoint(setup_keypoints, 23))
+                setup_right_hip = np.array(safe_get_keypoint(setup_keypoints, 24))
+                backswing_left_hip = np.array(safe_get_keypoint(backswing_keypoints, 23))
+                backswing_right_hip = np.array(safe_get_keypoint(backswing_keypoints, 24))
                 
                 # Calculate hip line angles
                 setup_hip_vector = setup_right_hip - setup_left_hip
                 backswing_hip_vector = backswing_right_hip - backswing_left_hip
                 
-                setup_hip_angle = np.degrees(np.arctan2(setup_hip_vector[1], setup_hip_vector[0]))
-                backswing_hip_angle = np.degrees(np.arctan2(backswing_hip_vector[1], backswing_hip_vector[0]))
-                
-                hip_rotation = abs(backswing_hip_angle - setup_hip_angle)
-                # Normalize to reasonable range (professionals typically achieve 45+ degrees)
-                metrics["hip_rotation"] = min(hip_rotation, 90)
-            else:
-                metrics["hip_rotation"] = 25  # Lower default for incomplete data
-        else:
-            metrics["hip_rotation"] = 25
+                if np.linalg.norm(setup_hip_vector) > 0 and np.linalg.norm(backswing_hip_vector) > 0:
+                    setup_hip_angle = np.degrees(np.arctan2(setup_hip_vector[1], setup_hip_vector[0]))
+                    backswing_hip_angle = np.degrees(np.arctan2(backswing_hip_vector[1], backswing_hip_vector[0]))
+                    
+                    hip_rotation = abs(backswing_hip_angle - setup_hip_angle)
+                    # Normalize to reasonable range (professionals typically achieve 45+ degrees)
+                    metrics["hip_rotation"] = min(hip_rotation, 90)
             
         # Calculate Shoulder Rotation
         if setup_frame and top_backswing_frame and setup_frame in pose_data and top_backswing_frame in pose_data:
             setup_keypoints = pose_data[setup_frame]
             backswing_keypoints = pose_data[top_backswing_frame]
             
-            if len(setup_keypoints) >= 33 and len(backswing_keypoints) >= 33:
+            if len(setup_keypoints) >= 13 and len(backswing_keypoints) >= 13:
                 # Shoulder rotation calculation
-                setup_left_shoulder = np.array(setup_keypoints[11][:2])
-                setup_right_shoulder = np.array(setup_keypoints[12][:2])
-                backswing_left_shoulder = np.array(backswing_keypoints[11][:2])
-                backswing_right_shoulder = np.array(backswing_keypoints[12][:2])
+                setup_left_shoulder = np.array(safe_get_keypoint(setup_keypoints, 11))
+                setup_right_shoulder = np.array(safe_get_keypoint(setup_keypoints, 12))
+                backswing_left_shoulder = np.array(safe_get_keypoint(backswing_keypoints, 11))
+                backswing_right_shoulder = np.array(safe_get_keypoint(backswing_keypoints, 12))
                 
                 setup_shoulder_vector = setup_right_shoulder - setup_left_shoulder
                 backswing_shoulder_vector = backswing_right_shoulder - backswing_left_shoulder
                 
-                setup_shoulder_angle = np.degrees(np.arctan2(setup_shoulder_vector[1], setup_shoulder_vector[0]))
-                backswing_shoulder_angle = np.degrees(np.arctan2(backswing_shoulder_vector[1], backswing_shoulder_vector[0]))
-                
-                shoulder_rotation = abs(backswing_shoulder_angle - setup_shoulder_angle)
-                metrics["shoulder_rotation"] = min(shoulder_rotation, 120)
-            else:
-                metrics["shoulder_rotation"] = 60  # Lower default
-        else:
-            metrics["shoulder_rotation"] = 60
+                if np.linalg.norm(setup_shoulder_vector) > 0 and np.linalg.norm(backswing_shoulder_vector) > 0:
+                    setup_shoulder_angle = np.degrees(np.arctan2(setup_shoulder_vector[1], setup_shoulder_vector[0]))
+                    backswing_shoulder_angle = np.degrees(np.arctan2(backswing_shoulder_vector[1], backswing_shoulder_vector[0]))
+                    
+                    shoulder_rotation = abs(backswing_shoulder_angle - setup_shoulder_angle)
+                    metrics["shoulder_rotation"] = min(shoulder_rotation, 120)
             
         # Calculate Weight Shift (using hip and ankle positions)
         if setup_frame and impact_frame and setup_frame in pose_data and impact_frame in pose_data:
             setup_keypoints = pose_data[setup_frame]
             impact_keypoints = pose_data[impact_frame]
             
-            if len(setup_keypoints) >= 33 and len(impact_keypoints) >= 33:
+            if len(setup_keypoints) >= 29 and len(impact_keypoints) >= 29:
                 # Use center of mass approximation
-                setup_left_ankle = np.array(setup_keypoints[27][:2])
-                setup_right_ankle = np.array(setup_keypoints[28][:2])
-                impact_left_ankle = np.array(impact_keypoints[27][:2])
-                impact_right_ankle = np.array(impact_keypoints[28][:2])
+                setup_left_ankle = np.array(safe_get_keypoint(setup_keypoints, 27))
+                setup_right_ankle = np.array(safe_get_keypoint(setup_keypoints, 28))
+                impact_left_ankle = np.array(safe_get_keypoint(impact_keypoints, 27))
+                impact_right_ankle = np.array(safe_get_keypoint(impact_keypoints, 28))
                 
                 # Calculate weight distribution based on foot positioning
                 setup_center = (setup_left_ankle + setup_right_ankle) / 2
@@ -1124,47 +1090,40 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
                     weight_shift_amount = np.linalg.norm(impact_center - setup_center) / foot_width
                     # Convert to percentage (professionals typically achieve 70%+ to front foot)
                     weight_shift = min(0.5 + weight_shift_amount * 0.5, 0.9)
-                else:
-                    weight_shift = 0.5
-                metrics["weight_shift"] = weight_shift
-            else:
-                metrics["weight_shift"] = 0.5  # Neutral default
-        else:
-            metrics["weight_shift"] = 0.5
+                    metrics["weight_shift"] = weight_shift
             
         # Calculate Posture Score (spine angle consistency)
         posture_scores = []
         for frame_list in [setup_frames, backswing_frames, impact_frames]:
             if frame_list:
                 frame = frame_list[len(frame_list) // 2]
-                if frame in pose_data and len(pose_data[frame]) >= 33:
+                if frame in pose_data and len(pose_data[frame]) >= 25:
                     keypoints = pose_data[frame]
                     # Use shoulder and hip landmarks to estimate spine angle
-                    left_shoulder = np.array(keypoints[11][:2])
-                    right_shoulder = np.array(keypoints[12][:2])
-                    left_hip = np.array(keypoints[23][:2])
-                    right_hip = np.array(keypoints[24][:2])
+                    left_shoulder = np.array(safe_get_keypoint(keypoints, 11))
+                    right_shoulder = np.array(safe_get_keypoint(keypoints, 12))
+                    left_hip = np.array(safe_get_keypoint(keypoints, 23))
+                    right_hip = np.array(safe_get_keypoint(keypoints, 24))
                     
                     shoulder_center = (left_shoulder + right_shoulder) / 2
                     hip_center = (left_hip + right_hip) / 2
                     
                     spine_vector = shoulder_center - hip_center
-                    spine_angle = np.degrees(np.arctan2(spine_vector[1], spine_vector[0]))
-                    posture_scores.append(abs(spine_angle))
+                    if np.linalg.norm(spine_vector) > 0:
+                        spine_angle = np.degrees(np.arctan2(spine_vector[1], spine_vector[0]))
+                        posture_scores.append(abs(spine_angle))
         
         if posture_scores:
             # Good posture = consistent spine angle across phases
             posture_consistency = 1.0 - (np.std(posture_scores) / 90.0)  # Normalize by 90 degrees
             metrics["posture_score"] = max(0.3, min(posture_consistency, 1.0))
-        else:
-            metrics["posture_score"] = 0.6
             
         # Calculate Arm Extension at Impact
-        if impact_frame and impact_frame in pose_data and len(pose_data[impact_frame]) >= 33:
+        if impact_frame and impact_frame in pose_data and len(pose_data[impact_frame]) >= 17:
             keypoints = pose_data[impact_frame]
-            right_shoulder = np.array(keypoints[12][:2])
-            right_elbow = np.array(keypoints[14][:2])
-            right_wrist = np.array(keypoints[16][:2])
+            right_shoulder = np.array(safe_get_keypoint(keypoints, 12))
+            right_elbow = np.array(safe_get_keypoint(keypoints, 14))
+            right_wrist = np.array(safe_get_keypoint(keypoints, 16))
             
             # Calculate arm extension
             upper_arm = np.linalg.norm(right_elbow - right_shoulder)
@@ -1177,10 +1136,6 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
             if total_arm_length > 0:
                 extension_ratio = actual_distance / total_arm_length
                 metrics["arm_extension"] = min(extension_ratio, 1.0)
-            else:
-                metrics["arm_extension"] = 0.6
-        else:
-            metrics["arm_extension"] = 0.6
             
         # Calculate Wrist Hinge using joint angles
         wrist_angles = []
@@ -1188,32 +1143,34 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
             if frame_list:
                 frame = frame_list[len(frame_list) // 2]
                 if frame in pose_data:
-                    angles = calculate_joint_angles(pose_data[frame])
-                    if "right_wrist" in angles:
-                        wrist_angles.append(angles["right_wrist"])
+                    try:
+                        angles = calculate_joint_angles(pose_data[frame])
+                        if angles and "right_wrist" in angles:
+                            wrist_angles.append(angles["right_wrist"])
+                    except Exception:
+                        pass  # Skip if joint angle calculation fails
         
         if wrist_angles:
             avg_wrist_angle = np.mean(wrist_angles)
             # Good wrist hinge is typically 80+ degrees
             metrics["wrist_hinge"] = min(avg_wrist_angle, 120)
-        else:
-            metrics["wrist_hinge"] = 60
             
         # Calculate Head Movement (lateral and vertical)
         if setup_frame and impact_frame and setup_frame in pose_data and impact_frame in pose_data:
             setup_keypoints = pose_data[setup_frame]
             impact_keypoints = pose_data[impact_frame]
             
-            if len(setup_keypoints) >= 33 and len(impact_keypoints) >= 33:
+            if len(setup_keypoints) >= 1 and len(impact_keypoints) >= 1:
                 # Use nose landmark (index 0) for head position
-                setup_head = np.array(setup_keypoints[0][:2])
-                impact_head = np.array(impact_keypoints[0][:2])
+                setup_head = np.array(safe_get_keypoint(setup_keypoints, 0))
+                impact_head = np.array(safe_get_keypoint(impact_keypoints, 0))
                 
                 head_movement = np.abs(impact_head - setup_head)
                 # Convert pixel movement to approximate inches (rough estimation)
                 # Assume average person's head is about 9 inches, use that as scale
                 if len(setup_keypoints) > 10:  # Have enough landmarks
-                    head_height_pixels = abs(setup_keypoints[0][1] - setup_keypoints[10][1])  # Nose to mouth
+                    mouth_pos = safe_get_keypoint(setup_keypoints, 10)
+                    head_height_pixels = abs(setup_head[1] - mouth_pos[1])
                     if head_height_pixels > 0:
                         pixel_to_inch = 4.0 / head_height_pixels  # Approximate nose-to-mouth is 4 inches
                         lateral_movement = head_movement[0] * pixel_to_inch
@@ -1227,24 +1184,18 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
                 
                 metrics["head_movement_lateral"] = min(lateral_movement, 8.0)
                 metrics["head_movement_vertical"] = min(vertical_movement, 6.0)
-            else:
-                metrics["head_movement_lateral"] = 3.0
-                metrics["head_movement_vertical"] = 2.0
-        else:
-            metrics["head_movement_lateral"] = 3.0
-            metrics["head_movement_vertical"] = 2.0
             
         # Calculate Knee Flexion
         knee_flexions = {}
         for phase_name, frame_list in [("address", setup_frames), ("impact", impact_frames)]:
             if frame_list:
                 frame = frame_list[len(frame_list) // 2]
-                if frame in pose_data and len(pose_data[frame]) >= 33:
+                if frame in pose_data and len(pose_data[frame]) >= 29:
                     keypoints = pose_data[frame]
                     # Right knee angle using hip, knee, ankle
-                    right_hip = np.array(keypoints[24][:2])
-                    right_knee = np.array(keypoints[26][:2])
-                    right_ankle = np.array(keypoints[28][:2])
+                    right_hip = np.array(safe_get_keypoint(keypoints, 24))
+                    right_knee = np.array(safe_get_keypoint(keypoints, 26))
+                    right_ankle = np.array(safe_get_keypoint(keypoints, 28))
                     
                     # Calculate knee angle
                     thigh_vector = right_hip - right_knee
@@ -1255,10 +1206,6 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
                         cos_angle = np.clip(cos_angle, -1, 1)
                         knee_angle = np.degrees(np.arccos(cos_angle))
                         knee_flexions[phase_name] = min(knee_angle, 60)
-                    else:
-                        knee_flexions[phase_name] = 25
-                else:
-                    knee_flexions[phase_name] = 25
         
         metrics["knee_flexion_address"] = knee_flexions.get("address", 25)
         metrics["knee_flexion_impact"] = knee_flexions.get("impact", 30)
@@ -1323,7 +1270,7 @@ def calculate_biomechanical_metrics(pose_data, swing_phases):
             
     except Exception as e:
         print(f"Error calculating biomechanical metrics: {str(e)}")
-        # Fail here
-        return None
+        # Don't return None - instead return the default metrics that were initialized
+        pass
     
     return metrics

app/streamlit_app.py

@@ -12,6 +12,7 @@ from pathlib import Path
 import shutil
 import cv2
 from PIL import Image
+from datetime import datetime
 
 # Load environment variables
 load_dotenv()
@@ -27,12 +28,440 @@ from app.models.llm_analyzer import generate_swing_analysis, create_llm_prompt,
 from app.utils.visualizer import create_annotated_video
 from app.utils.comparison import create_key_frame_comparison, extract_key_swing_frames
 
+# Import RAG functionality
+try:
+    from app.golf_swing_rag import GolfSwingRAG
+    RAG_AVAILABLE = True
+except ImportError:
+    RAG_AVAILABLE = False
+    st.warning("RAG functionality not available. Please ensure golf_swing_rag.py is in the app directory.")
+
 # Set page config
 st.set_page_config(page_title="Par-ity Project: Golf Swing Analysis 🏌️‍♀️",
                    page_icon="🏌️‍♀️",
                    layout="wide",
                    initial_sidebar_state="collapsed")
 
+# Custom CSS for RAG interface
+st.markdown("""
+<style>
+    .chat-message {
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    .user-message {
+        background-color: #e3f2fd;
+        border-left: 4px solid #2196f3;
+    }
+    .assistant-message {
+        background-color: #f1f8e9;
+        border-left: 4px solid #4caf50;
+    }
+    .rag-header {
+        color: #2E8B57;
+        font-size: 1.5rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+@st.cache_resource
+def load_rag_system():
+    """Load and initialize the RAG system (cached for performance)"""
+    if not RAG_AVAILABLE:
+        return None
+    try:
+        with st.spinner("Loading golf swing knowledge base..."):
+            rag = GolfSwingRAG()
+            rag.load_and_process_data()
+            rag.create_embeddings()
+        return rag
+    except Exception as e:
+        st.error(f"Error loading RAG system: {str(e)}")
+        return None
+
+def display_rag_sources(sources):
+    """Display source information in an organized way"""
+    if not sources:
+        return
+    
+    st.subheader("📚 Sources")
+    for i, source in enumerate(sources[:3]):  # Show top 3 sources
+        with st.expander(f"Source {i+1}: {source['metadata']['title'][:60]}..."):
+            st.write(f"**Similarity Score:** {source['similarity_score']:.3f}")
+            st.write(f"**Source:** {source['metadata']['source']}")
+            if source['metadata']['url']:
+                st.write(f"**URL:** [Link]({source['metadata']['url']})")
+            st.write("**Content:**")
+            st.write(source['chunk'][:500] + "..." if len(source['chunk']) > 500 else source['chunk'])
+
+def render_rag_interface():
+    """Render the RAG chatbot interface"""
+    # Removed header and description
+    
+    # Initialize RAG system
+    if 'rag_system' not in st.session_state and RAG_AVAILABLE:
+        st.session_state.rag_system = load_rag_system()
+    
+    # Initialize chat history if not exists
+    if 'rag_chat_history' not in st.session_state:
+        st.session_state.rag_chat_history = []
+    
+    if not RAG_AVAILABLE or st.session_state.get('rag_system') is None:
+        st.error("RAG system is not available. Please check the setup.")
+        return
+    
+    # Check if we have video analysis data to enhance responses
+    user_swing_context = ""
+    if st.session_state.get('video_analyzed') and 'analysis_data' in st.session_state:
+        stored_data = st.session_state.analysis_data
+        
+        # Use the structured analysis_data instead of just the prompt
+        if 'analysis_data' in stored_data:
+            structured_analysis = stored_data['analysis_data']
+            
+            # Format the structured data for better RAG context
+            user_swing_context = f"""
+
+USER'S SWING ANALYSIS:
+
+=== SWING TIMING & PHASES ===
+Swing Phases:
+- Setup: {structured_analysis.get('swing_phases', {}).get('setup', {}).get('frame_count', 0)} frames
+- Backswing: {structured_analysis.get('swing_phases', {}).get('backswing', {}).get('frame_count', 0)} frames  
+- Downswing: {structured_analysis.get('swing_phases', {}).get('downswing', {}).get('frame_count', 0)} frames
+- Impact: {structured_analysis.get('swing_phases', {}).get('impact', {}).get('frame_count', 0)} frames
+- Follow-through: {structured_analysis.get('swing_phases', {}).get('follow_through', {}).get('frame_count', 0)} frames
+
+Timing Metrics:
+- Tempo Ratio (down:back): {structured_analysis.get('timing_metrics', {}).get('tempo_ratio', 'N/A')}
+- Estimated Club Speed: {structured_analysis.get('timing_metrics', {}).get('estimated_club_speed_mph', 'N/A')} mph
+- Total Swing Time: {structured_analysis.get('timing_metrics', {}).get('total_swing_time_ms', 'N/A')} ms
+
+=== BIOMECHANICAL METRICS ===
+Core Body Mechanics:
+- Hip Rotation: {structured_analysis.get('biomechanical_metrics', {}).get('hip_rotation_degrees', 'N/A')}°
+- Shoulder Rotation: {structured_analysis.get('biomechanical_metrics', {}).get('shoulder_rotation_degrees', 'N/A')}°
+- Posture Score: {structured_analysis.get('biomechanical_metrics', {}).get('posture_score_percent', 'N/A')}%
+- Weight Shift: {structured_analysis.get('biomechanical_metrics', {}).get('weight_shift_percent', 'N/A')}%
+
+Upper Body Mechanics:
+- Arm Extension: {structured_analysis.get('biomechanical_metrics', {}).get('arm_extension_percent', 'N/A')}%
+- Wrist Hinge: {structured_analysis.get('biomechanical_metrics', {}).get('wrist_hinge_degrees', 'N/A')}°
+- Swing Plane Consistency: {structured_analysis.get('biomechanical_metrics', {}).get('swing_plane_consistency_percent', 'N/A')}%
+- Head Movement (lateral): {structured_analysis.get('biomechanical_metrics', {}).get('head_movement_lateral_inches', 'N/A')} in
+- Head Movement (vertical): {structured_analysis.get('biomechanical_metrics', {}).get('head_movement_vertical_inches', 'N/A')} in
+
+Lower Body Mechanics:
+- Hip Thrust: {structured_analysis.get('biomechanical_metrics', {}).get('hip_thrust_percent', 'N/A')}%
+- Ground Force Efficiency: {structured_analysis.get('biomechanical_metrics', {}).get('ground_force_efficiency_percent', 'N/A')}%
+- Knee Flexion (address): {structured_analysis.get('biomechanical_metrics', {}).get('knee_flexion_address_degrees', 'N/A')}°
+- Knee Flexion (impact): {structured_analysis.get('biomechanical_metrics', {}).get('knee_flexion_impact_degrees', 'N/A')}°
+
+Movement Quality & Coordination:
+- Sequential Kinematic Sequence: {structured_analysis.get('biomechanical_metrics', {}).get('kinematic_sequence_percent', 'N/A')}%
+- Energy Transfer Efficiency: {structured_analysis.get('biomechanical_metrics', {}).get('energy_transfer_efficiency_percent', 'N/A')}%
+- Power Accumulation: {structured_analysis.get('biomechanical_metrics', {}).get('power_accumulation_percent', 'N/A')}%
+- Transition Smoothness: {structured_analysis.get('biomechanical_metrics', {}).get('transition_smoothness_percent', 'N/A')}%
+
+Performance Estimates:
+- Potential Distance: {structured_analysis.get('biomechanical_metrics', {}).get('potential_distance_yards', 'N/A')} yards
+- Speed Generation Method: {structured_analysis.get('biomechanical_metrics', {}).get('speed_generation_method', 'N/A')}
+
+=== TRAJECTORY ANALYSIS ===
+- Estimated Carry Distance: {structured_analysis.get('trajectory_analysis', {}).get('estimated_carry_distance', 'N/A')} yards
+- Estimated Ball Speed: {structured_analysis.get('trajectory_analysis', {}).get('estimated_ball_speed', 'N/A')} mph
+- Trajectory Type: {structured_analysis.get('trajectory_analysis', {}).get('trajectory_type', 'N/A')}
+"""
+            
+            # Removed success message
+        elif 'prompt' in stored_data:
+            # Fallback to prompt if structured data not available
+            user_swing_context = f"\n\nUSER'S SWING ANALYSIS:\n{stored_data['prompt']}"
+            # Removed success message
+
+    # Create columns for layout
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        # Removed subheader
+        
+        # Question input (removed label)
+        question = st.text_area(
+            "",  # Removed label
+            height=100,
+            placeholder="Ask about your golf swing technique..."
+        )
+        
+        # Removed settings section - using smart defaults instead
+        
+        col_submit, col_clear = st.columns([1, 1])
+        with col_submit:
+            submit_button = st.button("🎯 Get Answer", type="primary", use_container_width=True)
+        with col_clear:
+            if st.button("🗑️ Clear Chat History", use_container_width=True):
+                st.session_state.rag_chat_history = []
+                # Don't call st.rerun() here to avoid disappearing interface
+                st.success("Chat history cleared!")
+        
+        # Process question
+        if submit_button and question.strip():
+            with st.spinner("Analyzing your question and searching the knowledge base..."):
+                try:
+                    # Enhanced query method that includes user's swing context
+                    # Use smart default for number of sources (3-5 depending on context)
+                    num_sources = 5 if user_swing_context else 3  # More sources when we have swing analysis
+                    result = query_with_user_context(
+                        st.session_state.rag_system, 
+                        question, 
+                        user_swing_context,
+                        top_k=num_sources
+                    )
+                    
+                    # Add to chat history
+                    st.session_state.rag_chat_history.append({
+                        'question': question,
+                        'response': result['response'],
+                        'sources': result['sources'],
+                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                        'used_swing_context': bool(user_swing_context)
+                    })
+                    
+                    st.success("Answer generated successfully!")
+                    
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")
+        
+        # Display chat history (simplified)
+        if st.session_state.rag_chat_history:
+            for i, chat in enumerate(reversed(st.session_state.rag_chat_history)):
+                # Removed question numbers, timestamps, and personalization indicators
+                
+                # Question
+                st.markdown(f'<div class="chat-message user-message"><strong>🤔 Your Question:</strong><br>{chat["question"]}</div>', 
+                           unsafe_allow_html=True)
+                
+                # Response
+                st.markdown(f'<div class="chat-message assistant-message"><strong>⛳ Expert Answer:</strong><br>{chat["response"]}</div>', 
+                           unsafe_allow_html=True)
+                
+                # Removed sources display
+                
+                st.divider()
+    
+    with col2:
+        # Removed all the About section, Tips, Personalized Questions, and metrics
+        pass
+
+def query_with_user_context(rag_system, question, user_swing_context, top_k=5):
+    """Enhanced query method that includes user's swing analysis context"""
+    # Search for relevant chunks
+    relevant_chunks = rag_system.search_similar_chunks(question, top_k)
+    
+    # Generate response with enhanced context
+    response = generate_enhanced_response(rag_system, question, relevant_chunks, user_swing_context)
+    print(f"Response: {response}")
+    
+    return {
+        'response': response,
+        'sources': relevant_chunks,
+        'query': question,
+        'timestamp': datetime.now().isoformat()
+    }
+
+def generate_enhanced_response(rag_system, query, context_chunks, user_swing_context=""):
+    """Generate response using OpenAI API with user's swing analysis as the main system prompt"""
+    if not rag_system.openai_client:
+        print("No OpenAI client found")
+        return generate_enhanced_fallback_response(query, context_chunks, user_swing_context)
+    
+    # Prepare context from knowledge base
+    knowledge_context = "\n\n".join([f"Reference Material from '{chunk['metadata']['title']}':\n{chunk['chunk']}" 
+                          for chunk in context_chunks])
+    
+    # Use the user's swing analysis as the primary system prompt if available
+    print(f"User swing context: {user_swing_context}")
+    if user_swing_context:
+        # Extract the actual analysis content (remove the header)
+        analysis_content = user_swing_context.replace("USER'S SWING ANALYSIS:\n", "").strip()
+        
+        system_prompt = f"""{analysis_content}
+
+You are a golf swing technique expert assistant analyzing this specific player's swing. 
+
+IMPORTANT: Only reference the player's swing analysis data above if the question is directly related to swing motion biomechanics (like hip rotation, shoulder turn, weight transfer, timing, etc.). 
+
+Do NOT reference swing analysis for questions about:
+- Grip (how to hold the club)
+- Setup/stance (static positioning before the swing)
+- Equipment (clubs, balls, etc.)
+- Course management
+- Mental game
+- Basic fundamentals that aren't measured during swing motion
+
+Follow this response structure:
+
+1. Synthesize information from the reference materials below to answer the user's question. Keep this to 2-4 sentences maximum. Start with "Based on [source name]," and provide clear, actionable advice about the technique.
+
+2. If the question relates to swing motion biomechanics AND you found relevant measurements in the analysis above, provide specific improvement advice comparing current state to recommendations. Otherwise, provide general advice without forcing connections to unrelated swing metrics.
+
+Reference Materials from Golf Instruction Database:
+{knowledge_context}"""
+
+        user_prompt = f"""Based on the golf instruction reference materials provided, please answer this question about golf swing technique:
+
+{query}
+
+Remember to:
+1. Only reference my swing analysis if the question is about swing motion biomechanics
+2. Synthesize expert advice concisely (2-4 sentences max)
+3. Don't force connections between unrelated topics (e.g., don't mention wrist hinge when asking about grip)"""
+
+    else:
+        # Fallback to general system prompt if no swing analysis available
+        system_prompt = f"""You are a golf swing technique expert assistant. You help golfers improve their swing by providing detailed, accurate advice based on professional golf instruction content.
+
+Instructions:
+- Answer questions about golf swing technique, mechanics, common problems, and solutions
+- Provide specific, actionable advice when possible
+- Reference relevant technical concepts when appropriate
+- Be encouraging and supportive
+- Synthesize information from multiple sources rather than just quoting them
+- Give clear, comprehensive explanations that golfers can understand and apply
+
+Reference Materials from Golf Instruction Database:
+{knowledge_context}"""
+
+        user_prompt = f"""Based on the golf instruction reference materials provided, please answer this question about golf swing technique:
+
+{query}
+
+Please provide a helpful, detailed response that synthesizes the relevant information into clear, actionable guidance."""
+
+    print(f"System prompt: {system_prompt}")
+    print(f"User prompt: {user_prompt}")
+    try:
+        response = rag_system.openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            max_tokens=800,
+            temperature=0.7
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        print(f"OpenAI API error: {e}")
+        return generate_enhanced_fallback_response(query, context_chunks, user_swing_context)
+
+def generate_enhanced_fallback_response(query, context_chunks, user_swing_context=""):
+    """Generate an enhanced fallback response when OpenAI API is not available"""
+    if not context_chunks:
+        return "I couldn't find specific information about that topic in the golf swing database. Could you try rephrasing your question or being more specific?"
+    
+    # Extract relevant information from chunks
+    best_chunk = context_chunks[0]
+    chunk_content = best_chunk['chunk']
+    source_title = best_chunk['metadata']['title']
+    
+    response_parts = []
+    
+    # Check if question is about swing motion biomechanics vs setup/grip/equipment
+    question_lower = query.lower()
+    
+    # Define topics that are NOT about swing motion biomechanics
+    non_biomechanics_topics = [
+        'grip', 'hold', 'grip pressure', 'grip size', 'grip style',
+        'setup', 'stance', 'address', 'alignment', 'posture at address',
+        'equipment', 'club', 'ball', 'tee', 'glove',
+        'course management', 'strategy', 'mental', 'psychology',
+        'warm up', 'practice', 'routine', 'pre-shot'
+    ]
+    
+    # Check if question is about non-biomechanics topics
+    is_non_biomechanics = any(topic in question_lower for topic in non_biomechanics_topics)
+    
+    # Part 1: Only check for relevant measurements if question is about swing motion biomechanics
+    found_relevant_measurement = False
+    if user_swing_context and not is_non_biomechanics:
+        analysis_content = user_swing_context.replace("USER'S SWING ANALYSIS:\n", "").strip()
+        analysis_lower = analysis_content.lower()
+        
+        # Only do specific keyword matching for biomechanics-related questions
+        if "wrist" in question_lower and "hinge" in question_lower:
+            # Look for wrist hinge measurements (only if asking about wrist hinge specifically)
+            lines = analysis_content.split('\n')
+            for line in lines:
+                if 'wrist hinge' in line.lower() and ('°' in line or '%' in line):
+                    import re
+                    wrist_match = re.search(r'wrist hinge[:\s]*(\d+\.?\d*°)', line.lower())
+                    if wrist_match:
+                        response_parts.append(f"I notice that your wrist hinge is {wrist_match.group(1)} during your swing.")
+                        found_relevant_measurement = True
+                        break
+                        
+        elif "hip" in question_lower and ("rotation" in question_lower or "turn" in question_lower):
+            # Look for hip rotation measurements (only if asking about hip rotation/turn)
+            lines = analysis_content.split('\n')
+            for line in lines:
+                if 'hip rotation' in line.lower() and '°' in line:
+                    import re
+                    user_hip_match = re.search(r'-\s*hip rotation[:\s]*(\d+\.?\d*°)', line.lower())
+                    if user_hip_match:
+                        response_parts.append(f"I notice that your hip rotation is {user_hip_match.group(1)} during your swing.")
+                        found_relevant_measurement = True
+                        break
+                        
+        elif "weight" in question_lower and ("transfer" in question_lower or "shift" in question_lower):
+            # Look for weight transfer measurements (only if asking about weight transfer/shift)
+            lines = analysis_content.split('\n')
+            for line in lines:
+                if ('weight transfer' in line.lower() or 'weight shift' in line.lower()) and '%' in line:
+                    import re
+                    weight_match = re.search(r'weight (?:transfer|shift)[:\s]*(\d+\.?\d*%)', line.lower())
+                    if weight_match:
+                        response_parts.append(f"I notice that your weight transfer is {weight_match.group(1)} during the downswing.")
+                        found_relevant_measurement = True
+                        break
+                        
+        elif "shoulder" in question_lower and ("rotation" in question_lower or "turn" in question_lower):
+            # Look for shoulder measurements (only if asking about shoulder rotation/turn)
+            lines = analysis_content.split('\n')
+            for line in lines:
+                if 'shoulder rotation' in line.lower() and '°' in line:
+                    import re
+                    shoulder_match = re.search(r'shoulder rotation[:\s]*(\d+\.?\d*°)', line.lower())
+                    if shoulder_match:
+                        response_parts.append(f"I notice that your shoulder rotation is {shoulder_match.group(1)} during your swing.")
+                        found_relevant_measurement = True
+                        break
+    
+    # Part 2: Expert recommendation (synthesized from source)
+    sentences = chunk_content.split('. ')
+    meaningful_sentences = [s.strip() for s in sentences if len(s.strip()) > 20][:3]
+    expert_advice = '. '.join(meaningful_sentences[:2]) + '.'
+    
+    response_parts.append(f"Based on {source_title}, {expert_advice}")
+    
+    # Part 3: Improvement recommendation (only connect to swing analysis if relevant)
+    if user_swing_context and found_relevant_measurement and not is_non_biomechanics:
+        # Only provide swing-analysis-specific advice if we found relevant measurements
+        analysis_content = user_swing_context.replace("USER'S SWING ANALYSIS:\n", "").strip()
+        response_parts.append("Based on your current measurements compared to professional standards, focus on implementing the expert advice above to address your specific swing characteristics.")
+    else:
+        # For non-biomechanics questions or when no relevant measurements found
+        response_parts.append("Focus on implementing this expert advice to improve your technique.")
+    
+    # Combine all parts
+    final_response = "\n\n".join(response_parts)
+    
+    # Add source reference
+    final_response += f"\n\n📚 **Source**: {source_title}"
+    
+    return final_response
 
 # Define functions
 def validate_youtube_url(url):
@@ -106,7 +535,9 @@ def main():
             'trajectory_data': None,
             'sample_rate': None
         }
-    
+    if 'show_chatbot' not in st.session_state:
+        st.session_state.show_chatbot = False
+
     # Add session cleanup - clean up old files when starting a new session
     if 'session_initialized' not in st.session_state:
         cleanup_result = cleanup_downloads_directory(keep_annotated=True)
@@ -237,13 +668,12 @@ def main():
                 'prompt': prompt
             }
 
-            # Clean up the original video file after processing (keep frames in memory)
-            st.info("🗑️ Cleaning up original video file to save space...")
-            cleanup_video_file(video_path)
+            # Keep the original video file for potential annotation
+            # Video will be cleaned up when user uploads a new video or session ends
 
             # Present the options after analysis
             st.subheader("What would you like to do next?")
-            options_col1, options_col2, options_col3 = st.columns(3)
+            options_col1, options_col2, options_col3, options_col4 = st.columns(4)
 
             with options_col1:
                 st.info(
@@ -259,6 +689,11 @@ def main():
                 st.info(
                     "**Option 3: Key Frame Analysis**\n\nExtract and review your setup, top of backswing, and impact frames with helpful comments for each phase."
                 )
+            
+            with options_col4:
+                st.info(
+                    "**Option 4: Golf Swing Chatbot**\n\nAsk specific questions about golf swing technique and get expert advice from our knowledge base."
+                )
 
         except Exception as e:
             st.error(f"Error during analysis: {str(e)}")
@@ -276,7 +711,7 @@ def main():
                         language="text")
 
         # Create columns for the action buttons
-        button_col1, button_col2, button_col3 = st.columns(3)
+        button_col1, button_col2, button_col3, button_col4 = st.columns(4)
 
         with button_col1:
             annotated_video_clicked = st.button("Generate Annotated Video",
@@ -292,9 +727,16 @@ def main():
             keyframe_analysis_clicked = st.button("Key Frame Analysis",
                                                  key="keyframe_analysis",
                                                  use_container_width=True)
+        
+        with button_col4:
+            chatbot_clicked = st.button("Golf Swing Chatbot",
+                                       key="rag_chatbot",
+                                       use_container_width=True)
 
         # Handle annotated video creation
         if annotated_video_clicked:
+            # Reset chatbot state when other buttons are clicked
+            st.session_state.show_chatbot = False
             try:
                 with st.spinner("Creating annotated video..."):
                     # Create downloads directory if it doesn't exist
@@ -341,6 +783,8 @@ def main():
 
         # Handle improvement recommendations generation
         if improvements_clicked:
+            # Reset chatbot state when other buttons are clicked
+            st.session_state.show_chatbot = False
             with st.spinner(
                     "Analyzing your swing and generating recommendations..."):
                 # Get data from session state
@@ -383,8 +827,11 @@ def main():
                 else:
                     # Show error message if analysis failed
                     st.error(analysis)
+        
         # Handle key frame analysis (new tab/option)
         if keyframe_analysis_clicked:
+            # Reset chatbot state when other buttons are clicked
+            st.session_state.show_chatbot = False
             try:
                 with st.spinner("Extracting key frames from your swing..."):
                     user_video_path = st.session_state.analysis_data['video_path']
@@ -479,6 +926,23 @@ def main():
             except Exception as e:
                 st.error(f"Error during key frame analysis: {str(e)}")
                 st.info("Please ensure your video is in a supported format and try again.")
+        
+        # Handle RAG chatbot
+        if chatbot_clicked:
+            st.session_state.show_chatbot = True
+        
+        # Always show chatbot interface if it's active
+        if st.session_state.show_chatbot:
+            # Create header with close button
+            header_col1, header_col2 = st.columns([3, 1])
+            with header_col1:
+                st.subheader("Golf Swing Technique Chatbot")
+            with header_col2:
+                if st.button("✕ Close Chatbot", use_container_width=True):
+                    st.session_state.show_chatbot = False
+                    st.rerun()
+            
+            render_rag_interface()
 
 
 if __name__ == "__main__":

app/utils/visualizer.py

@@ -216,9 +216,9 @@ def create_annotated_video(video_path,
                             print(f"Error transforming detection bbox: {str(e)}")
                             # Keep the bbox as is if there's an error
 
-            # Draw detections
+            # Draw detections - only show person detections, skip other objects
             frame_detections = [
-                d for d in detections if d.frame_idx == i * sample_rate
+                d for d in detections if d.frame_idx == i * sample_rate and d.class_name == "person"
             ]
             for detection in frame_detections:
                 try:
@@ -229,10 +229,8 @@ def create_annotated_video(video_path,
                         
                     x1, y1, x2, y2 = map(int, detection.bbox)
 
-                    # Draw bounding box
-                    color = (0, 255,
-                             0) if detection.class_name == "person" else (0, 0,
-                                                                          255)
+                    # Draw bounding box (only for person detections - green)
+                    color = (0, 255, 0)  # Green for person
                     cv2.rectangle(annotated_frame, (x1, y1), (x2, y2), color, 2)
 
                     # Draw label

article_extractor.py

@@ -0,0 +1,83 @@
+import requests
+from newspaper import Article
+import pandas as pd
+import time
+from pathlib import Path
+import re
+from typing import List
+
+def extract_article_text(urls):
+    """Extract text content from a list of article URLs"""
+    articles = []
+    for url in urls:
+        try:
+            article = Article(url)
+            article.download()
+            article.parse()
+            
+            articles.append({
+                'url': url,
+                'title': article.title,
+                'text': article.text,
+                'authors': article.authors,
+                'publish_date': article.publish_date,
+                'source': url.split('/')[2]  # Extract domain
+            })
+            time.sleep(1)  # Be respectful to servers
+        except Exception as e:
+            print(f"Failed to extract {url}: {e}")
+    
+    return pd.DataFrame(articles)
+
+def clean_text(text: str) -> str:
+    """Clean text by removing extra whitespace and special characters"""
+    # Remove extra whitespace, special characters
+    text = re.sub(r'\s+', ' ', text)
+    text = re.sub(r'[^\w\s.,!?-]', '', text)
+    return text.strip()
+
+def chunk_text(text: str, chunk_size: int = 1000, overlap: int = 200) -> List[str]:
+    """Split text into overlapping chunks"""
+    words = text.split()
+    chunks = []
+    
+    for i in range(0, len(words), chunk_size - overlap):
+        chunk = ' '.join(words[i:i + chunk_size])
+        chunks.append(chunk)
+    
+    return chunks
+
+def process_articles(urls: List[str], save_path: str = None) -> pd.DataFrame:
+    """Complete pipeline to extract, clean, and process articles"""
+    print(f"Extracting text from {len(urls)} articles...")
+    
+    # Extract articles
+    df = extract_article_text(urls)
+    
+    # Clean text
+    df['cleaned_text'] = df['text'].apply(clean_text)
+    
+    # Create chunks for each article
+    df['text_chunks'] = df['cleaned_text'].apply(
+        lambda x: chunk_text(x) if pd.notna(x) else []
+    )
+    
+    # Save if path provided
+    if save_path:
+        df.to_csv(save_path, index=False)
+        print(f"Results saved to {save_path}")
+    
+    return df
+
+if __name__ == "__main__":
+    # Example usage
+    sample_urls = [
+        "https://example.com/article1",
+        "https://example.com/article2"
+    ]
+    
+    # Process articles
+    # df = process_articles(sample_urls, "extracted_articles.csv")
+    # print(f"Extracted {len(df)} articles")
+    
+    print("Article extractor ready! Use process_articles() with your URLs.") 

requirements.txt

@@ -2,11 +2,20 @@ opencv-python-headless
 yt-dlp==2025.05.22
 ultralytics
 mediapipe
-numpy
-matplotlib
+numpy==1.24.3
+matplotlib==3.8.2
 torch==2.2.0
 torchvision==0.17.0
-openai==1.6.0
+openai==1.12.0
 python-dotenv==1.0.0
 tqdm==4.66.1
-streamlit==1.30.0 
+streamlit==1.29.0
+pandas==2.1.4
+sentence-transformers==2.2.2
+faiss-cpu==1.7.4
+scikit-learn==1.3.2
+plotly==5.17.0
+langchain==0.1.7
+langchain-openai==0.0.6
+langchain-community==0.0.19
+tiktoken==0.5.2