Update app.py

app.py

@@ -10,14 +10,10 @@ import traceback # For detailed error logging
 
 # --- Configuration ---
 # Models chosen for speed and capability balance
-# whisper-1 is standard for transcription via API.
-# gpt-3.5-turbo is generally fast for summarization/chat.
 TRANSCRIPTION_MODEL = "whisper-1"
 LANGUAGE_MODEL = "gpt-3.5-turbo"
 # Approximate context window limit for the language model (input tokens)
-# Leaving space for prompt overhead and response generation.
-# Check OpenAI docs for the specific version deployed if needed.
-MAX_TOKENS_FOR_SUMMARY_INPUT = 3500 # Adjusted slightly for safety margin
+MAX_TOKENS_FOR_SUMMARY_INPUT = 3500
 MAX_TOKENS_FOR_CHAT_INPUT = 3500 # Context + Question
 AUDIO_SIZE_LIMIT_MB = 25 # OpenAI API limit
 
@@ -57,14 +53,12 @@ def truncate_text_by_tokens(text, max_tokens):
             return text
         except Exception as e:
              st.warning(f"Token encoding/decoding failed during truncation: {e}. Using word count fallback.")
-             # Fallback truncation
              words = text.split()
-             estimated_words = int(max_tokens * 0.7) # Rough estimate words per token
+             estimated_words = int(max_tokens * 0.7)
              return " ".join(words[:estimated_words])
     else:
-        # Fallback truncation if tiktoken failed to initialize
         words = text.split()
-        estimated_words = int(max_tokens * 0.7) # Rough estimate
+        estimated_words = int(max_tokens * 0.7)
         return " ".join(words[:estimated_words])
 
 # --- Core Functions ---
@@ -72,7 +66,6 @@ def truncate_text_by_tokens(text, max_tokens):
 def initialize_openai():
     """Initializes OpenAI API key from Streamlit secrets."""
     try:
-        # Fetch API key from Hugging Face secrets
         api_key = st.secrets["OPENAI_API_KEY"]
         if not api_key:
             st.error("OpenAI API Key not found in Secrets. Please add 'OPENAI_API_KEY' to your Hugging Face Space secrets.")
@@ -96,7 +89,6 @@ def transcribe_audio(audio_file):
     try:
         audio = AudioSegment.from_file(audio_file)
         buffer = io.BytesIO()
-        # Export as WAV for broad compatibility with Whisper
         audio.export(buffer, format="wav")
         buffer.seek(0)
         buffer.name = "audio.wav" # Required by OpenAI API
@@ -118,14 +110,12 @@ def transcribe_audio(audio_file):
          return None
     except Exception as e:
         st.error(f"Error during audio transcription: {str(e)}")
-        # Log detailed error for debugging if needed (visible in Hugging Face logs)
         print(f"Transcription Error Traceback:\n{traceback.format_exc()}")
         return None
 
 def extract_text_from_pdf(pdf_file):
     """Extracts text from a PDF using PyMuPDF."""
     try:
-        # Read file bytes directly for PyMuPDF
         pdf_bytes = pdf_file.getvalue()
         doc = fitz.open(stream=pdf_bytes, filetype="pdf")
         text = ""
@@ -134,7 +124,7 @@ def extract_text_from_pdf(pdf_file):
         doc.close()
         if not text.strip():
              st.warning("No text could be extracted. The PDF might be image-based (scanned) or empty.")
-             return "" # Return empty string, not None, to avoid downstream errors
+             return ""
         return text
     except Exception as e:
         st.error(f"Error reading PDF: {str(e)}")
@@ -144,28 +134,41 @@ def extract_text_from_pdf(pdf_file):
 def get_youtube_transcript(url):
     """Gets English transcript from a YouTube video."""
     try:
+        video_id = None
         if "watch?v=" in url:
             video_id = url.split("watch?v=")[1].split("&")[0]
-        # Add other common formats if needed, e.g., youtu.be/
-        elif "youtu.be//" in url:
-             # Be careful with splitting logic for different URL structures
-             # This is a guess, adjust based on actual URLs you encounter
-             video_id = url.split("youtu.be//")[1].split("?")[0]
+        elif "youtu.be/" in url:
+             video_id = url.split("youtu.be/")[1].split("?")[0]
+        elif "youtu.be/" in url:
+            video_id = url.split("/")[-1].split("?")[0]
         elif "youtu.be//" in url:
             video_id = url.split("/")[-1].split("?")[0]
         else:
-            # Basic check for other potential valid IDs (e.g., short URLs)
-            # This might need refinement
+            # Basic check for other potential valid IDs (e.g., youtu.be links)
             parts = url.split("/")
-            if len(parts[-1]) == 11: # Common length for YouTube IDs
-                 video_id = parts[-1].split("?")[0]
+            potential_id = parts[-1].split("?")[0]
+            if len(potential_id) == 11: # Common length for YouTube IDs
+                 video_id = potential_id
             else:
-                 st.error("Could not automatically determine Video ID from URL.")
+                 st.error("Could not automatically determine Video ID from URL. Please use standard 'watch?v=' URL.")
                  return None
 
+        if not video_id:
+            st.error("Failed to extract video ID.")
+            return None
+
         transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
-        # Try fetching English first, fallback might be needed if desired
-        transcript = transcript_list.find_generated_transcript(['en']) # Or find_manually_created_transcript
+        try:
+             # Prioritize manual transcripts, fallback to generated
+             transcript = transcript_list.find_manually_created_transcript(['en'])
+        except NoTranscriptFound:
+             try:
+                 transcript = transcript_list.find_generated_transcript(['en'])
+                 st.info("Using auto-generated English transcript.")
+             except NoTranscriptFound:
+                 st.warning(f"No English transcript (manual or generated) found for video: {url}")
+                 return None
+
         transcript_data = transcript.fetch()
         transcription_text = "\n".join(
             [f"[{entry['start']:.2f}-{entry['start']+entry['duration']:.2f}] {entry['text']}" for entry in transcript_data]
@@ -174,9 +177,6 @@ def get_youtube_transcript(url):
     except TranscriptsDisabled:
         st.error(f"Transcripts are disabled for video: {url}")
         return None
-    except NoTranscriptFound:
-        st.warning(f"No English transcript found for video: {url}. Auto-generated transcripts might exist in other languages.")
-        return None
     except Exception as e:
         st.error(f"Error fetching YouTube transcript: {str(e)}")
         print(f"YouTube Transcript Error Traceback:\n{traceback.format_exc()}")
@@ -186,37 +186,33 @@ def generate_summary(text_to_summarize, max_output_tokens=800):
     """Generates summary using OpenAI API, handling potential truncation."""
     input_token_count = count_tokens(text_to_summarize)
 
-    # Check if input text needs truncation BEFORE sending to API
     if input_token_count > MAX_TOKENS_FOR_SUMMARY_INPUT:
         st.warning(f"Input text ({input_token_count} tokens) exceeds the limit ({MAX_TOKENS_FOR_SUMMARY_INPUT} tokens) for the summarization model. Truncating input.")
         text_to_summarize = truncate_text_by_tokens(text_to_summarize, MAX_TOKENS_FOR_SUMMARY_INPUT)
-        input_token_count = count_tokens(text_to_summarize) # Recount after truncation
+        input_token_count = count_tokens(text_to_summarize) # Recount
 
     if not text_to_summarize:
          st.error("Input text for summarization is empty.")
          return None
 
-    # Ensure we leave enough tokens for the output
-    # The API calculates this, but good practice to have a buffer
-    # max_tokens in create() limits the *output* length
     prompt = f"Summarize the following text comprehensively, focusing on key points, concepts, and conclusions. Aim for a detailed summary but keep it concise where possible:\n\n{text_to_summarize}"
 
     try:
         response = openai.ChatCompletion.create(
             model=LANGUAGE_MODEL,
             messages=[{'role': 'user', 'content': prompt}],
-            max_tokens=max_output_tokens, # Limit the length of the generated summary
-            temperature=0.5 # Adjust temperature for creativity vs factuality
+            max_tokens=max_output_tokens,
+            temperature=0.5
         )
         return response.choices[0].message.content.strip()
     except openai.error.AuthenticationError:
          st.error("Authentication Error: Invalid OpenAI API Key provided in Secrets.")
          return None
     except openai.error.RateLimitError:
-         st.error("OpenAI API Rate Limit Exceeded during summarization. Please check your usage or wait.")
+         st.error("OpenAI API Rate Limit Exceeded during summarization.")
          return None
     except openai.error.InvalidRequestError as e:
-         st.error(f"Invalid Request during summarization: {e}. This might be due to content policy or exceeding model limits.")
+         st.error(f"Invalid Request during summarization: {e}.")
          return None
     except Exception as e:
         st.error(f"Error during summary generation: {str(e)}")
@@ -229,36 +225,32 @@ def chat_with_ai(question, context, max_output_tokens=500):
         st.warning("Please enter a question.")
         return None
     if not context:
-         st.error("Cannot answer question: No context (summary or text) available.")
+         st.error("Cannot answer question: No context available.")
          return None
 
     prompt = f"Based *only* on the following content:\n\n---\n{context}\n---\n\nAnswer the question: {question}"
     prompt_token_count = count_tokens(prompt)
 
-    # Check if prompt exceeds model limits
     if prompt_token_count > MAX_TOKENS_FOR_CHAT_INPUT:
-        st.error(f"The question and context combined ({prompt_token_count} tokens) exceed the model's input limit ({MAX_TOKENS_FOR_CHAT_INPUT} tokens). Please shorten the context or ask a more concise question.")
-        # Alternative: Truncate context here if desired, but might lose info
-        # context = truncate_text_by_tokens(context, MAX_TOKENS_FOR_CHAT_INPUT - count_tokens(f"Answer the question: {question}") - 50) # Rough context truncation
-        # prompt = f"Based *only* on the following content:\n\n---\n{context}\n---\n\nAnswer the question: {question}"
+        st.error(f"The question and context combined ({prompt_token_count} tokens) exceed the model's input limit ({MAX_TOKENS_FOR_CHAT_INPUT} tokens). Try using the summary as context or ask a shorter question.")
         return None
 
     try:
         response = openai.ChatCompletion.create(
             model=LANGUAGE_MODEL,
             messages=[{'role': 'user', 'content': prompt}],
-            max_tokens=max_output_tokens, # Limit answer length
-            temperature=0.3 # Lower temperature for more factual answers based on context
+            max_tokens=max_output_tokens,
+            temperature=0.3
         )
         return response.choices[0].message.content.strip()
     except openai.error.AuthenticationError:
          st.error("Authentication Error: Invalid OpenAI API Key provided in Secrets.")
          return None
     except openai.error.RateLimitError:
-         st.error("OpenAI API Rate Limit Exceeded during chat. Please check your usage or wait.")
+         st.error("OpenAI API Rate Limit Exceeded during chat.")
          return None
     except openai.error.InvalidRequestError as e:
-         st.error(f"Invalid Request during chat: {e}. This might be due to content policy or exceeding model limits.")
+         st.error(f"Invalid Request during chat: {e}.")
          return None
     except Exception as e:
         st.error(f"Error during AI chat: {str(e)}")
@@ -269,39 +261,87 @@ def chat_with_ai(question, context, max_output_tokens=500):
 def main():
     st.set_page_config(layout="wide", page_title="AI Summarization Bot")
 
-    # --- Styling (Optional) ---
+    # --- Styling (Restored Original CSS) ---
     st.markdown("""
         <style>
-        /* Add your custom CSS here if needed */
         .stApp {
-            /* background: linear-gradient(....); */ /* Example */
+            background: linear-gradient(180deg,
+                rgba(64,224,208,0.7) 0%,
+                rgba(32,112,104,0.4) 35%,
+                rgba(0,0,0,0) 100%
+            );
         }
+        /* Attempt to make sidebar slightly transparent if needed */
+        div[data-testid="stSidebarContent"] {
+            background-color: rgba(255,255,255,0.1) !important; /* May need tweaking */
+        }
+        /* Style markdown text */
+        .stMarkdown p, .stMarkdown li, .stText, .stAlert p {
+            color: #ffffff !important; /* White text for markdown, etc. */
+        }
+        /* Text Area Styling */
         .stTextArea textarea {
-            /* background-color: #f0f0f0 !important; */ /* Example */
-            /* color: #333 !important; */ /* Example */
+            background-color: rgba(0, 0, 0, 0.6) !important; /* Darker transparent background */
+            color: #ffffff !important; /* White text */
+            border: 1px solid rgba(255, 255, 255, 0.3); /* Subtle border */
+            max-height: 400px; /* Ensure scroll height */
+            overflow-y: auto !important;
+        }
+        /* Input Text Styling */
+        .stTextInput input {
+            color: white !important;
+            background-color: rgba(0, 0, 0, 0.5) !important;
+             border: 1px solid rgba(255, 255, 255, 0.3);
+        }
+        /* Button Styling */
+        .stButton button {
+            background-color: #40E0D0; /* Turquoise */
+            color: black;
+            border: none;
+            padding: 0.5rem 1rem;
+            border-radius: 5px;
+            font-weight: bold;
+        }
+        .stButton button:hover {
+            background-color: #48D1CC; /* Slightly darker turquoise */
+            color: black;
+        }
+        /* Headings */
+        h1, h2, h3, h4, h5, h6 {
+            color: white !important;
         }
-        h1, h2, h3 {
-            /* color: #your_color !important; */ /* Example */
+        /* Specific text elements like radio buttons, selectbox labels */
+        .stRadio label, .stSelectbox label, .stFileUploader label {
+             color: white !important;
         }
-        /* Make text areas scrollable */
+        /* Sidebar Header */
+        [data-testid="stSidebar"] [data-testid="stVerticalBlock"] {
+            color: white !important;
+        }
+        [data-testid="stSidebar"] h1, [data-testid="stSidebar"] h2, [data-testid="stSidebar"] h3 {
+             color: white !important;
+        }
+        [data-testid="stSidebar"] p, [data-testid="stSidebar"] li {
+              color: white !important;
+        }
+
+        /* Make text areas scrollable if content exceeds max-height */
          div[data-baseweb="textarea"] > div > textarea {
-            max-height: 400px; /* Adjust as needed */
             overflow-y: auto !important;
         }
         </style>
     """, unsafe_allow_html=True)
 
     st.markdown("<h1 style='text-align: center;'>AI Summarization Bot 🤖</h1>", unsafe_allow_html=True)
-    st.markdown("<p style='text-align: center;'>Upload Audio/PDF or provide YouTube URL for Transcription & Summary</p>", unsafe_allow_html=True)
+    # Removed redundant description paragraph as title is descriptive
 
     # Initialize OpenAI API Key
-    # This should run early, ideally once per session if key doesn't change
     if 'openai_initialized' not in st.session_state:
         st.session_state['openai_initialized'] = initialize_openai()
 
     if not st.session_state.get('openai_initialized'):
         st.warning("OpenAI initialization failed. Please ensure your API key is correctly set in Hugging Face secrets and refresh.")
-        st.stop() # Stop execution if key is not valid/found
+        st.stop()
 
     # --- Sidebar for Inputs ---
     st.sidebar.header("Input Options")
@@ -314,16 +354,20 @@ def main():
         st.session_state['summary'] = None
     if 'last_input_type' not in st.session_state:
         st.session_state['last_input_type'] = None
-    if 'last_input_data_key' not in st.session_state: # Track input data reference
+    if 'last_input_data_key' not in st.session_state:
         st.session_state['last_input_data_key'] = None
+    if 'current_input_key' not in st.session_state:
+        st.session_state['current_input_key'] = None
+
 
     # Clear results if input type changes
     if st.session_state['last_input_type'] != input_type:
         st.session_state['full_text'] = None
         st.session_state['summary'] = None
-        st.session_state['last_input_data_key'] = None # Reset input tracker too
+        st.session_state['last_input_data_key'] = None
+        st.session_state['current_input_key'] = None # Reset current key too
 
-    st.session_state['last_input_type'] = input_type # Update current type
+    st.session_state['last_input_type'] = input_type
 
     # --- Input Elements ---
     uploaded_file = None
@@ -331,41 +375,60 @@ def main():
     process_button_pressed = False
 
     if input_type == "Audio File":
-        uploaded_file = st.sidebar.file_uploader("Upload audio file (Max 25MB)", type=["mp3", "wav", "m4a", "ogg", "webm"], key="audio_uploader") # Added more types pydub might handle
+        uploaded_file = st.sidebar.file_uploader("Upload audio file (Max 25MB)", type=["mp3", "wav", "m4a", "ogg", "webm"], key="audio_uploader")
         if uploaded_file:
-             st.session_state['current_input_key'] = uploaded_file.id # Use file ID as key
+             # Use file name and size as the key instead of non-existent .id
+             st.session_state['current_input_key'] = f"{uploaded_file.name}-{uploaded_file.size}"
     elif input_type == "PDF Document":
         uploaded_file = st.sidebar.file_uploader("Upload PDF document", type=["pdf"], key="pdf_uploader")
         if uploaded_file:
-             st.session_state['current_input_key'] = uploaded_file.id
+             # Use file name and size as the key
+             st.session_state['current_input_key'] = f"{uploaded_file.name}-{uploaded_file.size}"
     elif input_type == "YouTube URL":
-        youtube_url = st.sidebar.text_input("Enter YouTube URL (must have subtitles)", key="youtube_input")
+        youtube_url = st.sidebar.text_input("Enter YouTube URL", key="youtube_input", placeholder="e.g., https://www.youtube.com/watch?v=...")
         if youtube_url:
              st.session_state['current_input_key'] = youtube_url # Use URL as key
 
+    st.sidebar.markdown("---") # Separator
+    st.sidebar.markdown("### Steps:")
+    st.sidebar.markdown("1. Select input type & provide source.")
+    st.sidebar.markdown("2. Click 'Generate Summary & Notes'.")
+    st.sidebar.markdown("3. Review results and use chat if needed.")
+
+
     # Single "Generate" button
-    if st.sidebar.button("Generate Summary & Notes", key="generate_button"):
-         # Check if new input is provided or if it's the same as last time
-         if 'current_input_key' in st.session_state and st.session_state['current_input_key'] != st.session_state['last_input_data_key']:
-              # New input detected, clear old results and process
-              st.session_state['full_text'] = None
-              st.session_state['summary'] = None
-              st.session_state['last_input_data_key'] = st.session_state['current_input_key'] # Update tracker
-              process_button_pressed = True
-         elif 'current_input_key' not in st.session_state or not st.session_state['current_input_key']:
-              st.warning("Please provide input (upload file or enter URL) before generating.")
+    if st.sidebar.button("Generate Summary & Notes", key="generate_button", use_container_width=True): # Make button wider
+         current_key = st.session_state.get('current_input_key')
+         # Check if input is provided for the selected type
+         valid_input_provided = False
+         if input_type == "Audio File" and uploaded_file:
+             valid_input_provided = True
+         elif input_type == "PDF Document" and uploaded_file:
+             valid_input_provided = True
+         elif input_type == "YouTube URL" and youtube_url:
+             valid_input_provided = True
+
+         if valid_input_provided:
+             # Check if it's a *new* input compared to the last processed one
+             if current_key != st.session_state.get('last_input_data_key'):
+                 st.session_state['full_text'] = None
+                 st.session_state['summary'] = None
+                 st.session_state['last_input_data_key'] = current_key
+                 process_button_pressed = True
+             else:
+                 # Input hasn't changed, check if results already exist
+                 if st.session_state.get('full_text') or st.session_state.get('summary'):
+                     st.info("Results for the current input are already displayed. Upload a new file or URL to generate again.")
+                 else: # Results don't exist for some reason, re-process
+                      process_button_pressed = True
          else:
-              # Same input as before, maybe re-process? For now, just indicate it's done if results exist
-              if st.session_state['full_text'] or st.session_state['summary']:
-                  st.info("Results for the current input are already displayed.")
-              else: # If results somehow got cleared, reprocess
-                  process_button_pressed = True
+              st.warning("Please provide input (upload file or enter URL) before generating.")
 
 
     # --- Processing Logic ---
     if process_button_pressed:
         extracted_text = None
-        input_valid = False
+        input_valid = False # Re-check validity just before processing
 
         if input_type == "Audio File" and uploaded_file:
             input_valid = True
@@ -380,58 +443,63 @@ def main():
             with st.spinner('Fetching YouTube transcript...'):
                 extracted_text = get_youtube_transcript(youtube_url)
 
-        if input_valid and extracted_text is not None: # Check for None from failed extraction
+        if input_valid and extracted_text is not None:
             st.session_state['full_text'] = extracted_text
             if extracted_text: # Only summarize if text extraction was successful
                  with st.spinner('Generating summary...'):
                       summary_text = generate_summary(extracted_text)
                       st.session_state['summary'] = summary_text
                       if not summary_text:
-                           st.error("Summary generation failed.")
+                           st.error("Summary generation failed.") # Keep error message if summary is None
             else:
                  st.warning("Text extraction resulted in empty content. Cannot generate summary.")
-                 st.session_state['summary'] = None # Ensure summary is None if text is empty
+                 st.session_state['summary'] = None
         elif input_valid and extracted_text is None:
-             # Error message already shown in extraction function
+             # Error already shown in extraction func OR warning shown if text was empty
              st.session_state['full_text'] = None
              st.session_state['summary'] = None
 
 
     # --- Display Results ---
+    # Use columns only if there's something to display to avoid empty columns
     if st.session_state.get('full_text') or st.session_state.get('summary'):
-        st.markdown("---")
-        col1, col2 = st.columns([1, 1]) # Equal columns
+        st.markdown("---") # Separator before results
+        col1, col2 = st.columns([1, 1])
 
         with col1:
             st.markdown("<h3>Full Text / Transcription</h3>", unsafe_allow_html=True)
-            if st.session_state.get('full_text'):
-                 # Display full text, truncate display if extremely long for UI performance
-                 display_text = st.session_state['full_text']
-                 if len(display_text) > 100000: # Arbitrary limit for UI
-                      display_text = display_text[:100000] + "\n\n... (Text truncated for display)"
-                 st.text_area("Full Content", display_text, height=400, key="full_text_area")
+            full_text_content = st.session_state.get('full_text')
+            if full_text_content:
+                 display_text = full_text_content
+                 # Simple truncation for display performance, not affecting summary/chat context
+                 if len(display_text) > 150000:
+                      display_text = display_text[:150000] + "\n\n... (Text truncated for display performance)"
+                 st.text_area("Full Content:", display_text, height=400, key="full_text_area", label_visibility="collapsed")
             else:
-                 st.info("No text extracted or transcribed.")
+                 # Show placeholder only if generation was attempted but failed/empty
+                 if st.session_state.get('last_input_data_key') and process_button_pressed: # Check if process was triggered
+                      st.info("No text extracted or transcribed.")
 
         with col2:
             st.markdown("<h3>Generated Summary</h3>", unsafe_allow_html=True)
-            if st.session_state.get('summary'):
-                 st.text_area("Summary", st.session_state['summary'], height=400, key="summary_area")
-            elif st.session_state.get('full_text'):
-                 st.warning("Summary could not be generated.")
+            summary_content = st.session_state.get('summary')
+            if summary_content:
+                 st.text_area("Summary:", summary_content, height=400, key="summary_area", label_visibility="collapsed")
             else:
-                 st.info("Generate content first to see summary.")
+                 # Show placeholder only if generation was attempted but failed/empty
+                 if st.session_state.get('last_input_data_key') and process_button_pressed:
+                      st.warning("Summary could not be generated.")
 
         # --- Chat Section ---
         st.markdown("---")
         st.markdown("<h3>Chat with AI about the Content</h3>", unsafe_allow_html=True)
 
-        # Option to choose context for chat
         context_option = st.radio(
             "Use as chat context:",
             ('Generated Summary', 'Full Text'),
             key='chat_context_option',
-            horizontal=True
+            horizontal=True,
+            label_visibility="collapsed" # Hide label for radio itself
         )
 
         chat_context = None
@@ -444,31 +512,43 @@ def main():
                 st.warning("Summary not available for chat context.")
         else: # Full Text option
             if st.session_state.get('full_text'):
-                 # Important: Use truncated text if original was too long for chat model
-                 chat_context = truncate_text_by_tokens(st.session_state['full_text'], MAX_TOKENS_FOR_CHAT_INPUT - 500) # Leave room for question+response
-                 if len(st.session_state['full_text']) > len(chat_context):
-                      context_name = "Full Text (Truncated)"
+                 full_text_for_chat = st.session_state['full_text']
+                 # Truncate context *before* passing to chat if needed
+                 # Estimate tokens needed for question + response buffer
+                 max_context_tokens = MAX_TOKENS_FOR_CHAT_INPUT - 500
+                 chat_context = truncate_text_by_tokens(full_text_for_chat, max_context_tokens)
+
+                 if len(full_text_for_chat) > len(chat_context):
+                      context_name = "Full Text (Truncated for Chat)"
                  else:
                       context_name = "Full Text"
             else:
                 st.warning("Full text not available for chat context.")
 
         if chat_context:
-             st.info(f"Chatting based on: **{context_name}**")
-             question = st.text_input("Ask a question:", key="chat_question")
-             if st.button("Ask AI", key="ask_ai_button"):
+             # Display which context is being used subtly
+             st.markdown(f"<small style='color: #cccccc;'>Chatting based on: **{context_name}**</small>", unsafe_allow_html=True)
+             question = st.text_input("Ask a question:", key="chat_question", placeholder="Ask anything about the selected context...")
+             if st.button("Ask AI", key="ask_ai_button", use_container_width=True):
                  if question:
                      with st.spinner("AI is thinking..."):
                           answer = chat_with_ai(question, chat_context)
                           if answer:
                                st.markdown("**AI Answer:**")
-                               st.write(answer)
+                               # Use markdown for potentially better formatting of AI response
+                               st.markdown(answer)
                           else:
                                st.error("Failed to get an answer from the AI.")
                  else:
                      st.warning("Please enter a question first.")
         else:
-             st.markdown("_(Generate content or summary first to enable chat)_")
+             # Only show message if processing was attempted for current input
+              if st.session_state.get('last_input_data_key'):
+                   st.markdown("_(Generate content or summary first to enable chat)_")
+
+    # Add footer or instructions if desired
+    st.sidebar.markdown("---")
+    st.sidebar.info("Powered by OpenAI Whisper & GPT models.")
 
 
 if __name__ == "__main__":