diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -44,9 +44,10 @@ st.set_page_config(
     layout="wide"
 )
 
-# Original CSS
+# Custom CSS
 st.markdown("""
 <style>
+    /* Original CSS */
     .main-header {
         font-size: 2.5rem;
         color: #4285F4;
@@ -82,6 +83,8 @@ st.markdown("""
         border-radius: 4px;
         background-color: #f5eee9;
     }
+    
+    /* New chatbot styling */
     .chat-container {
         background-color: white;
         border-radius: 16px;
@@ -160,25 +163,32 @@ st.markdown("""
 """, unsafe_allow_html=True)
 
 def analyze_image(image, analysis_types, confidence_threshold=0.5):
+    """Analyze image with selected analysis types and confidence filtering"""
+    # Convert uploaded image to bytes
     if image is None:
         return None, {}, {}, "", {}
     
     img_byte_arr = io.BytesIO()
     image.save(img_byte_arr, format='PNG')
     content = img_byte_arr.getvalue()
+
+    # Create vision image object
     vision_image = vision.Image(content=content)
-    
+
+    # Perform detection based on selected types
     labels_data = {}
     objects_data = {}
     text_content = ""
-    colors_data = {}
-    text_language = ""
+    colors_data = {}  # New: store dominant colors
+    text_language = "" # New: store detected language
     
     img_with_boxes = image.copy()
     draw = ImageDraw.Draw(img_with_boxes)
     
+    # Extract color information regardless of analysis types
     if "Visual Attributes" in analysis_types:
         image_properties = client.image_properties(image=vision_image).image_properties_annotation
+        # Get top 5 dominant colors with scores
         colors_data = {
             f"Color #{i+1}": {
                 "rgb": (int(color.color.red), int(color.color.green), int(color.color.blue)),
@@ -189,16 +199,21 @@ def analyze_image(image, analysis_types, confidence_threshold=0.5):
     
     if "Labels" in analysis_types:
         labels = client.label_detection(image=vision_image)
+        # Apply confidence threshold
         labels_data = {label.description: round(label.score * 100) 
                       for label in labels.label_annotations 
                       if label.score >= confidence_threshold}
     
     if "Objects" in analysis_types:
         objects = client.object_localization(image=vision_image)
+        # Apply confidence threshold
         filtered_objects = [obj for obj in objects.localized_object_annotations 
                            if obj.score >= confidence_threshold]
+        
         objects_data = {obj.name: round(obj.score * 100) 
                        for obj in filtered_objects}
+        
+        # Draw object boundaries
         for obj in filtered_objects:
             box = [(vertex.x * image.width, vertex.y * image.height)
                   for vertex in obj.bounding_poly.normalized_vertices]
@@ -211,38 +226,52 @@ def analyze_image(image, analysis_types, confidence_threshold=0.5):
         text = client.text_detection(image=vision_image)
         if text.text_annotations:
             text_content = text.text_annotations[0].description
+            
+            # New: Detect language if text is found
             if text_content:
                 try:
+                    # Get language of text
                     document = vision.types.Document(
                         content=content,
                         type_=vision.types.Document.Type.GENERAL_DOCUMENT
                     )
                     response = client.document_text_detection(image=vision_image)
-                    if response.text_annotations and response.pages and response.pages[0].property.detected_languages:
-                        lang = response.pages[0].property.detected_languages[0]
-                        text_language = f"{lang.language_code} ({round(lang.confidence * 100)}%)"
-                except Exception:
+                    if response.text_annotations:
+                        # Get the language code from the first page
+                        if response.pages and response.pages[0].property.detected_languages:
+                            lang = response.pages[0].property.detected_languages[0]
+                            text_language = f"{lang.language_code} ({round(lang.confidence * 100)}%)"
+                except Exception as e:
                     text_language = "Detection failed"
-            for text_annot in text.text_annotations[1:]:
+            
+            # Draw text boundaries
+            for text_annot in text.text_annotations[1:]:  # Skip the first one (full text)
                 box = [(vertex.x, vertex.y) for vertex in text_annot.bounding_poly.vertices]
                 draw.polygon(box, outline='blue', width=1)
 
     if "Face Detection" in analysis_types:
         faces = client.face_detection(image=vision_image)
+        # Apply confidence threshold - filter by detection confidence
         filtered_faces = [face for face in faces.face_annotations 
                          if face.detection_confidence >= confidence_threshold]
+        
         for face in filtered_faces:
             vertices = face.bounding_poly.vertices
             box = [(vertex.x, vertex.y) for vertex in vertices]
             draw.polygon(box, outline='green', width=2)
+            
+            # Draw facial landmarks
             for landmark in face.landmarks:
                 px = landmark.position.x
                 py = landmark.position.y
                 draw.ellipse((px-2, py-2, px+2, py+2), fill='yellow')
 
+    # Return extended results
     return img_with_boxes, labels_data, objects_data, text_content, colors_data, text_language
 
 def display_results(annotated_img, labels, objects, text, colors=None, text_language=None):
+    """Display analysis results in a clean format with enhanced features"""
+    # Store results in session state for chatbot context
     st.session_state.analysis_results = {
         "labels": labels,
         "objects": objects,
@@ -251,6 +280,8 @@ def display_results(annotated_img, labels, objects, text, colors=None, text_lang
         "text_language": text_language if text_language else "",
         "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
     }
+    
+    # Update vectorstore with new results
     update_vectorstore_with_results(st.session_state.analysis_results)
     
     col1, col2 = st.columns([3, 2])
@@ -261,6 +292,8 @@ def display_results(annotated_img, labels, objects, text, colors=None, text_lang
     
     with col2:
         st.markdown('<div class="subheader">Analysis Results</div>', unsafe_allow_html=True)
+        
+        # Labels tab
         if labels:
             st.markdown("##### 🏷️ Labels Detected")
             st.markdown('<div class="result-container">', unsafe_allow_html=True)
@@ -268,6 +301,7 @@ def display_results(annotated_img, labels, objects, text, colors=None, text_lang
                 st.markdown(f'<div class="label-item">{label}: {confidence}%</div>', unsafe_allow_html=True)
             st.markdown('</div>', unsafe_allow_html=True)
         
+        # Objects tab
         if objects:
             st.markdown("##### 📦 Objects Detected")
             st.markdown('<div class="result-container">', unsafe_allow_html=True)
@@ -275,6 +309,7 @@ def display_results(annotated_img, labels, objects, text, colors=None, text_lang
                 st.markdown(f'<div class="object-item">{obj}: {confidence}%</div>', unsafe_allow_html=True)
             st.markdown('</div>', unsafe_allow_html=True)
         
+        # Text tab
         if text:
             st.markdown("##### 📝 Text Detected")
             if text_language:
@@ -283,12 +318,17 @@ def display_results(annotated_img, labels, objects, text, colors=None, text_lang
             st.markdown(f'<div class="text-item">{text}</div>', unsafe_allow_html=True)
             st.markdown('</div>', unsafe_allow_html=True)
             
+        # Color analysis tab (new)
         if colors:
             st.markdown("##### 🎨 Dominant Colors")
             st.markdown('<div class="result-container">', unsafe_allow_html=True)
+            
+            # Create color swatches
             for color_name, color_data in colors.items():
                 rgb = color_data["rgb"]
                 hex_color = f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
+                
+                # Display color swatch with info
                 st.markdown(f"""
                 <div style="display:flex; align-items:center; margin-bottom:10px;">
                     <div style="background-color:{hex_color}; width:50px; height:30px; margin-right:15px; border:1px solid #ddd;"></div>
@@ -298,8 +338,10 @@ def display_results(annotated_img, labels, objects, text, colors=None, text_lang
                     </div>
                 </div>
                 """, unsafe_allow_html=True)
+            
             st.markdown('</div>', unsafe_allow_html=True)
     
+    # Add Download Summary Image button
     summary_img = create_summary_image(annotated_img, labels, objects, text, colors)
     buf = io.BytesIO()
     summary_img.save(buf, format="JPEG", quality=90)
@@ -314,12 +356,20 @@ def display_results(annotated_img, labels, objects, text, colors=None, text_lang
     )
 
 def create_summary_image(annotated_img, labels, objects, text, colors=None):
+    """Create a downloadable summary image with analysis results"""
+    # Create a new image with space for results
     img_width, img_height = annotated_img.size
-    result_height = 400
+    # Make room for text results (adjust height based on content)
+    result_height = 400  # Space for results
     summary_img = Image.new('RGB', (img_width, img_height + result_height), color=(255, 255, 255))
+    
+    # Paste the annotated image at the top
     summary_img.paste(annotated_img, (0, 0))
+    
+    # Create a drawing object
     draw = ImageDraw.Draw(summary_img)
     
+    # Try to get a font - use default if not available
     try:
         font = ImageFont.truetype("arial.ttf", 16)
         title_font = ImageFont.truetype("arial.ttf", 20)
@@ -327,37 +377,53 @@ def create_summary_image(annotated_img, labels, objects, text, colors=None):
         font = ImageFont.load_default()
         title_font = ImageFont.load_default()
     
+    # Draw title - using dark blue color
     draw.text((20, img_height + 20), "Cosmick Cloud AI Analyzer Results", fill=(0, 0, 139), font=title_font)
+    
+    # Draw divider line
     draw.line([(0, img_height + 50), (img_width, img_height + 50)], fill=(200, 200, 200), width=2)
+    
+    # Current Y position for drawing text
     y_pos = img_height + 60
     
+    # Draw labels
     if labels:
         draw.text((20, y_pos), "🏷️ Labels Detected:", fill=(0, 0, 0), font=title_font)
         y_pos += 30
+        
         for i, (label, confidence) in enumerate(sorted(labels.items(), key=lambda x: x[1], reverse=True)):
-            if i < 8:
+            if i < 8:  # Limit to top 8 labels to avoid overcrowding
                 draw.text((40, y_pos), f"{label}: {confidence}%", fill=(0, 100, 0), font=font)
                 y_pos += 25
     
+    # Draw a column divider
     mid_point = img_width // 2
     draw.line([(mid_point - 20, img_height + 60), (mid_point - 20, img_height + result_height - 20)], 
               fill=(200, 200, 200), width=1)
+    
+    # Reset Y position for second column
     y_pos = img_height + 60
     
+    # Draw objects in second column
     if objects:
         draw.text((mid_point, y_pos), "📦 Objects Detected:", fill=(0, 0, 0), font=title_font)
         y_pos += 30
+        
         for i, (obj, confidence) in enumerate(sorted(objects.items(), key=lambda x: x[1], reverse=True)):
-            if i < 8:
+            if i < 8:  # Limit to top 8 objects
                 draw.text((mid_point + 20, y_pos), f"{obj}: {confidence}%", fill=(0, 0, 128), font=font)
                 y_pos += 25
     
+    # Add text detection summary at the bottom with improved visibility
     if text:
         bottom_y = img_height + result_height - 80
         draw.text((20, bottom_y), "📝 Text Detected:", fill=(0, 0, 0), font=title_font)
+        # Truncate text if too long
         display_text = text if len(text) < 100 else text[:97] + "..."
+        # Change text color to dark red for better visibility
         draw.text((20, bottom_y + 30), display_text, fill=(139, 0, 0), font=font)
     
+    # Add timestamp with darker color
     timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
     draw.text((img_width - 200, img_height + result_height - 30), 
               f"Generated: {timestamp}", fill=(50, 50, 50), font=font)
@@ -365,12 +431,14 @@ def create_summary_image(annotated_img, labels, objects, text, colors=None):
     return summary_img
 
 class VideoProcessor(VideoProcessorBase):
+    """Process video frames for real-time analysis"""
+    
     def __init__(self, analysis_types: List[str]):
         self.analysis_types = analysis_types
         self.frame_counter = 0
-        self.process_every_n_frames = 5
-        self.vision_client = client
-        self.last_results = {}
+        self.process_every_n_frames = 5  # Process every 5th frame
+        self.vision_client = client  # Store client reference
+        self.last_results = {}  # Cache results between processed frames
         self.last_processed_time = time.time()
         self.processing_active = True
         
@@ -378,23 +446,31 @@ class VideoProcessor(VideoProcessorBase):
         img = frame.to_ndarray(format="bgr24")
         self.frame_counter += 1
         
+        # Add status display on all frames
         cv2.putText(img, 
                    f"Vision AI: {'Active' if self.processing_active else 'Paused'}", 
                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
         
+        # Process at regular intervals
         current_time = time.time()
-        if current_time - self.last_processed_time > 1.0 and self.processing_active:
+        if current_time - self.last_processed_time > 1.0 and self.processing_active:  # Process max once per second
             self.last_processed_time = current_time
+            
             try:
+                # Convert to PIL Image for Vision API
                 pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+                
+                # Process with Vision API
                 img_byte_arr = io.BytesIO()
                 pil_img.save(img_byte_arr, format='PNG')
                 content = img_byte_arr.getvalue()
                 vision_image = vision.Image(content=content)
                 
+                # Update status text
                 cv2.putText(img, "Processing...", (10, 60), 
                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
                 
+                # Process according to selected analysis types
                 if "Objects" in self.analysis_types:
                     objects = self.vision_client.object_localization(image=vision_image)
                     self.last_results["objects"] = objects.localized_object_annotations
@@ -412,34 +488,48 @@ class VideoProcessor(VideoProcessorBase):
                 cv2.putText(img, f"Error: {error_msg}", (10, 60), 
                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
         
-        if "objects" in self.last_results and "Objects" in self.analysis_types:
-            for obj in self.last_results["objects"]:
-                box = [(vertex.x * img.shape[1], vertex.y * img.shape[0])
-                      for vertex in obj.bounding_poly.normalized_vertices]
-                box = np.array(box, np.int32).reshape((-1, 1, 2))
-                cv2.polylines(img, [box], True, (0, 255, 0), 2)
-                cv2.putText(img, f"{obj.name}: {int(obj.score * 100)}%", 
-                           (int(box[0][0][0]), int(box[0][0][1]) - 10),
-                           cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
-        
-        if "faces" in self.last_results and "Face Detection" in self.analysis_types:
-            for face in self.last_results["faces"]:
-                vertices = face.bounding_poly.vertices
-                points = [(vertex.x, vertex.y) for vertex in vertices]
-                pts = np.array(points, np.int32).reshape((-1, 1, 2))
-                cv2.polylines(img, [pts], True, (0, 0, 255), 2)
-                for landmark in face.landmarks:
-                    px = int(landmark.position.x)
-                    py = int(landmark.position.y)
-                    cv2.circle(img, (px, py), 2, (255, 255, 0), -1)
-        
-        if "text" in self.last_results and "Text" in self.analysis_types:
-            if len(self.last_results["text"]) > 1:
-                for text_annot in self.last_results["text"][1:]:
-                    box = [(vertex.x, vertex.y) for vertex in text_annot.bounding_poly.vertices]
-                    pts = np.array(box, np.int32).reshape((-1, 1, 2))
-                    cv2.polylines(img, [pts], True, (255, 0, 0), 1)
+        # Always draw the cached results for smooth display
+        try:
+            # Draw object detections
+            if "objects" in self.last_results and "Objects" in self.analysis_types:
+                for obj in self.last_results["objects"]:
+                    box = [(vertex.x * img.shape[1], vertex.y * img.shape[0])
+                          for vertex in obj.bounding_poly.normalized_vertices]
+                    box = np.array(box, np.int32).reshape((-1, 1, 2))
+                    cv2.polylines(img, [box], True, (0, 255, 0), 2)
+                    # Add label
+                    cv2.putText(img, f"{obj.name}: {int(obj.score * 100)}%", 
+                               (int(box[0][0][0]), int(box[0][0][1]) - 10),
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+            
+            # Draw face detections
+            if "faces" in self.last_results and "Face Detection" in self.analysis_types:
+                for face in self.last_results["faces"]:
+                    vertices = face.bounding_poly.vertices
+                    points = [(vertex.x, vertex.y) for vertex in vertices]
+                    pts = np.array(points, np.int32).reshape((-1, 1, 2))
+                    cv2.polylines(img, [pts], True, (0, 0, 255), 2)
+                    
+                    # Draw landmarks
+                    for landmark in face.landmarks:
+                        px = int(landmark.position.x)
+                        py = int(landmark.position.y)
+                        cv2.circle(img, (px, py), 2, (255, 255, 0), -1)
+            
+            # Draw text detections
+            if "text" in self.last_results and "Text" in self.analysis_types:
+                if len(self.last_results["text"]) > 1:  # Skip the first one (full text)
+                    for text_annot in self.last_results["text"][1:]:
+                        box = [(vertex.x, vertex.y) for vertex in text_annot.bounding_poly.vertices]
+                        pts = np.array(box, np.int32).reshape((-1, 1, 2))
+                        cv2.polylines(img, [pts], True, (255, 0, 0), 1)
+                
+        except Exception as e:
+            error_msg = str(e)[:50]
+            cv2.putText(img, f"Display Error: {error_msg}", (10, 90), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
         
+        # Add which analysis types are active
         y_pos = img.shape[0] - 10
         cv2.putText(img, f"Analyzing: {', '.join(self.analysis_types)}", 
                    (10, y_pos), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
@@ -447,26 +537,46 @@ class VideoProcessor(VideoProcessorBase):
         return av.VideoFrame.from_ndarray(img, format="bgr24")
 
 def analyze_document(file_content, processor_id, location="us"):
+    """Analyze document using Document AI"""
+    # Create Document AI client
     client = documentai.DocumentProcessorServiceClient(credentials=credentials)
+    
+    # The full resource name of the processor
     processor_name = f"projects/{credentials.project_id}/locations/{location}/processors/{processor_id}"
     
+    # Determine the mime type based on input file type
     if file_content[:4] == b'%PDF':
         mime_type = "application/pdf"
-    else:
+    else:  # Default to image for other types
         mime_type = "image/jpeg"
     
+    # Create the request
     raw_document = documentai.RawDocument(content=file_content, mime_type=mime_type)
-    request = documentai.ProcessRequest(name=processor_name, raw_document=raw_document)
+    
+    # Updated API request format
+    request = documentai.ProcessRequest(
+        name=processor_name,
+        raw_document=raw_document
+    )
+    
+    # Process the document
     result = client.process_document(request=request)
     document = result.document
     
+    # Extract text, entities, etc.
     text = document.text
-    entities = {entity.type_: entity.mention_text for entity in document.entities}
+    entities = {}
+    
+    # Extract entities and their values
+    for entity in document.entities:
+        entities[entity.type_] = entity.mention_text
     
+    # Extract table data if available
     tables = []
     for page in document.pages:
         for table in page.tables:
             table_data = []
+            # Get header row if available
             headers = []
             if hasattr(table, 'header_rows') and table.header_rows:
                 for cell in table.header_rows[0].cells:
@@ -475,6 +585,8 @@ def analyze_document(file_content, processor_id, location="us"):
                         headers.append(text[segment.start_index:segment.end_index])
                     else:
                         headers.append("")
+            
+            # Get data rows
             for row in table.body_rows:
                 row_data = []
                 for cell in row.cells:
@@ -485,10 +597,14 @@ def analyze_document(file_content, processor_id, location="us"):
                     else:
                         row_data.append("")
                 table_data.append(row_data)
+            
+            # If no header found, create generic column names
             if not headers and table_data:
                 headers = [f"Column_{i+1}" for i in range(len(table_data[0]))]
+                
             tables.append({"headers": headers, "data": table_data})
     
+    # Store results in session state for chatbot context
     results = (text, entities, tables)
     st.session_state.analysis_results = {
         "text": text,
@@ -496,11 +612,18 @@ def analyze_document(file_content, processor_id, location="us"):
         "tables": tables,
         "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
     }
+    
+    # Update vectorstore with new results
     update_vectorstore_with_results(results)
+    
     return text, entities, tables
 
 def create_bigquery_table(dataset_id, table_id, schema=None):
+    """Create a BigQuery table if it doesn't exist"""
+    # Create client
     bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
+    
+    # Create dataset if it doesn't exist
     dataset_ref = bq_client.dataset(dataset_id)
     try:
         bq_client.get_dataset(dataset_ref)
@@ -510,178 +633,263 @@ def create_bigquery_table(dataset_id, table_id, schema=None):
         bq_client.create_dataset(dataset)
         st.info(f"Dataset '{dataset_id}' created.")
     
+    # Create table reference
     table_ref = dataset_ref.table(table_id)
+    
+    # Check if table exists
     try:
         bq_client.get_table(table_ref)
         st.info(f"Table '{table_id}' already exists.")
         return table_ref
     except NotFound:
+        # Create the table with schema if provided
         if schema:
             table = bigquery.Table(table_ref, schema=schema)
         else:
             table = bigquery.Table(table_ref)
+        
         bq_client.create_table(table)
         st.info(f"Table '{table_id}' created.")
         return table_ref
 
 def upload_csv_to_bigquery(file, dataset_id, table_id, append=False):
+    """Upload a CSV file to BigQuery"""
+    # Create client
     bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
+    
+    # First, ensure dataset and table exist
     table_ref = create_bigquery_table(dataset_id, table_id)
     
+    # Create a temporary file
     with tempfile.NamedTemporaryFile(delete=False, suffix='.csv') as temp_file:
         temp_file.write(file.getvalue())
         temp_file_path = temp_file.name
     
+    # Configure the load job
     job_config = bigquery.LoadJobConfig(
         source_format=bigquery.SourceFormat.CSV,
-        skip_leading_rows=1,
-        autodetect=True,
+        skip_leading_rows=1,  # Skip header row
+        autodetect=True,  # Auto-detect schema
     )
+    
     if append:
         job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND
     else:
         job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
     
+    # Load the file
     with open(temp_file_path, "rb") as source_file:
-        job = bq_client.load_table_from_file(source_file, table_ref, job_config=job_config)
+        job = bq_client.load_table_from_file(
+            source_file, table_ref, job_config=job_config
+        )
     
+    # Wait for the job to complete
     job.result()
+    
+    # Clean up the temp file
     os.unlink(temp_file_path)
     
+    # Get the table
     table = bq_client.get_table(table_ref)
+    
     result = {
         "num_rows": table.num_rows,
         "size_bytes": table.num_bytes,
         "schema": [field.name for field in table.schema]
     }
+    
+    # Store results in session state for chatbot context
     st.session_state.analysis_results = {
         "data_source": f"{dataset_id}.{table_id}",
         "num_rows": table.num_rows,
         "schema": [field.name for field in table.schema],
         "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
     }
+    
+    # Update vectorstore with new results
     update_vectorstore_with_results(result)
+    
     return result
 
 def run_bigquery(query):
+    """Run a BigQuery query and return results"""
+    # Create client
     bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
+    
+    # Run the query
     query_job = bq_client.query(query)
+    
+    # Wait for the query to finish
     results = query_job.result()
+    
+    # Convert to dataframe
     df = results.to_dataframe()
+    
+    # Store results in session state for chatbot context
     st.session_state.analysis_results = {
         "query": query,
         "results": df,
         "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
     }
+    
+    # Update vectorstore with new results
     update_vectorstore_with_results(df)
+    
     return df
 
 def list_bigquery_resources():
+    """List all datasets and tables in the project"""
+    # Create client
     bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
+    
+    # Get datasets
     datasets = list(bq_client.list_datasets())
+    
+    # Create a dictionary to store dataset -> tables mapping
     resources = {}
+    
     if datasets:
         for dataset in datasets:
             dataset_id = dataset.dataset_id
+            # Get tables for this dataset
             tables = list(bq_client.list_tables(dataset_id))
+            # Store table names
             resources[dataset_id] = [table.table_id for table in tables]
+    
     return resources
 
 def process_video_file(video_file, analysis_types):
+    """Process an uploaded video file with enhanced Vision AI detection and analytics"""
+    # Create a temporary file to save the uploaded video
     with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
         temp_file.write(video_file.read())
         temp_video_path = temp_file.name
     
+    # Create a temp file for the output video
     output_path = f"{temp_video_path}_processed.mp4"
+    
+    # Open the video file
     cap = cv2.VideoCapture(temp_video_path)
     if not cap.isOpened():
         st.error("Error opening video file")
         os.unlink(temp_video_path)
         return None
     
+    # Get video properties
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     fps = cap.get(cv2.CAP_PROP_FPS)
+    
+    # Calculate max frames for 10-second limit
     max_frames = int(fps * 10)
     total_frames = min(int(cap.get(cv2.CAP_PROP_FRAME_COUNT)), max_frames)
-    output_fps = fps * 0.6
     
+    # Inform user if video is being truncated
     if int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) > max_frames:
         st.info("⚠️ Video is longer than 10 seconds. Only the first 10 seconds will be processed.")
     
+    # Slow down the output video by reducing the fps (60% of original speed)
+    output_fps = fps * 0.6
     st.info(f"Output video will be slowed down to {output_fps:.1f} FPS (60% of original speed) for better visualization.")
     
-    # Try H.264 first, fall back to XVID or MJPG
+    # Create video writer with higher quality settings
     try:
-        fourcc = cv2.VideoWriter_fourcc(*'H264')
-        out = cv2.VideoWriter(output_path, fourcc, output_fps, (width, height), isColor=True)
+        # Try XVID first (widely available)
+        fourcc = cv2.VideoWriter_fourcc(*'XVID')
     except Exception:
+        # If that fails, try Motion JPEG
         try:
-            fourcc = cv2.VideoWriter_fourcc(*'XVID')
-            out = cv2.VideoWriter(output_path, fourcc, output_fps, (width, height), isColor=True)
-        except Exception:
             fourcc = cv2.VideoWriter_fourcc(*'MJPG')
-            out = cv2.VideoWriter(output_path, fourcc, output_fps, (width, height), isColor=True)
+        except Exception:
+            # Last resort - use uncompressed
+            fourcc = cv2.VideoWriter_fourcc(*'DIB ')  # Uncompressed RGB
+    out = cv2.VideoWriter(output_path, fourcc, output_fps, (width, height), isColor=True)
     
+    # Process every Nth frame to reduce API calls but increase from 10 to 5 for more detail
     process_every_n_frames = 5
+    
+    # Create a progress bar
     progress_bar = st.progress(0)
     status_text = st.empty()
     
+    # Enhanced statistics tracking
     detection_stats = {
         "objects": {},
         "faces": 0,
         "text_blocks": 0,
         "labels": {},
-        "object_tracking": {},
-        "activity_metrics": [],
-        "scene_changes": []
+        # New advanced tracking
+        "object_tracking": {},  # Track object appearances by frame
+        "activity_metrics": [],  # Track frame-to-frame differences
+        "scene_changes": []     # Track major scene transitions
     }
+    
+    # For scene change detection
     previous_frame_gray = None
-    scene_change_threshold = 40.0
+    scene_change_threshold = 40.0  # Threshold for scene change detection
     
     try:
         frame_count = 0
-        while frame_count < max_frames:
+        while frame_count < max_frames:  # Limit to 10 seconds
             ret, frame = cap.read()
             if not ret:
                 break
                 
             frame_count += 1
+            
+            # Update progress
             progress = int(frame_count / total_frames * 100)
             progress_bar.progress(progress)
             status_text.text(f"Processing frame {frame_count}/{total_frames} ({progress}%) - {frame_count/fps:.1f}s of 10s")
             
+            # Add timestamp to frame
             cv2.putText(frame, f"Time: {frame_count/fps:.2f}s", 
                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
             
+            # Activity detection and scene change detection
             current_frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
             current_frame_gray = cv2.GaussianBlur(current_frame_gray, (21, 21), 0)
+                
             if previous_frame_gray is not None:
+                # Calculate frame difference for activity detection
                 frame_diff = cv2.absdiff(current_frame_gray, previous_frame_gray)
                 activity_level = np.mean(frame_diff)
                 detection_stats["activity_metrics"].append((frame_count/fps, activity_level))
+                
+                # Scene change detection
                 if activity_level > scene_change_threshold:
                     detection_stats["scene_changes"].append(frame_count/fps)
+                    # Mark scene change on frame
                     cv2.putText(frame, "SCENE CHANGE", 
                               (width // 2 - 100, 50), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 255), 2)
+            
             previous_frame_gray = current_frame_gray
             
+            # Process frames with Vision API
             if frame_count % process_every_n_frames == 0:
                 try:
+                    # Convert OpenCV frame to PIL Image for Vision API
                     pil_img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+                    
+                    # Create vision image
                     img_byte_arr = io.BytesIO()
                     pil_img.save(img_byte_arr, format='PNG')
                     content = img_byte_arr.getvalue()
                     vision_image = vision.Image(content=content)
                     
+                    # Apply analysis based on selected types with enhanced detail
                     if "Objects" in analysis_types:
                         objects = client.object_localization(image=vision_image)
+                        # Draw boxes around detected objects with enhanced info
                         for obj in objects.localized_object_annotations:
                             obj_name = obj.name
+                            # Update basic stats
                             if obj_name in detection_stats["objects"]:
                                 detection_stats["objects"][obj_name] += 1
                             else:
                                 detection_stats["objects"][obj_name] = 1
+                                
+                            # Enhanced object tracking
                             timestamp = frame_count/fps
                             if obj_name not in detection_stats["object_tracking"]:
                                 detection_stats["object_tracking"][obj_name] = {
@@ -696,105 +904,167 @@ def process_video_file(video_file, analysis_types):
                                 tracking["last_seen"] = timestamp
                                 tracking["timestamps"].append(timestamp)
                             
+                            # Calculate box coordinates
                             box = [(vertex.x * frame.shape[1], vertex.y * frame.shape[0])
                                   for vertex in obj.bounding_poly.normalized_vertices]
                             box = np.array(box, np.int32).reshape((-1, 1, 2))
+                            
+                            # Draw more noticeable box with thicker lines
                             cv2.polylines(frame, [box], True, (0, 255, 0), 3)
+                            
+                            # Calculate box size for better placement of labels
                             x_min = min([p[0][0] for p in box])
                             y_min = min([p[0][1] for p in box])
                             confidence = int(obj.score * 100)
+                            
+                            # Enhanced label with confidence and border - larger text for visibility
                             label_text = f"{obj.name}: {confidence}%"
                             text_size = cv2.getTextSize(label_text, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)[0]
+                            
+                            # Larger background rectangle for text visibility
                             cv2.rectangle(frame, 
                                         (int(x_min), int(y_min) - text_size[1] - 10),
                                         (int(x_min) + text_size[0] + 10, int(y_min)),
                                         (0, 0, 0), -1)
+                            
+                            # Draw the label text with larger font
                             cv2.putText(frame, label_text, 
                                       (int(x_min) + 5, int(y_min) - 5),
                                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
                     
                     if "Face Detection" in analysis_types:
                         faces = client.face_detection(image=vision_image)
+                        # Track statistics
                         detection_stats["faces"] += len(faces.face_annotations)
+                        
                         for face in faces.face_annotations:
                             vertices = face.bounding_poly.vertices
                             points = [(vertex.x, vertex.y) for vertex in vertices]
+                            # Draw face box with thicker lines
                             pts = np.array(points, np.int32).reshape((-1, 1, 2))
                             cv2.polylines(frame, [pts], True, (0, 0, 255), 3)
+                            
+                            # Enhanced face info
                             emotions = []
-                            if face.joy_likelihood >= 3: emotions.append("Joy")
-                            if face.anger_likelihood >= 3: emotions.append("Anger")
-                            if face.surprise_likelihood >= 3: emotions.append("Surprise")
-                            if face.sorrow_likelihood >= 3: emotions.append("Sorrow")
+                            if face.joy_likelihood >= 3:
+                                emotions.append("Joy")
+                            if face.anger_likelihood >= 3:
+                                emotions.append("Anger")
+                            if face.surprise_likelihood >= 3:
+                                emotions.append("Surprise")
+                            if face.sorrow_likelihood >= 3:
+                                emotions.append("Sorrow")
+                                
                             emotion_text = ", ".join(emotions) if emotions else "Neutral"
                             x_min = min([p[0] for p in points])
                             y_min = min([p[1] for p in points])
+                            
+                            # Add detailed emotion text
                             cv2.putText(frame, emotion_text, 
                                       (int(x_min), int(y_min) - 10),
                                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+                            
+                            # Draw enhanced landmarks
                             for landmark in face.landmarks:
                                 px = int(landmark.position.x)
                                 py = int(landmark.position.y)
-                                cv2.circle(frame, (px, py), 3, (255, 255, 0), -1)
+                                cv2.circle(frame, (px, py), 3, (255, 255, 0), -1)  # Larger circles
                     
                     if "Text" in analysis_types:
                         text = client.text_detection(image=vision_image)
+                        # Update stats
                         if len(text.text_annotations) > 1:
                             detection_stats["text_blocks"] += len(text.text_annotations) - 1
+                            
+                        # Add overall text summary to the frame
                         if text.text_annotations:
                             full_text = text.text_annotations[0].description
                             words = full_text.split()
                             short_text = " ".join(words[:5])
-                            if len(words) > 5: short_text += "..."
+                            if len(words) > 5:
+                                short_text += "..."
+                                
+                            # Add text summary to top of frame with better visibility
                             cv2.rectangle(frame, (10, 60), (10 + len(short_text)*10, 90), (0, 0, 0), -1)
                             cv2.putText(frame, f"Text: {short_text}", 
                                       (10, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+                        
+                        # Draw text boxes with improved visibility
                         for text_annot in text.text_annotations[1:]:
                             box = [(vertex.x, vertex.y) for vertex in text_annot.bounding_poly.vertices]
                             pts = np.array(box, np.int32).reshape((-1, 1, 2))
-                            cv2.polylines(frame, [pts], True, (255, 0, 0), 2)
+                            cv2.polylines(frame, [pts], True, (255, 0, 0), 2)  # Thicker lines
                     
+                    # Add Labels analysis for more detail
                     if "Labels" in analysis_types:
                         labels = client.label_detection(image=vision_image, max_results=5)
+                        
+                        # Add labels to the frame with better visibility
                         y_pos = 120
                         cv2.rectangle(frame, (10, y_pos-20), (250, y_pos+20*len(labels.label_annotations)), (0, 0, 0), -1)
                         cv2.putText(frame, "Scene labels:", (15, y_pos), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+                        
+                        # Track stats and show labels
                         for i, label in enumerate(labels.label_annotations):
+                            # Update stats
                             if label.description in detection_stats["labels"]:
                                 detection_stats["labels"][label.description] += 1
                             else:
                                 detection_stats["labels"][label.description] = 1
+                                
+                            # Display on frame with larger text
                             cv2.putText(frame, f"- {label.description}: {int(label.score*100)}%", 
                                       (15, y_pos + 20*(i+1)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
                 
                 except Exception as e:
+                    # Show error on frame
                     cv2.putText(frame, f"API Error: {str(e)[:30]}", 
                               (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
             
+            # Add hint about slowed down speed
             cv2.putText(frame, "Playback: 60% speed for better visualization", 
                       (width - 400, height - 30), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 200, 0), 2)
+            
+            # Write the frame to output video
             out.write(frame)
         
+        # Release resources
         cap.release()
         out.release()
+        
+        # Clear progress indicators
         progress_bar.empty()
         status_text.empty()
         
+        # Read the processed video as bytes for download
         with open(output_path, 'rb') as file:
             processed_video_bytes = file.read()
         
+        # Clean up temporary files
         os.unlink(temp_video_path)
         os.unlink(output_path)
         
+        # Calculate additional statistics
         for obj_name, tracking in detection_stats["object_tracking"].items():
+            # Calculate total screen time
             tracking["screen_time"] = round(tracking["frames_present"] * (1/fps) * process_every_n_frames, 2)
+            # Calculate average confidence if available
+            if "confidences" in tracking and tracking["confidences"]:
+                tracking["avg_confidence"] = sum(tracking["confidences"]) / len(tracking["confidences"])
         
+        # Return enhanced results
         results = {"detection_stats": detection_stats}
+        
+        # Store results in session state for chatbot context
         st.session_state.analysis_results = results
+        
+        # Update vectorstore with new results
         update_vectorstore_with_results(results)
+        
         return processed_video_bytes, results
         
     except Exception as e:
+        # Clean up on error
         cap.release()
         if 'out' in locals():
             out.release()
@@ -804,13 +1074,27 @@ def process_video_file(video_file, analysis_types):
         raise e
 
 def load_bigquery_table(dataset_id, table_id, limit=1000):
+    """Load data directly from an existing BigQuery table"""
+    # Create client
     bq_client = bigquery.Client(credentials=credentials, project=credentials.project_id)
-    query = f"SELECT * FROM `{credentials.project_id}.{dataset_id}.{table_id}` LIMIT {limit}"
+    
+    # Build query to get data from the table
+    query = f"""
+    SELECT * FROM `{credentials.project_id}.{dataset_id}.{table_id}`
+    LIMIT {limit}
+    """
+    
+    # Run the query
     query_job = bq_client.query(query)
     results = query_job.result()
+    
+    # Convert to dataframe
     df = results.to_dataframe()
+    
+    # Get table schema for metadata
     table_ref = bq_client.dataset(dataset_id).table(table_id)
     table = bq_client.get_table(table_ref)
+    
     return {
         "data": df,
         "num_rows": table.num_rows,
@@ -819,8 +1103,13 @@ def load_bigquery_table(dataset_id, table_id, limit=1000):
     }
 
 def setup_groq_client():
+    """Setup GROQ client with API key from environment variables"""
+    # Load environment variables from .env file
     load_dotenv()
+    
+    # Get API key from environment variable
     api_key = os.environ.get("GROQ_API")
+    
     if api_key:
         return Groq(api_key=api_key)
     else:
@@ -828,7 +1117,11 @@ def setup_groq_client():
         return None
 
 def process_documents():
+    """Process documentation and past analysis results to create a knowledge base"""
+    # Create a directory for storing app documentation if it doesn't exist
     os.makedirs("app_docs", exist_ok=True)
+    
+    # Create basic app documentation if it doesn't exist
     app_doc_path = "app_docs/app_info.txt"
     if not os.path.exists(app_doc_path):
         with open(app_doc_path, "w") as f:
@@ -847,34 +1140,54 @@ def process_documents():
             - Ask questions using the chat assistant for help
             """)
     
+    # Load documents
     documents = []
+    
+    # Load app documentation
     try:
         loader = TextLoader(app_doc_path)
         documents.extend(loader.load())
     except Exception as e:
         st.warning(f"Could not load app documentation: {str(e)}")
     
+    # Process documents
     if documents:
-        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200
+        )
         return text_splitter.split_documents(documents)
     return []
 
 def create_vectorstore(documents):
+    """Create or update a vectorstore with embeddings"""
     try:
+        # Check if an API key is available for embeddings
         api_key = os.environ.get("OPENAI_API_KEY")
+        
         if not api_key:
             st.warning("OpenAI API Key not found. Using default embeddings.")
             return None
+        
+        # Initialize embeddings
         embeddings = OpenAIEmbeddings(openai_api_key=api_key)
+        
+        # Create or load the vectorstore
         if os.path.exists("vectorstore") and os.path.isdir("vectorstore"):
             try:
                 vectorstore = FAISS.load_local("vectorstore", embeddings)
+                # Add new documents to existing vectorstore
                 if documents:
                     vectorstore.add_documents(documents)
-            except Exception:
+            except Exception as e:
+                st.warning(f"Error loading existing vectorstore: {str(e)}")
+                # Create a new vectorstore
                 vectorstore = FAISS.from_documents(documents, embeddings)
         else:
+            # Create a new vectorstore
             vectorstore = FAISS.from_documents(documents, embeddings)
+            
+        # Save the updated vectorstore
         vectorstore.save_local("vectorstore")
         return vectorstore
     except Exception as e:
@@ -882,59 +1195,85 @@ def create_vectorstore(documents):
         return None
 
 def update_vectorstore_with_results(results):
+    """Update the vectorstore with new analysis results"""
     if not results:
         return
     
     try:
+        # Convert results to document format based on type
         results_text = ""
         timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
         
+        # Check what type of results we have
         if isinstance(results, dict):
-            if "labels" in results:
+            if "labels" in results:  # Image analysis results
                 results_text = f"""
                 Image Analysis Results at {results.get('timestamp', timestamp)}:
+                
                 Labels detected: {', '.join(results.get('labels', {}).keys())}
+                
                 Objects detected: {', '.join(results.get('objects', {}).keys())}
+                
                 Text detected: {results.get('text', 'None')}
                 """
-            elif "detection_stats" in results:
+            elif "detection_stats" in results:  # Video analysis results
                 detection_stats = results.get("detection_stats", {})
                 results_text = f"""
                 Video Analysis Results at {timestamp}:
+                
                 Objects detected: {', '.join(detection_stats.get('objects', {}).keys())}
+                
                 Faces detected: {detection_stats.get('faces', 0)}
+                
                 Text blocks detected: {detection_stats.get('text_blocks', 0)}
+                
                 Labels detected: {', '.join(detection_stats.get('labels', {}).keys())}
                 """
-            elif "data" in results:
+            elif "data" in results:  # Data analysis results
                 results_text = f"""
                 Data Analysis Results at {timestamp}:
+                
                 Dataset loaded with {results.get('num_rows', 0)} rows
+                
                 Columns: {', '.join(results.get('schema', []))}
                 """
-        elif isinstance(results, tuple) and len(results) == 3:
+        elif isinstance(results, tuple) and len(results) == 3:  # Document analysis results
             text, entities, tables = results
             entities_text = ", ".join(f"{k}: {v}" for k, v in entities.items())
             tables_info = f"{len(tables)} tables extracted" if tables else "No tables extracted"
+            
             results_text = f"""
             Document Analysis Results at {timestamp}:
+            
             Extracted text length: {len(text)} characters
+            
             Entities detected: {entities_text}
+            
             Tables: {tables_info}
             """
-        elif isinstance(results, pd.DataFrame):
+        elif isinstance(results, pd.DataFrame):  # Query results
             results_text = f"""
             Query Results at {timestamp}:
+            
             Retrieved {len(results)} rows of data
+            
             Columns: {', '.join(results.columns)}
             """
         
+        # Create a document
         if results_text:
-            text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+            text_splitter = RecursiveCharacterTextSplitter(
+                chunk_size=1000,
+                chunk_overlap=200
+            )
             docs = text_splitter.create_documents([results_text])
+            
+            # Initialize vectorstore if it doesn't exist in session state
             if "vectorstore" not in st.session_state:
                 docs_data = process_documents()
                 st.session_state.vectorstore = create_vectorstore(docs_data)
+            
+            # Add the new documents to the vectorstore
             if st.session_state.vectorstore and docs:
                 api_key = os.environ.get("OPENAI_API_KEY")
                 if api_key:
@@ -945,7 +1284,9 @@ def update_vectorstore_with_results(results):
         st.warning(f"Error updating vectorstore: {str(e)}")
 
 def setup_rag_chain():
+    """Set up a RAG chain with Groq LLM and vectorstore"""
     if "vectorstore" not in st.session_state:
+        # Initialize vectorstore with documentation
         docs = process_documents()
         st.session_state.vectorstore = create_vectorstore(docs)
     
@@ -953,107 +1294,166 @@ def setup_rag_chain():
         return None
     
     try:
+        # Set up Groq client
         if "groq_client" not in st.session_state:
             st.session_state.groq_client = setup_groq_client()
         
         if not st.session_state.groq_client:
             return None
         
-        memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
-        retriever = st.session_state.vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 5})
+        # Initialize conversational memory
+        memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True
+        )
+        
+        # Create the RAG chain
+        retriever = st.session_state.vectorstore.as_retriever(
+            search_type="similarity",
+            search_kwargs={"k": 5}
+        )
+        
+        # Initialize chat model
         api_key = os.environ.get("GROQ_API")
         if not api_key:
             return None
+            
         llm = ChatGroq(api_key=api_key, model_name="llama3-70b-8192")
-        chain = ConversationalRetrievalChain.from_llm(llm=llm, retriever=retriever, memory=memory, return_source_documents=True)
+        
+        # Create the chain
+        chain = ConversationalRetrievalChain.from_llm(
+            llm=llm,
+            retriever=retriever,
+            memory=memory,
+            return_source_documents=True
+        )
+        
         return chain
     except Exception as e:
         st.warning(f"Error setting up RAG chain: {str(e)}")
         return None
 
 def parse_command(command, analysis_types=None):
+    """Parse user command and return function to execute"""
     command = command.lower().strip()
+    
+    # Image analysis commands
     if "analyze image" in command and analysis_types:
         return "analyze_image", analysis_types
+    
+    # Video analysis commands
     elif "process video" in command and analysis_types:
         return "process_video", analysis_types
+    
+    # Data analysis commands
     elif "run query" in command:
         query = re.search(r"run query\s*:\s*(.*)", command, re.IGNORECASE)
         if query:
             return "run_query", query.group(1)
+    
+    # Document analysis commands
     elif "process document" in command:
         return "process_document", None
+        
+    # Help commands
     elif any(x in command for x in ["what can you do", "help", "capabilities"]):
         return "help", None
+        
+    # No command detected
     return None, None
 
 def execute_command(command_type, params):
+    """Execute a command based on the parsed command"""
     if command_type == "analyze_image":
         st.write("To analyze an image, please upload an image in the Image Analysis section and select your desired analysis types.")
         return "I can help you analyze images. Please upload an image in the Image Analysis section and select which features you want to detect."
+    
     elif command_type == "process_video":
         st.write("To process a video, please upload a video in the Video Analysis section and select your desired analysis types.")
         return "I can help you process videos. Please upload a video in the Video Analysis section and select which features you want to detect."
+    
     elif command_type == "run_query":
         st.write("To run a BigQuery query, please go to the Data Analysis section.")
         return f"I can help you run the query: {params}. Please go to the Data Analysis section to execute it."
+    
     elif command_type == "process_document":
         st.write("To process a document, please upload a document in the Document Analysis section.")
         return "I can help you analyze documents. Please upload a document in the Document Analysis section."
+    
     elif command_type == "help":
         capabilities = """
         I can help you with several tasks in the Cosmick Cloud AI Analyzer:
+        
         1. **Image Analysis** - I can identify objects, text, faces, and labels in images
         2. **Video Analysis** - I can process videos to detect objects, faces, and text
         3. **Document Analysis** - I can extract text and structure from documents
         4. **Data Analysis** - I can help query and visualize data in BigQuery
+        
         Try asking me specific questions about your analysis results or how to use the app!
         """
         return capabilities
+    
     return None
 
 def get_assistant_response(client, prompt, context=None, model="llama3-70b-8192"):
+    """Get response from GROQ assistant with context awareness"""
     if client is None:
         return "I'm unable to connect to my knowledge base right now. Please check the API configuration."
     
+    # Check if the input is a command
     command_type, params = parse_command(prompt)
     if command_type:
         command_response = execute_command(command_type, params)
         if command_response:
             return command_response
     
+    # Set up RAG chain if available
     rag_chain = None
-    if "vectorstore" in st.session_state and st.session_state.vectorstore:
-        rag_chain = setup_rag_chain()
+    try:
+        if "vectorstore" in st.session_state and st.session_state.vectorstore:
+            rag_chain = setup_rag_chain()
+    except Exception as e:
+        st.warning(f"Error setting up RAG: {str(e)}")
     
+    # If RAG is available, use it for enhanced responses
     if rag_chain:
         try:
             result = rag_chain({"question": prompt})
             return result["answer"]
-        except Exception:
-            pass
+        except Exception as e:
+            st.warning(f"RAG error: {str(e)}, falling back to standard response")
     
+    # Build a context-aware prompt as fallback
     if context:
         full_prompt = f"""You are an AI assistant for the Cosmick Cloud AI Analyzer application.
-        Current application context: {context}
-        User question: {prompt}
-        Please provide a helpful, accurate response based on the current application context. 
-        If you need more specific information to answer correctly, please ask for it."""
+        
+Current application context: {context}
+User question: {prompt}
+Please provide a helpful, accurate response based on the current application context. 
+If you need more specific information to answer correctly, please ask for it."""
     else:
         full_prompt = f"""You are an AI assistant for the Cosmick Cloud AI Analyzer application.
-        The application has the following tools:
-        1. Image Analysis: Analyzes images for labels, objects, text, and faces
-        2. Video Analysis: Processes videos to detect objects, faces, and text
-        3. Document Analysis: Extracts text and structure from documents
-        4. Data Analysis: Uploads, queries, and visualizes data in BigQuery
-        User question: {prompt}
-        Please provide a helpful response to guide the user on using these tools."""
+        
+The application has the following tools:
+1. Image Analysis: Analyzes images for labels, objects, text, and faces
+2. Video Analysis: Processes videos to detect objects, faces, and text
+3. Document Analysis: Extracts text and structure from documents
+4. Data Analysis: Uploads, queries, and visualizes data in BigQuery
+User question: {prompt}
+Please provide a helpful response to guide the user on using these tools."""
 
+    # Call GROQ API
     try:
         chat_completion = client.chat.completions.create(
             messages=[
-                {"role": "system", "content": "You are a helpful, knowledgeable assistant for the Cosmick Cloud AI Analyzer application."},
-                {"role": "user", "content": full_prompt}
+                {
+                    "role": "system",
+                    "content": "You are a helpful, knowledgeable assistant for the Cosmick Cloud AI Analyzer application."
+                },
+                {
+                    "role": "user",
+                    "content": full_prompt
+                }
             ],
             model=model,
             temperature=0.5,
@@ -1066,26 +1466,34 @@ def get_assistant_response(client, prompt, context=None, model="llama3-70b-8192"
         return f"I encountered an error: {str(e)}. Please try again or check the API configuration."
 
 def chatbot_interface():
+    """Create a chatbot interface at the bottom of the app"""
+    # Initialize chat history
     if "messages" not in st.session_state:
         st.session_state.messages = []
+    
+    # Initialize GROQ client
     if "groq_client" not in st.session_state:
         st.session_state.groq_client = setup_groq_client()
     
+    # Get current context
     current_context = ""
     if "current_tool" in st.session_state:
         current_context += f"Current tool: {st.session_state.current_tool}\n"
     if "analysis_results" in st.session_state:
         current_context += f"Analysis results: {st.session_state.analysis_results}\n"
     
+    # Create chatbot container with improved styling
     st.markdown('<div class="chat-container">', unsafe_allow_html=True)
     st.markdown('<div class="chat-header">💬 Cosmick AI Assistant</div>', unsafe_allow_html=True)
     
+    # Clear conversation button
     st.markdown('<div class="clear-button">', unsafe_allow_html=True)
     if st.button("Clear conversation"):
         st.session_state.messages = []
         st.rerun()
     st.markdown('</div>', unsafe_allow_html=True)
     
+    # Display chat message history with improved styling
     st.markdown('<div class="message-container">', unsafe_allow_html=True)
     for message in st.session_state.messages:
         if message["role"] == "user":
@@ -1095,18 +1503,40 @@ def chatbot_interface():
     st.markdown('<div class="clear-float"></div>', unsafe_allow_html=True)
     st.markdown('</div>', unsafe_allow_html=True)
     
+    # Chat input
     user_input = st.chat_input("Ask me anything about image, video, document or data analysis...")
+    
     if user_input:
+        # Add user message to history
         st.session_state.messages.append({"role": "user", "content": user_input})
-        response = get_assistant_response(st.session_state.groq_client, user_input, context=current_context)
+        
+        # Check if it's a command
+        command_type, params = parse_command(user_input)
+        
+        if command_type:
+            # Execute command
+            response = execute_command(command_type, params)
+        else:
+            # Get assistant response
+            response = get_assistant_response(
+                st.session_state.groq_client,
+                user_input,
+                context=current_context
+            )
+        
+        # Add assistant response to history
         st.session_state.messages.append({"role": "assistant", "content": response})
+        
+        # Rerun to update chat display
         st.rerun()
     
     st.markdown('</div>', unsafe_allow_html=True)
 
 def main():
+    # Header - Updated title
     st.markdown('<div class="main-header">Cosmick Cloud AI Analyzer</div>', unsafe_allow_html=True)
     
+    # Navigation
     selected = option_menu(
         menu_title=None,
         options=["Image Analysis", "Video Analysis", "Document Analysis", "Data Analysis", "About"],
@@ -1116,143 +1546,226 @@ def main():
         orientation="horizontal",
     )
     
+    # Store current tool in session state for context
     st.session_state.current_tool = selected
     
     if selected == "Image Analysis":
+        # Sidebar controls
         with st.sidebar:
             st.markdown("### Analysis Settings")
+            
+            # Add mode selection
             processing_mode = st.radio("Processing Mode", ["Single Image", "Batch Processing (up to 5 images)"])
+            
+            # Analysis types selection
             st.write("Choose analysis types:")
             analysis_types = []
-            if st.checkbox("Label Detection", value=True): analysis_types.append("Labels")
-            if st.checkbox("Object Detection", value=True): analysis_types.append("Objects")
-            if st.checkbox("Text Recognition", value=True): analysis_types.append("Text")
-            if st.checkbox("Face Detection"): analysis_types.append("Face Detection")
-            if st.checkbox("Visual Attributes (Colors)"): analysis_types.append("Visual Attributes")
+            
+            if st.checkbox("Label Detection", value=True):
+                analysis_types.append("Labels")
+            
+            if st.checkbox("Object Detection", value=True):
+                analysis_types.append("Objects")
+            
+            if st.checkbox("Text Recognition", value=True):
+                analysis_types.append("Text")
+            
+            if st.checkbox("Face Detection"):
+                analysis_types.append("Face Detection")
+            
+            # New enhanced analysis options
+            if st.checkbox("Visual Attributes (Colors)", value=False):
+                analysis_types.append("Visual Attributes")
+            
             st.markdown("---")
-            confidence_threshold = st.slider("Detection Confidence Threshold", 0.0, 1.0, 0.5)
+            
+            # Confidence threshold control
+            confidence_threshold = st.slider("Detection Confidence Threshold", 
+                                          min_value=0.0, max_value=1.0, value=0.5,
+                                          help="Filter results based on confidence level")
+            
+            # Image quality settings
             st.write("Image settings:")
-            quality = st.slider("Image Quality", 0, 100, 100)
+            quality = st.slider("Image Quality", min_value=0, max_value=100, value=100)
+            
             st.markdown("---")
-            st.info("This application analyzes images using Google Cloud Vision AI.")
+            st.info("This application analyzes images using Google Cloud Vision AI. Upload an image to get started.")
         
+        # Main content
         if processing_mode == "Single Image":
             st.markdown("## Single Image Analysis")
             uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+            
             if uploaded_file is not None:
+                # Convert uploaded file to image
                 image = Image.open(uploaded_file)
+                
+                # Apply quality adjustment if needed
                 if quality < 100:
                     img_byte_arr = io.BytesIO()
                     image.save(img_byte_arr, format='JPEG', quality=quality)
                     image = Image.open(img_byte_arr)
+                
+                # Show original image
                 st.markdown('<div class="subheader">Original Image</div>', unsafe_allow_html=True)
                 st.image(image, use_container_width=True)
+                
+                # Add analyze button
                 if st.button("Analyze Image"):
                     if not analysis_types:
                         st.warning("Please select at least one analysis type.")
                     else:
                         with st.spinner("Analyzing image..."):
+                            # Call analyze function
                             annotated_img, labels, objects, text, colors, text_language = analyze_image(image, analysis_types)
+                            
+                            # Display results
                             display_results(annotated_img, labels, objects, text, colors, text_language)
+                            
+                            # Add download button for the annotated image
                             buf = io.BytesIO()
                             annotated_img.save(buf, format="PNG")
                             byte_im = buf.getvalue()
+                            
                             st.download_button(
                                 label="Download Annotated Image",
                                 data=byte_im,
                                 file_name="annotated_image.png",
                                 mime="image/png"
                             )
-        else:
+        
+        else:  # Batch Processing mode
             st.markdown("## Batch Image Analysis")
             st.info("Upload up to 5 images for batch processing.")
+            
             uploaded_files = st.file_uploader("Choose images...", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
+            
             if uploaded_files and len(uploaded_files) > 0:
                 if len(uploaded_files) > 5:
-                    st.warning("Only the first 5 images will be processed.")
+                    st.warning("You've uploaded more than 5 images. Only the first 5 will be processed.")
                     uploaded_files = uploaded_files[:5]
+                
                 if st.button("Process Batch"):
                     st.write(f"Processing {len(uploaded_files)} images...")
+                    
+                    # Process each image with a unique key for each download button
                     for i, uploaded_file in enumerate(uploaded_files):
                         st.markdown(f"### Image {i+1}: {uploaded_file.name}")
+                        
+                        # Open and process the image
                         try:
                             image = Image.open(uploaded_file)
                             annotated_img, labels, objects, text, colors, text_language = analyze_image(
                                 image, analysis_types, confidence_threshold
                             )
+                            
+                            # Create a unique identifier for this image
                             image_id = f"{i}_{uploaded_file.name.replace(' ', '_')}"
+                            
+                            # Display results with unique download button keys
                             col1, col2 = st.columns([3, 2])
+                            
                             with col1:
                                 st.image(annotated_img, use_container_width=True)
+                            
                             with col2:
+                                # Display analysis results
                                 if labels:
                                     st.markdown("##### Labels Detected")
                                     for label, confidence in labels.items():
                                         st.write(f"{label}: {confidence}%")
+                                
                                 if objects:
                                     st.markdown("##### Objects Detected")
                                     for obj, confidence in objects.items():
                                         st.write(f"{obj}: {confidence}%")
+                                
                                 if text:
                                     st.markdown("##### Text Detected")
                                     if text_language:
                                         st.markdown(f"**Language:** {text_language}")
                                     st.text(text)
+                                
                                 if colors:
                                     st.markdown("##### Dominant Colors")
                                     for color_name, color_data in colors.items():
                                         rgb = color_data["rgb"]
                                         hex_color = f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
                                         st.markdown(f"<div style='background-color:{hex_color};width:50px;height:20px;display:inline-block;'></div> {color_name}: {color_data['score']}%", unsafe_allow_html=True)
+                        
+                            # Create summary image for download
                             summary_img = create_summary_image(annotated_img, labels, objects, text, colors)
                             buf = io.BytesIO()
                             summary_img.save(buf, format="JPEG", quality=90)
                             byte_im = buf.getvalue()
+                            
+                            # Use unique key for each download button
                             st.download_button(
                                 label=f"📥 Download Results for {uploaded_file.name}",
                                 data=byte_im,
                                 file_name=f"analysis_{image_id}.jpg",
                                 mime="image/jpeg",
-                                key=f"download_batch_{image_id}"
+                                key=f"download_batch_{image_id}"  # Unique key for each image
                             )
-                            st.markdown("---")
+                            
+                            st.markdown("---")  # Add separator between images
+                            
                         except Exception as e:
                             st.error(f"Error processing {uploaded_file.name}: {str(e)}")
     
     elif selected == "Video Analysis":
         st.markdown('<div class="subheader">Video Analysis</div>', unsafe_allow_html=True)
+        
+        # Analysis settings
         st.sidebar.markdown("### Video Analysis Settings")
         analysis_types = []
-        if st.sidebar.checkbox("Object Detection", value=True): analysis_types.append("Objects")
-        if st.sidebar.checkbox("Face Detection"): analysis_types.append("Face Detection")
-        if st.sidebar.checkbox("Text Recognition"): analysis_types.append("Text")
+        if st.sidebar.checkbox("Object Detection", value=True):
+            analysis_types.append("Objects")
+        if st.sidebar.checkbox("Face Detection"):
+            analysis_types.append("Face Detection")
+        if st.sidebar.checkbox("Text Recognition"):
+            analysis_types.append("Text")
+        
         st.sidebar.markdown("---")
-        st.sidebar.warning("⚠️ Video analysis may use a significant amount of API calls.")
+        st.sidebar.warning("⚠️ Video analysis may use a significant amount of API calls. Use responsibly.")
         
+        # Upload Video mode only - removed real-time camera option
         st.markdown("""
         #### 📤 Video Analysis
+        
         Upload a video file to analyze it with Google Cloud Vision AI.
+        
         **Instructions:**
         1. Select the analysis types in the sidebar
         2. Upload a video file (MP4, MOV, AVI)
         3. Click "Process Video" to begin analysis
         4. Download the processed video when complete
-        **Note:** Videos are limited to 10 seconds of processing.
+        
+        **Note:** Videos are limited to 10 seconds of processing to manage API usage.
         """)
         
+        # File uploader for videos
         uploaded_file = st.file_uploader("Choose a video file", type=["mp4", "mov", "avi"])
+        
         if uploaded_file is not None:
-            file_details = {"Filename": uploaded_file.name, "Size": f"{uploaded_file.size / (1024*1024):.2f} MB"}
+            # Display file info
+            file_details = {"Filename": uploaded_file.name, 
+                           "Size": f"{uploaded_file.size / (1024*1024):.2f} MB"}
             st.write("### File Details")
             st.json(file_details)
+            
+            # Process video button
             if st.button("Process Video"):
                 if not analysis_types:
                     st.warning("Please select at least one analysis type.")
                 else:
                     with st.spinner("Processing video (max 10 seconds)..."):
                         try:
+                            # Process the video with enhanced detail
                             processed_video, results = process_video_file(uploaded_file, analysis_types)
+                            
                             if processed_video:
+                                # Offer download of processed video
                                 st.success("Video processing complete!")
                                 st.download_button(
                                     label="⬇️ Download Processed Video",
@@ -1260,11 +1773,19 @@ def main():
                                     file_name=f"processed_{uploaded_file.name}",
                                     mime="video/mp4"
                                 )
+                                
+                                # Show detailed analysis results
                                 st.markdown("### Detailed Analysis Results")
+                                
+                                # Display object detection summary
                                 if "Objects" in analysis_types and results["detection_stats"]["objects"]:
                                     st.markdown("#### 📦 Objects Detected")
+                                    
+                                    # Sort objects by frequency
                                     sorted_objects = dict(sorted(results["detection_stats"]["objects"].items(), 
                                                         key=lambda x: x[1], reverse=True))
+                                    
+                                    # Create bar chart for objects
                                     if sorted_objects:
                                         fig, ax = plt.subplots(figsize=(10, 5))
                                         objects = list(sorted_objects.keys())
@@ -1273,53 +1794,80 @@ def main():
                                         ax.set_xlabel('Number of Detections')
                                         ax.set_title('Objects Detected in Video')
                                         st.pyplot(fig)
+                                        
+                                        # List with counts
                                         col1, col2 = st.columns(2)
                                         with col1:
                                             st.markdown("**Top Objects:**")
                                             for obj, count in list(sorted_objects.items())[:10]:
                                                 st.markdown(f"- {obj}: {count} occurrences")
+                                
+                                # Display face detection summary
                                 if "Face Detection" in analysis_types and results["detection_stats"]["faces"] > 0:
                                     st.markdown("#### 👤 Face Analysis")
                                     st.markdown(f"Total faces detected: {results['detection_stats']['faces']}")
+                                
+                                # Display text detection summary
                                 if "Text" in analysis_types and results["detection_stats"]["text_blocks"] > 0:
                                     st.markdown("#### 📝 Text Analysis")
                                     st.markdown(f"Total text blocks detected: {results['detection_stats']['text_blocks']}")
+                                
+                                # Display label detection summary
                                 if "Labels" in analysis_types and results["detection_stats"]["labels"]:
                                     st.markdown("#### 🏷️ Scene Labels")
+                                    
+                                    # Sort labels by frequency
                                     sorted_labels = dict(sorted(results["detection_stats"]["labels"].items(), 
                                                        key=lambda x: x[1], reverse=True))
+                                    
+                                    # Create pie chart for top labels
                                     if sorted_labels:
                                         fig, ax = plt.subplots(figsize=(8, 8))
                                         top_labels = dict(list(sorted_labels.items())[:7])
                                         if len(sorted_labels) > 7:
                                             other_count = sum(list(sorted_labels.values())[7:])
                                             top_labels["Other"] = other_count
+                                            
                                         ax.pie(top_labels.values(), labels=top_labels.keys(), autopct='%1.1f%%')
                                         ax.set_title('Distribution of Scene Labels')
                                         st.pyplot(fig)
+                        
                         except Exception as e:
                             st.error(f"Error processing video: {str(e)}")
     
     elif selected == "Document Analysis":
         st.markdown('<div class="subheader">Document Processing & Analysis</div>', unsafe_allow_html=True)
+        
+        # Sidebar controls for document analysis
         with st.sidebar:
             st.markdown("### Document Analysis Settings")
+            
+            # Select document processor type
             processor_type = st.selectbox(
                 "Select Document Type",
                 ["Document OCR", "Form Parser", "Layout Parser", "Invoice Parser", "ID Document"]
             )
+            
+            # Mapping of processor types to processor IDs with all your actual IDs
             processor_mapping = {
-                "Document OCR": "4c80189b1a7863b0",
-                "Form Parser": "47542cfc343edcac",
-                "Layout Parser": "54e2616441b939e5",
-                "Invoice Parser": "e6efe8aa1d3afa61",
-                "ID Document": "894a011b810ebfee"
+                "Document OCR": "4c80189b1a7863b0",     # ocr-process
+                "Form Parser": "47542cfc343edcac",      # Form-Process
+                "Layout Parser": "54e2616441b939e5",    # layout-process
+                "Invoice Parser": "e6efe8aa1d3afa61",   # invoice-parser
+                "ID Document": "894a011b810ebfee"       # ID-parser
             }
+            
             st.markdown("---")
             st.info("Upload a document to extract information using Google Document AI.")
         
-        uploaded_file = st.file_uploader("Upload a document (PDF, TIFF, JPG, PNG)", type=["pdf", "tiff", "jpg", "jpeg", "png"])
+        # Main content
+        uploaded_file = st.file_uploader(
+            "Upload a document (PDF, TIFF, JPG, PNG)", 
+            type=["pdf", "tiff", "jpg", "jpeg", "png"]
+        )
+        
         if uploaded_file is not None:
+            # Display file details
             file_details = {
                 "Filename": uploaded_file.name,
                 "File size": f"{uploaded_file.size / 1024:.2f} KB",
@@ -1328,23 +1876,38 @@ def main():
             st.write("### File Details")
             for key, value in file_details.items():
                 st.write(f"**{key}:** {value}")
+            
+            # If it's an image file, display it
             if uploaded_file.type.startswith('image/'):
                 st.image(uploaded_file, caption="Uploaded Document", use_container_width=True)
             else:
                 st.info("PDF document uploaded (preview not available)")
+            
+            # Process button
             if st.button("Process Document"):
                 with st.spinner("Processing document..."):
+                    # Get processor ID based on selection
                     processor_id = processor_mapping[processor_type]
+                    
+                    # Get file content
                     file_content = uploaded_file.getvalue()
+                    
+                    # Process document
                     try:
                         text, entities, tables = analyze_document(file_content, processor_id)
+                        
+                        # Display results
                         st.markdown("### Document Analysis Results")
+                        
+                        # Show extracted information in tabs
                         tab1, tab2, tab3 = st.tabs(["Text", "Extracted Fields", "Tables"])
+                        
                         with tab1:
                             st.markdown("#### Extracted Text")
                             st.markdown('<div class="result-container">', unsafe_allow_html=True)
                             st.write(text)
                             st.markdown('</div>', unsafe_allow_html=True)
+                        
                         with tab2:
                             st.markdown("#### Extracted Fields")
                             st.markdown('<div class="result-container">', unsafe_allow_html=True)
@@ -1354,6 +1917,7 @@ def main():
                             else:
                                 st.info("No fields extracted from this document.")
                             st.markdown('</div>', unsafe_allow_html=True)
+                        
                         with tab3:
                             st.markdown("#### Extracted Tables")
                             if tables:
@@ -1363,20 +1927,30 @@ def main():
                                     st.dataframe(df)
                             else:
                                 st.info("No tables found in this document.")
+                    
                     except Exception as e:
                         st.error(f"Error processing document: {str(e)}")
     
     elif selected == "Data Analysis":
         st.markdown('<div class="subheader">BigQuery Data Analysis</div>', unsafe_allow_html=True)
+        
+        # Sidebar controls for BigQuery
         with st.sidebar:
             st.markdown("### BigQuery Settings")
+            
+            # List existing resources
             try:
                 resources = list_bigquery_resources()
+                
+                # Direct data selection option
                 st.markdown("### Select Existing Data")
                 if resources:
+                    # Dataset selection
                     dataset_options = list(resources.keys())
                     dataset_options.insert(0, "-- Select a dataset --")
                     selected_dataset = st.selectbox("Dataset", dataset_options)
+                    
+                    # Table selection (dependent on dataset)
                     table_options = []
                     if selected_dataset and selected_dataset != "-- Select a dataset --":
                         table_options = resources[selected_dataset]
@@ -1384,17 +1958,24 @@ def main():
                             st.info("No tables in this dataset")
                     table_options.insert(0, "-- Select a table --")
                     selected_table = st.selectbox("Table", table_options)
+                    
+                    # Load button
                     if selected_dataset != "-- Select a dataset --" and selected_table != "-- Select a table --":
                         if st.button("Load Selected Table"):
                             with st.spinner(f"Loading data from {selected_dataset}.{selected_table}..."):
                                 try:
+                                    # Load the data
                                     result = load_bigquery_table(selected_dataset, selected_table)
+                                    
+                                    # Store in session state for use in other tabs
                                     st.session_state["table_info"] = {
                                         "dataset_id": selected_dataset,
                                         "table_id": selected_table,
                                         "schema": result["schema"]
                                     }
                                     st.session_state["query_results"] = result["data"]
+                                    
+                                    # Show success message
                                     st.success(f"Loaded {result['data'].shape[0]} rows from {selected_dataset}.{selected_table}")
                                 except Exception as e:
                                     st.error(f"Error loading table: {str(e)}")
@@ -1404,22 +1985,38 @@ def main():
                 st.error(f"Error listing resources: {str(e)}")
             
             st.markdown("---")
+            
+            # Manual dataset and table settings for upload
             st.markdown("### Upload New Data")
             dataset_id = st.text_input("Dataset ID", "my_dataset")
             table_id = st.text_input("Table ID", "my_table")
-            replace_data = st.radio("Upload Mode:", ["Replace existing data", "Append to existing data"])
+            
+            # Upload options
+            replace_data = st.radio(
+                "Upload Mode:",
+                ["Replace existing data", "Append to existing data"]
+            )
         
+        # Tabs for different actions
         upload_tab, explore_tab, query_tab, visualization_tab = st.tabs(["Upload Data", "Explore Data", "Query Data", "Visualize Data"])
         
+        # New Explore Data tab
         with explore_tab:
             st.markdown("### Explore BigQuery Data")
+            
             if "query_results" in st.session_state and not st.session_state["query_results"].empty:
                 df = st.session_state["query_results"]
+                
+                # Show summary of the data
                 st.write("### Data Summary")
                 st.write(f"**Rows:** {df.shape[0]}")
                 st.write(f"**Columns:** {df.shape[1]}")
+                
+                # Display the data
                 st.write("### Data Preview")
                 st.dataframe(df.head(100))
+                
+                # Display column information
                 st.write("### Column Information")
                 col_info = pd.DataFrame({
                     "Column": df.columns,
@@ -1429,31 +2026,52 @@ def main():
                     "Unique Values": [df[col].nunique() for col in df.columns]
                 })
                 st.dataframe(col_info)
+                
+                # Quick statistics for numeric columns
                 num_cols = df.select_dtypes(include=['int64', 'float64']).columns
                 if not num_cols.empty:
                     st.write("### Numeric Column Statistics")
                     st.dataframe(df[num_cols].describe())
             else:
-                st.info("Select an existing dataset and table from the sidebar or upload a CSV file.")
+                st.info("Select an existing dataset and table from the sidebar and click 'Load Selected Table', or upload a CSV file in the 'Upload Data' tab.")
         
         with upload_tab:
             st.markdown("### Upload Data to BigQuery")
+            
+            # File uploader for CSV files
             uploaded_file = st.file_uploader("Upload a CSV file", type=["csv"])
+            
             if uploaded_file is not None:
+                # Display file details
+                file_details = {
+                    "Filename": uploaded_file.name,
+                    "File size": f"{uploaded_file.size / 1024:.2f} KB"
+                }
+                
+                # Show file preview
                 try:
                     df_preview = pd.read_csv(uploaded_file)
                     st.write("### File Preview")
                     st.dataframe(df_preview.head(5))
+                    
+                    # Store dataframe in session state for other tabs
                     st.session_state["query_results"] = df_preview
+                    
+                    # Upload button
                     if st.button("Upload to BigQuery"):
                         with st.spinner("Uploading to BigQuery..."):
                             try:
+                                # Upload the file
                                 append = replace_data == "Append to existing data"
                                 result = upload_csv_to_bigquery(uploaded_file, dataset_id, table_id, append=append)
+                                
+                                # Show success message
                                 st.success(f"Successfully uploaded to {dataset_id}.{table_id}")
                                 st.write(f"Rows: {result['num_rows']}")
                                 st.write(f"Size: {result['size_bytes'] / 1024:.2f} KB")
                                 st.write(f"Schema: {', '.join(result['schema'])}")
+                                
+                                # Store table info in session state
                                 st.session_state["table_info"] = {
                                     "dataset_id": dataset_id,
                                     "table_id": table_id,
@@ -1468,18 +2086,31 @@ def main():
         
         with query_tab:
             st.markdown("### Query BigQuery Data")
+            
             if "query_results" in st.session_state and "table_info" in st.session_state:
+                # Display info about the loaded data
                 table_info = st.session_state["table_info"]
                 st.write(f"Working with table: **{table_info['dataset_id']}.{table_info['table_id']}**")
+                
+                # Query input
                 default_query = f"SELECT * FROM `{credentials.project_id}.{table_info['dataset_id']}.{table_info['table_id']}` LIMIT 100"
                 query = st.text_area("SQL Query", default_query, height=100)
+                
+                # Execute query button
                 if st.button("Run Query"):
                     with st.spinner("Executing query..."):
                         try:
+                            # Run the query
                             results = run_bigquery(query)
+                            
+                            # Store results in session state
                             st.session_state["query_results"] = results
+                            
+                            # Display results
                             st.write("### Query Results")
                             st.dataframe(results)
+                            
+                            # Download button for results
                             csv = results.to_csv(index=False)
                             st.download_button(
                                 label="Download Results as CSV",
@@ -1494,55 +2125,82 @@ def main():
         
         with visualization_tab:
             st.markdown("### Visualize BigQuery Data")
+            
             if "query_results" in st.session_state and not st.session_state["query_results"].empty:
                 df = st.session_state["query_results"]
-                chart_type = st.selectbox("Select Chart Type", ["Bar Chart", "Line Chart", "Scatter Plot", "Histogram", "Pie Chart"])
+                
+                # Chart type selection
+                chart_type = st.selectbox(
+                    "Select Chart Type",
+                    ["Bar Chart", "Line Chart", "Scatter Plot", "Histogram", "Pie Chart"]
+                )
+                
+                # Column selection based on data types
                 numeric_cols = df.select_dtypes(include=['int64', 'float64']).columns.tolist()
                 all_cols = df.columns.tolist()
+                
                 if len(numeric_cols) < 1:
                     st.warning("No numeric columns available for visualization")
                 else:
                     if chart_type in ["Bar Chart", "Line Chart", "Scatter Plot"]:
                         col1, col2 = st.columns(2)
+                        
                         with col1:
                             x_axis = st.selectbox("X-axis", all_cols)
+                        
                         with col2:
                             y_axis = st.selectbox("Y-axis", numeric_cols)
+                        
+                        # Optional: Grouping/color dimension
                         color_dim = st.selectbox("Color Dimension (Optional)", ["None"] + all_cols)
+                        
+                        # Generate the visualization based on selection
                         if st.button("Generate Visualization"):
                             st.write(f"### {chart_type}: {y_axis} by {x_axis}")
+                            
                             if chart_type == "Bar Chart":
                                 if color_dim != "None":
-                                    fig = px.bar(df, x=x_axis, y=y_axis, color=color_dim, title=f"{y_axis} by {x_axis}")
+                                    fig = px.bar(df, x=x_axis, y=y_axis, color=color_dim, 
+                                                 title=f"{y_axis} by {x_axis}")
                                 else:
                                     fig = px.bar(df, x=x_axis, y=y_axis, title=f"{y_axis} by {x_axis}")
                                 st.plotly_chart(fig)
+                            
                             elif chart_type == "Line Chart":
                                 if color_dim != "None":
-                                    fig = px.line(df, x=x_axis, y=y_axis, color=color_dim, title=f"{y_axis} by {x_axis}")
+                                    fig = px.line(df, x=x_axis, y=y_axis, color=color_dim,
+                                                  title=f"{y_axis} by {x_axis}")
                                 else:
                                     fig = px.line(df, x=x_axis, y=y_axis, title=f"{y_axis} by {x_axis}")
                                 st.plotly_chart(fig)
+                            
                             elif chart_type == "Scatter Plot":
                                 if color_dim != "None":
-                                    fig = px.scatter(df, x=x_axis, y=y_axis, color=color_dim, title=f"{y_axis} vs {x_axis}")
+                                    fig = px.scatter(df, x=x_axis, y=y_axis, color=color_dim,
+                                                     title=f"{y_axis} vs {x_axis}")
                                 else:
                                     fig = px.scatter(df, x=x_axis, y=y_axis, title=f"{y_axis} vs {x_axis}")
                                 st.plotly_chart(fig)
+                    
                     elif chart_type == "Histogram":
                         column = st.selectbox("Select Column", numeric_cols)
-                        bins = st.slider("Number of Bins", 5, 100, 20)
+                        bins = st.slider("Number of Bins", min_value=5, max_value=100, value=20)
+                        
                         if st.button("Generate Visualization"):
                             st.write(f"### Histogram of {column}")
                             fig = px.histogram(df, x=column, nbins=bins, title=f"Distribution of {column}")
                             st.plotly_chart(fig)
+                    
                     elif chart_type == "Pie Chart":
                         column = st.selectbox("Category Column", all_cols)
                         value_col = st.selectbox("Value Column", numeric_cols)
+                        
                         if st.button("Generate Visualization"):
+                            # Aggregate the data if needed
                             pie_data = df.groupby(column)[value_col].sum().reset_index()
                             st.write(f"### Pie Chart: {value_col} by {column}")
-                            fig = px.pie(pie_data, names=column, values=value_col, title=f"{value_col} by {column}")
+                            fig = px.pie(pie_data, names=column, values=value_col, 
+                                         title=f"{value_col} by {column}")
                             st.plotly_chart(fig)
             else:
                 st.info("Load a table from BigQuery or upload a CSV file first")
@@ -1551,27 +2209,36 @@ def main():
         st.markdown("## About This App")
         st.write("""
         This application uses Google Cloud Vision AI to analyze images and video streams. It can:
+        
         - **Detect labels** in images
         - **Identify objects** and their locations
         - **Extract text** from images
         - **Detect faces** and facial landmarks
         - **Analyze real-time video** from your camera
+        
         To use this app, you need to:
         1. Set up Google Cloud Vision API credentials
         2. Upload an image or use your camera
         3. Select the types of analysis you want to perform
         4. Click "Analyze Image" or start the video stream
+        
         The app is built with Streamlit and Google Cloud Vision API.
         """)
+        
         st.info("Note: Make sure your Google Cloud credentials are properly set up to use this application.")
 
+    # Add the chatbot interface at the bottom of the page
     chatbot_interface()
 
 if __name__ == "__main__":
+    # Use GOOGLE_CREDENTIALS directly - no need for file or GOOGLE_APPLICATION_CREDENTIALS
     try:
         if 'GOOGLE_CREDENTIALS' in os.environ:
+            # Create credentials object directly from JSON string
             credentials_info = json.loads(os.environ['GOOGLE_CREDENTIALS'])
             credentials = service_account.Credentials.from_service_account_info(credentials_info)
+            
+            # Initialize client with these credentials directly
             client = vision.ImageAnnotatorClient(credentials=credentials)
         else:
             st.sidebar.error("GOOGLE_CREDENTIALS environment variable not found")
@@ -1579,4 +2246,51 @@ if __name__ == "__main__":
     except Exception as e:
         st.sidebar.error(f"Error with credentials: {str(e)}")
         client = None
-    main()
\ No newline at end of file
+
+    main() 
+
+# Add this function to your app
+def extract_video_frames(video_bytes, num_frames=5):
+    """Extract frames from video bytes for thumbnail display"""
+    import cv2
+    import numpy as np
+    import tempfile
+    from PIL import Image
+    import io
+    
+    # Save video bytes to a temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as temp_file:
+        temp_file.write(video_bytes)
+        temp_video_path = temp_file.name
+    
+    # Open the video file
+    cap = cv2.VideoCapture(temp_video_path)
+    
+    # Get video properties
+    frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    
+    # Calculate frame intervals
+    interval = max(1, frame_count // (num_frames + 1))
+    
+    # Extract frames at intervals
+    frames = []
+    for i in range(1, num_frames + 1):
+        frame_position = i * interval
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_position)
+        ret, frame = cap.read()
+        if ret:
+            # Convert to RGB (from BGR)
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            # Convert to PIL Image
+            pil_img = Image.fromarray(frame_rgb)
+            # Save to bytes
+            img_byte_arr = io.BytesIO()
+            pil_img.save(img_byte_arr, format='JPEG')
+            frames.append(img_byte_arr.getvalue())
+    
+    # Clean up
+    cap.release()
+    import os
+    os.unlink(temp_video_path)
+    
+    return frames