Add Git LFS and update with new logo and improvements

- Setup Git LFS for PNG files to comply with Hugging Face requirements
- Add new horizontal logo (par-ity project horizontal logo.png)
- Improve navigation with simplified sidebar menu
- Enhance RAG system stability and error handling
- Add footer with clickable link to par-ityproject.org
- Remove old logo files (transparent.png, transparent2.png)

app/.gitattributes

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

app/golf_swing_rag.py

@@ -369,81 +369,162 @@ class GolfSwingRAG:
         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")
+        """Create embeddings for all text chunks with enhanced error handling"""
+        try:
+            # 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...")
+                try:
+                    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
+                except Exception as e:
+                    print(f"Failed to load existing embeddings: {e}")
+                    print("Will create new embeddings...")
+            
+            print("Creating embeddings...")
+            if not self.chunks:
+                self.load_and_process_data()
+            
+            # Reduce batch size to prevent memory issues
+            batch_size = 16  # Reduced from 32
+            all_embeddings = []
+            
+            # Add memory management
+            import gc
+            
+            for i in range(0, len(self.chunks), batch_size):
+                try:
+                    batch_chunks = self.chunks[i:i+batch_size]
+                    print(f"Processing batch {i//batch_size + 1}/{(len(self.chunks) + batch_size - 1)//batch_size}")
+                    
+                    # Create embeddings with reduced progress bar output
+                    batch_embeddings = self.embedding_model.encode(
+                        batch_chunks, 
+                        show_progress_bar=True,
+                        convert_to_numpy=True,
+                        normalize_embeddings=True  # Normalize during encoding
+                    )
+                    all_embeddings.append(batch_embeddings)
+                    print(f"Processed {min(i+batch_size, len(self.chunks))}/{len(self.chunks)} chunks")
+                    
+                    # Force garbage collection after each batch
+                    gc.collect()
+                    
+                except Exception as e:
+                    print(f"Error processing batch {i//batch_size + 1}: {e}")
+                    # Continue with next batch instead of failing completely
+                    continue
+            
+            if not all_embeddings:
+                raise Exception("Failed to create any embeddings")
+            
+            # Combine all embeddings
+            print("Combining embeddings...")
+            embeddings = np.vstack(all_embeddings)
+            
+            # Create FAISS index with error handling
+            print("Creating FAISS index...")
+            dimension = embeddings.shape[1]
+            
+            # Use simpler FAISS index that's more stable
+            self.index = faiss.IndexFlatL2(dimension)  # L2 distance instead of inner product
+            
+            # Add embeddings to index
+            self.index.add(embeddings.astype('float32'))
+            
+            # Save embeddings and index
+            print("Saving embeddings...")
+            try:
+                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")
+            except Exception as e:
+                print(f"Failed to save embeddings: {e}")
+                print("Embeddings created but not saved to disk")
+                
+        except Exception as e:
+            print(f"Critical error in create_embeddings: {e}")
+            print("RAG system will operate in limited mode")
+            # Set up minimal fallback
+            self.chunks = self.chunks if hasattr(self, 'chunks') and self.chunks else []
+            self.metadata = self.metadata if hasattr(self, 'metadata') and self.metadata else []
+            self.index = None
     
     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 for similar chunks using semantic similarity with fallback"""
+        try:
+            if self.index is None:
+                print("FAISS index not available, using simple text matching fallback")
+                return self._fallback_search(query, top_k)
+            
+            # Create query embedding
+            query_embedding = self.embedding_model.encode([query], convert_to_numpy=True, normalize_embeddings=True)
+            
+            # Search in FAISS index (L2 distance, so lower scores are better)
+            scores, indices = self.index.search(query_embedding.astype('float32'), top_k)
+            
+            # Convert results to list format
+            results = []
+            for i, (score, idx) in enumerate(zip(scores[0], indices[0])):
+                if idx < len(self.chunks):  # Ensure valid index
+                    results.append({
+                        'chunk': self.chunks[idx],
+                        'metadata': self.metadata[idx],
+                        'similarity_score': 1.0 / (1.0 + score)  # Convert L2 distance to similarity
+                    })
+            
+            return results
+            
+        except Exception as e:
+            print(f"Error in semantic search: {e}")
+            print("Falling back to simple text matching")
+            return self._fallback_search(query, top_k)
+    
+    def _fallback_search(self, query: str, top_k: int = 5) -> List[Dict]:
+        """Simple text-based search fallback when semantic search fails"""
+        if not self.chunks:
+            return []
         
-        # Search in FAISS index
-        scores, indices = self.index.search(query_embedding, top_k)
+        query_lower = query.lower()
+        query_words = set(query_lower.split())
         
-        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)
+        # Score chunks based on word overlap
+        scored_chunks = []
+        for i, chunk in enumerate(self.chunks):
+            chunk_lower = chunk.lower()
+            chunk_words = set(chunk_lower.split())
+            
+            # Calculate simple word overlap score
+            overlap = len(query_words.intersection(chunk_words))
+            if overlap > 0:
+                score = overlap / len(query_words)
+                scored_chunks.append({
+                    'chunk': chunk,
+                    'metadata': self.metadata[i] if i < len(self.metadata) else {},
+                    'similarity_score': score
                 })
         
-        return results
+        # Sort by score and return top_k
+        scored_chunks.sort(key=lambda x: x['similarity_score'], reverse=True)
+        return scored_chunks[:top_k]
     
     def generate_response(self, query: str, context_chunks: List[Dict]) -> str:
         """Generate response using OpenAI API with context"""

app/streamlit_app.py

@@ -121,9 +121,11 @@ st.markdown("""
 
 @st.cache_resource
 def load_rag_system():
-    """Load and initialize the RAG system (cached for performance)"""
+    """Load and initialize the RAG system (cached for performance) with enhanced error handling"""
     if not RAG_AVAILABLE:
+        st.warning("RAG system not available - missing dependencies")
         return None
+    
     try:
         print("=== RAG System Loading Debug ===")
         with st.spinner("Loading golf swing knowledge base..."):
@@ -135,19 +137,30 @@ def load_rag_system():
             rag.load_and_process_data()
             print("✓ Data loaded and processed successfully")
             
-            print("Creating embeddings...")
-            rag.create_embeddings()
-            print("✓ Embeddings created successfully")
+            print("Creating embeddings (this may take a moment)...")
+            try:
+                rag.create_embeddings()
+                if hasattr(rag, 'index') and rag.index is not None:
+                    print("✓ Embeddings created successfully with FAISS")
+                    st.success("🎯 RAG system loaded with semantic search capabilities")
+                else:
+                    print("⚠ Embeddings creation had issues, but fallback search available")
+                    st.warning("⚠️ RAG system loaded with basic search (semantic search unavailable)")
+            except Exception as embedding_error:
+                print(f"⚠ Embedding creation failed: {embedding_error}")
+                print("RAG will use fallback search methods")
+                st.warning("⚠️ RAG system loaded with basic search only")
             
-        print("✓ RAG system loaded successfully!")
+        print("✓ RAG system initialization completed!")
         print("=== End RAG System Loading Debug ===")
         return rag
+        
     except Exception as e:
-        print(f"✗ Error loading RAG system: {str(e)}")
+        print(f"✗ Critical error loading RAG system: {str(e)}")
         print(f"Error type: {type(e).__name__}")
         import traceback
         print(f"Full traceback: {traceback.format_exc()}")
-        st.error(f"Error loading RAG system: {str(e)}")
+        st.error(f"❌ RAG system failed to load: {str(e)}")
         return None
 
 def display_rag_sources(sources):
@@ -636,14 +649,14 @@ def main():
     """, unsafe_allow_html=True)
     
     # Centered logo at the top
-    col1, col2, col3 = st.columns([1, 2, 1])
+    col1, col2, col3 = st.columns([1, 1, 1])
     
     with col1:
         st.write("")  # Empty space
     
     with col2:
         try:
-            st.image("app/transparent.png", width=400)
+            st.image("app/par-ity project horizontal logo.png", width=850)
         except:
             st.markdown('<div class="main-header"><h1>⛳ Par-ity Project</h1></div>', unsafe_allow_html=True)
     
@@ -651,7 +664,7 @@ def main():
         st.write("")  # Empty space
     
     # Reduce spacing after logo
-    st.markdown('<div style="margin-top: -20px;"></div>', unsafe_allow_html=True)
+    st.markdown('<div style="margin-top: -25px;"></div>', unsafe_allow_html=True)
     
     # Initialize session state for step-based flow
     if 'current_step' not in st.session_state:
@@ -684,113 +697,27 @@ def main():
     enable_gpt = any_service_available
     sample_rate = 1
 
-    # Hamburger menu navigation (appears after Step 3)
+    # Simple sidebar navigation (appears after Step 3)
     if st.session_state.current_step >= 3:
-        # Add hamburger menu CSS and HTML
-        st.markdown("""
-        <style>
-        .hamburger-menu {
-            position: fixed;
-            top: 20px;
-            left: 20px;
-            z-index: 1000;
-            background: #0B3B0B;
-            color: white;
-            border: none;
-            border-radius: 8px;
-            padding: 10px;
-            font-size: 18px;
-            cursor: pointer;
-            box-shadow: 0 2px 8px rgba(11, 59, 11, 0.3);
-        }
-        
-        .hamburger-menu:hover {
-            background: #4CAF50;
-        }
-        
-        .menu-content {
-            position: fixed;
-            top: 60px;
-            left: 20px;
-            background: rgba(255, 255, 255, 0.95);
-            border: 2px solid #4CAF50;
-            border-radius: 10px;
-            padding: 15px;
-            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
-            z-index: 999;
-            min-width: 180px;
-            backdrop-filter: blur(10px);
-        }
-        
-        .menu-hidden {
-            display: none;
-        }
-        </style>
-        
-        <div class="hamburger-menu" onclick="toggleMenu()">
-            ☰
-        </div>
-        
-        <div id="menu-content" class="menu-content menu-hidden">
-            <h4 style="color: #0B3B0B; margin: 0 0 10px 0;">Navigation</h4>
-        </div>
-        
-        <script>
-        function toggleMenu() {
-            const menu = document.getElementById('menu-content');
-            menu.classList.toggle('menu-hidden');
-        }
-        
-        // Close menu when clicking outside
-        document.addEventListener('click', function(event) {
-            const menu = document.getElementById('menu-content');
-            const hamburger = document.querySelector('.hamburger-menu');
-            if (!menu.contains(event.target) && !hamburger.contains(event.target)) {
-                menu.classList.add('menu-hidden');
-            }
-        });
-        </script>
-        """, unsafe_allow_html=True)
-        
-        # Navigation menu in main content (only show when menu should be visible)
-        if 'show_menu' not in st.session_state:
-            st.session_state.show_menu = False
+        with st.sidebar:
+            st.markdown("### Navigation")
+            st.markdown("---")
             
-        # Menu toggle button
-        col1, col2, col3 = st.columns([1, 8, 1])
-        with col1:
-            if st.button("☰", key="menu_toggle", help="Navigation Menu"):
-                st.session_state.show_menu = not st.session_state.show_menu
+            if st.button("🎯 Generate Improvements", key="nav_improvements", use_container_width=True):
+                st.session_state.current_step = 4
+                st.rerun()
+                    
+            if st.button("💬 Ask Questions", key="nav_chatbot", use_container_width=True):
+                st.session_state.current_step = 5
+                st.rerun()
+            
+            if st.button("🔄 Start Over", key="nav_start_over", use_container_width=True):
+                # Reset all session state
+                for key in list(st.session_state.keys()):
+                    if key != 'session_initialized':
+                        del st.session_state[key]
+                st.session_state.current_step = 1
                 st.rerun()
-        
-        # Show menu content if toggled
-        if st.session_state.show_menu:
-            with st.container():
-                st.markdown("#### 🧭 Navigation")
-                
-                nav_col1, nav_col2 = st.columns(2)
-                
-                with nav_col1:
-                    if st.button("🎯 Improvements", key="nav_improvements", use_container_width=True):
-                        st.session_state.current_step = 4
-                        st.session_state.show_menu = False
-                        st.rerun()
-                        
-                with nav_col2:
-                    if st.button("💬 Chatbot", key="nav_chatbot", use_container_width=True):
-                        st.session_state.current_step = 5
-                        st.session_state.show_menu = False
-                        st.rerun()
-                
-                if st.button("🔄 Start Over", key="nav_start_over", use_container_width=True):
-                    # Reset all session state
-                    for key in list(st.session_state.keys()):
-                        if key != 'session_initialized':
-                            del st.session_state[key]
-                    st.session_state.current_step = 1
-                    st.rerun()
-                
-                st.markdown("---")
 
     # Step-based content rendering
     if st.session_state.current_step == 1:
@@ -803,6 +730,15 @@ def main():
         render_step_4()
     elif st.session_state.current_step == 5:
         render_step_5()
+    
+    st.markdown("---")
+    # Footer with website link
+    st.markdown(
+        '<div style="text-align: center; margin-top: 5px; margin-bottom: 1px;">'
+        '<a href="https://par-ityproject.org" target="_blank" style="color: #0B3B0B; text-decoration: none; font-size: 14px;">par-ityproject.org</a>'
+        '</div>',
+        unsafe_allow_html=True
+    )
 
 def render_step_1():
     """Step 1: Upload Video"""
@@ -814,11 +750,13 @@ def render_step_1():
     
     with col1:
         st.markdown("#### YouTube URL")
-        youtube_url = st.text_input("Enter YouTube URL of golf swing:", key="youtube_input")
+        st.markdown('<style>div[data-testid="stTextInput"] > label {display: none;}</style>', unsafe_allow_html=True)
+        youtube_url = st.text_input("", key="youtube_input", label_visibility="collapsed")
     
     with col2:
         st.markdown("#### Upload Video File")
-        uploaded_file = st.file_uploader("Upload a golf swing video", type=["mp4", "mov", "avi"], key="video_upload")
+        st.markdown('<style>div[data-testid="stFileUploader"] > label {display: none;}</style>', unsafe_allow_html=True)
+        uploaded_file = st.file_uploader("", type=["mp4", "mov", "avi"], key="video_upload", label_visibility="collapsed")
     
     # Analyze button
     if st.button("🏌️ Start Analysis", key="start_analysis", use_container_width=True):
@@ -859,7 +797,6 @@ def render_step_2():
     st.markdown('<h2 style="color: #0B3B0B; font-family: Georgia, serif;">Step 2: Analyzing Video and Pose</h2>', unsafe_allow_html=True)
     
     st.markdown("🔄 **Processing your swing video...**")
-    st.markdown("Please wait while we analyze your golf swing.")
     
     video_path = st.session_state.analysis_data.get('video_path')
     
@@ -943,7 +880,7 @@ def render_step_3():
         with col1:
             st.markdown("""
             <div style="text-align: center; padding: 20px; border: 2px solid #4CAF50; border-radius: 15px; margin: 10px 0;">
-                <h3 style="color: #0B3B0B;">🎯 AI-Powered Improvements</h3>
+                <h3 style="color: #0B3B0B;">🎯 Generate Improvements</h3>
                 <p>Get personalized swing analysis with specific tips for improvement</p>
             </div>
             """, unsafe_allow_html=True)
@@ -955,7 +892,7 @@ def render_step_3():
         with col2:
             st.markdown("""
             <div style="text-align: center; padding: 20px; border: 2px solid #4CAF50; border-radius: 15px; margin: 10px 0;">
-                <h3 style="color: #0B3B0B;">💬 Golf Expert Q&A</h3>
+                <h3 style="color: #0B3B0B;">💬 Ask Questions</h3>
                 <p>Ask specific questions about golf swing technique from our knowledge base</p>
             </div>
             """, unsafe_allow_html=True)