Complete project overhaul and feature integration

.gitignore

@@ -1,3 +1,5 @@
+# D:\jan-contract\.gitignore
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.pyc
@@ -9,4 +11,20 @@ __pycache__/
 venv/
 
 # IDE
-.vscode/
+.vscode/
+
+# --- NEW: Files and Folders to Ignore ---
+
+# Ignore user-uploaded content directories
+pdfs_demystify/
+video_consents/
+
+# Ignore temporary test files
+# Using wildcards (*) to catch all of them
+test_*.py
+minimal_*.py
+simple_*.py
+run_app.py # Assuming this is a local runner, not part of the final project
+
+# You can also ignore specific files
+# TROUBLESHOOTING.md # Uncomment this line if you DON'T want to save this file

TROUBLESHOOTING.md

@@ -0,0 +1,116 @@
+# 🎥 Audio/Video Troubleshooting Guide
+
+## Common Issues and Solutions
+
+### 1. Video Recording Issues
+
+**Problem:** Video recording creates 0-second files or doesn't work at all.
+
+**Solutions:**
+- **Browser Compatibility**: Use Chrome, Firefox, or Edge. Safari may have issues.
+- **Camera Permissions**: Make sure to allow camera access when prompted.
+- **HTTPS Required**: Some browsers require HTTPS for camera access. Use `streamlit run --server.address 0.0.0.0 --server.port 8501` for local testing.
+- **Refresh Page**: If buttons don't respond, try refreshing the page.
+
+### 2. Audio Recording Issues
+
+**Problem:** Voice input doesn't work or produces no audio.
+
+**Solutions:**
+- **Microphone Permissions**: Allow microphone access when prompted.
+- **Browser Settings**: Check browser settings for microphone permissions.
+- **Clear Browser Cache**: Clear browser cache and cookies.
+- **Try Different Browser**: Some browsers handle WebRTC better than others.
+
+### 3. Dependencies Issues
+
+**Problem:** Import errors or missing modules.
+
+**Solutions:**
+```bash
+# Install all dependencies
+pip install -r requirements.txt
+
+# If you get errors, try installing individually:
+pip install streamlit-webrtc
+pip install opencv-python-headless
+pip install av
+pip install SpeechRecognition
+pip install gTTS
+pip install PyAudio
+```
+
+### 4. Windows-Specific Issues
+
+**Problem:** PyAudio installation fails on Windows.
+
+**Solutions:**
+```bash
+# Try installing PyAudio with pipwin
+pip install pipwin
+pipwin install pyaudio
+
+# Or download from: https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyaudio
+```
+
+### 5. Performance Issues
+
+**Problem:** Slow video/audio processing.
+
+**Solutions:**
+- **Reduce Video Quality**: The app uses 640x480 resolution by default.
+- **Close Other Apps**: Close other applications using camera/microphone.
+- **Check System Resources**: Ensure sufficient RAM and CPU available.
+
+## Testing Your Setup
+
+Run the test script to verify everything is working:
+
+```bash
+streamlit run test_audio_video.py
+```
+
+This will check:
+- ✅ All dependencies are installed
+- ✅ Directories are writable
+- ✅ Basic functionality
+
+## Browser Requirements
+
+- **Chrome**: Best compatibility
+- **Firefox**: Good compatibility
+- **Edge**: Good compatibility
+- **Safari**: Limited compatibility (not recommended)
+
+## Network Requirements
+
+- **Local Development**: Works fine on localhost
+- **Production**: HTTPS required for camera/microphone access
+- **Firewall**: Ensure ports 8501 (or your chosen port) is accessible
+
+## Error Messages and Solutions
+
+| Error | Solution |
+|-------|----------|
+| "Camera not found" | Check camera permissions and browser settings |
+| "Microphone not found" | Check microphone permissions and browser settings |
+| "WebRTC not supported" | Update browser or try different browser |
+| "Permission denied" | Allow camera/microphone access in browser |
+| "Video file too small" | Record for at least 2-3 seconds |
+
+## Getting Help
+
+If you're still having issues:
+
+1. Check the browser console for JavaScript errors
+2. Run the test script: `streamlit run test_audio_video.py`
+3. Check if your camera/microphone work in other applications
+4. Try a different browser
+5. Restart the Streamlit server
+
+## Development Tips
+
+- Use `st.debug()` to add debugging information
+- Check `st.session_state` for state management issues
+- Monitor browser console for WebRTC errors
+- Test on different devices and browsers

agents/general_assistant_agent.py

@@ -0,0 +1,27 @@
+# D:\jan-contract\agents\general_assistant_agent.py
+
+import os
+import google.generativeai as genai
+
+# Configure the API key from the .env file
+try:
+    genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+    # Use a specific, robust model name
+    model = genai.GenerativeModel('gemini-1.5-flash')
+except Exception as e:
+    print(f"Error configuring Google Generative AI: {e}")
+    model = None
+
+def ask_gemini(prompt: str) -> str:
+    """
+    Sends a prompt directly to the Google Gemini API and returns the text response.
+    This is the core logic from your script, adapted for our application.
+    """
+    if model is None:
+        return "Error: The Generative AI model is not configured. Please check your API key."
+    
+    try:
+        response = model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        return f"An error occurred while communicating with the Gemini API: {str(e)}"

components/chat_interface.py

@@ -0,0 +1,227 @@
+# D:\jan-contract\components/chat_interface.py
+
+import streamlit as st
+import speech_recognition as sr
+from gtts import gTTS
+import io
+import av
+import queue
+import wave
+import threading
+import time
+import numpy as np
+from typing import Optional
+
+from streamlit_webrtc import webrtc_streamer, WebRtcMode
+
+# --- Setup ---
+recognizer = sr.Recognizer()
+recognizer.energy_threshold = 300  # Lower threshold for better sensitivity
+recognizer.dynamic_energy_threshold = True
+recognizer.pause_threshold = 0.8
+
+def text_to_speech(text: str) -> bytes:
+    """Converts text to an in-memory MP3 file bytes."""
+    try:
+        audio_io = io.BytesIO()
+        tts = gTTS(text=text, lang='en', slow=False)
+        tts.write_to_fp(audio_io)
+        audio_io.seek(0)
+        return audio_io.read()
+    except Exception as e:
+        st.error(f"Error during Text-to-Speech: {e}")
+        return None
+
+def chat_interface(handler_function, session_state_key: str):
+    """
+    A reusable component that provides a full Text and Voice chat interface.
+
+    Args:
+        handler_function: The function to call with the user's text input.
+        session_state_key (str): A unique key to store chat history AND to use
+                                 as a base for widget keys.
+    """
+    st.subheader("💬 Chat via Text")
+    
+    if session_state_key not in st.session_state:
+        st.session_state[session_state_key] = []
+
+    for message in st.session_state[session_state_key]:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+    
+    if prompt := st.chat_input("Ask a question...", key=f"chat_input_{session_state_key}"):
+        st.session_state[session_state_key].append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        with st.chat_message("assistant"):
+            with st.spinner("Thinking..."):
+                response = handler_function(prompt)
+                st.markdown(response)
+        
+        st.session_state[session_state_key].append({"role": "assistant", "content": response})
+
+    st.divider()
+
+    st.subheader("🎙️ Chat via Voice")
+    st.info("🎤 **Instructions:** Click START to begin recording, speak your question clearly, then click STOP.")
+
+    # Initialize session state for voice recording
+    voice_key = f"voice_{session_state_key}"
+    if f"{voice_key}_frames" not in st.session_state:
+        st.session_state[f"{voice_key}_frames"] = []
+    if f"{voice_key}_processing" not in st.session_state:
+        st.session_state[f"{voice_key}_processing"] = False
+    if f"{voice_key}_recording_start" not in st.session_state:
+        st.session_state[f"{voice_key}_recording_start"] = None
+    if f"{voice_key}_bytes" not in st.session_state:
+        st.session_state[f"{voice_key}_bytes"] = 0
+    if f"{voice_key}_component_key" not in st.session_state:
+        st.session_state[f"{voice_key}_component_key"] = f"voice-chat-{session_state_key}-{int(time.time())}"
+
+    def audio_frame_callback(frame: av.AudioFrame):
+        """Callback to collect audio frames during recording"""
+        if st.session_state[f"{voice_key}_processing"]:
+            try:
+                # Resample every frame to 16kHz mono, 16-bit PCM for SR
+                resampled = frame.reformat(format="s16", layout="mono", rate=16000)
+                chunk = resampled.planes[0].to_bytes()
+                st.session_state[f"{voice_key}_frames"].append(chunk)
+                st.session_state[f"{voice_key}_bytes"] += len(chunk)
+            except Exception as e:
+                st.error(f"Error processing audio frame: {e}")
+
+    def process_voice_input():
+        """Process the collected audio frames and get response"""
+        # Short-audio threshold (~0.5s at 16kHz, 16-bit mono)
+        total_bytes = st.session_state.get(f"{voice_key}_bytes", 0)
+        if total_bytes < int(16000 * 2 * 0.5):
+            st.error("❌ No audio captured or recording too short. Please speak for at least 1 second and try again.")
+            st.session_state[f"{voice_key}_frames"] = []
+            st.session_state[f"{voice_key}_processing"] = False
+            st.session_state[f"{voice_key}_bytes"] = 0
+            return
+
+        status_placeholder = st.empty()
+        status_placeholder.info("🔄 Processing audio...")
+
+        try:
+            # Combine all audio frames (already PCM s16 mono 16kHz)
+            audio_data = b"".join(st.session_state[f"{voice_key}_frames"])
+            
+            # Create WAV file in memory with proper format
+            with io.BytesIO() as wav_buffer:
+                with wave.open(wav_buffer, 'wb') as wf:
+                    wf.setnchannels(1)  # Mono
+                    wf.setsampwidth(2)  # 16-bit
+                    wf.setframerate(16000)  # 16kHz
+                    wf.writeframes(audio_data)
+                wav_buffer.seek(0)
+                
+                # Use speech recognition with better error handling
+                with sr.AudioFile(wav_buffer) as source:
+                    # Adjust for ambient noise quickly; avoid long pauses
+                    recognizer.adjust_for_ambient_noise(source, duration=0.1)
+                    audio = recognizer.record(source)
+                
+                # Recognize speech with multiple fallbacks
+                try:
+                    user_input = recognizer.recognize_google(audio, language="en-US")
+                except sr.UnknownValueError:
+                    try:
+                        user_input = recognizer.recognize_google(audio, language="en-GB")
+                    except sr.UnknownValueError:
+                        st.error("❌ Could not understand the audio. Please speak more clearly and try again.")
+                        return
+                
+                if not user_input.strip():
+                    st.error("❌ No speech detected. Please try again.")
+                    return
+                
+                st.write(f"🎤 **You said:** *{user_input}*")
+                
+                # Get response from handler
+                with st.spinner("🤔 Getting response..."):
+                    response_text = handler_function(user_input)
+                
+                st.write(f"🤖 **Assistant says:** *{response_text}*")
+                
+                # Generate audio response
+                with st.spinner("🔊 Generating audio response..."):
+                    audio_response = text_to_speech(response_text)
+                    if audio_response:
+                        st.audio(audio_response, format="audio/mp3", start_time=0)
+                        st.success("✅ Audio response generated!")
+                
+                # Add to chat history
+                st.session_state[session_state_key].append({"role": "user", "content": user_input})
+                st.session_state[session_state_key].append({"role": "assistant", "content": response_text})
+
+        except sr.RequestError as e:
+            st.error(f"❌ Speech recognition service error: {e}")
+        except Exception as e:
+            st.error(f"❌ Error processing audio: {str(e)}")
+        finally:
+            # Clear the audio frames
+            st.session_state[f"{voice_key}_frames"] = []
+            st.session_state[f"{voice_key}_processing"] = False
+            st.session_state[f"{voice_key}_bytes"] = 0
+            status_placeholder.empty()
+
+    # Create a unique key for each component instance to avoid registration issues
+    component_key = st.session_state[f"{voice_key}_component_key"]
+    
+    # WebRTC streamer with proper error handling and component lifecycle
+    try:
+        ctx = webrtc_streamer(
+            key=component_key,
+            mode=WebRtcMode.SENDONLY,
+            rtc_configuration={
+                "iceServers": [
+                    {"urls": ["stun:stun.l.google.com:19302"]},
+                    {"urls": ["stun:stun1.l.google.com:19302"]}
+                ]
+            },
+            audio_frame_callback=audio_frame_callback,
+            media_stream_constraints={
+                "video": False,
+                "audio": {
+                    "echoCancellation": True,
+                    "noiseSuppression": True,
+                    "autoGainControl": True
+                }
+            },
+            async_processing=True,
+            on_change=lambda: None,  # Prevent component registration issues
+        )
+        
+        # Handle recording state with better feedback
+        bytes_captured = st.session_state.get(f"{voice_key}_bytes", 0)
+        
+        if ctx.state.playing and not st.session_state.get(f"{voice_key}_processing", False):
+            st.session_state[f"{voice_key}_processing"] = True
+            st.session_state[f"{voice_key}_recording_start"] = time.time()
+            st.session_state[f"{voice_key}_frames"] = []
+            st.session_state[f"{voice_key}_bytes"] = 0
+            st.success("🔴 **Recording started!** Speak your question now...")
+            
+        elif ctx.state.playing and st.session_state.get(f"{voice_key}_processing", False):
+            # Show recording progress
+            if st.session_state.get(f"{voice_key}_recording_start"):
+                elapsed = time.time() - st.session_state[f"{voice_key}_recording_start"]
+                approx_seconds = bytes_captured / (16000 * 2) if bytes_captured else 0
+                st.caption(f"🎤 Recording... ~{approx_seconds:.1f}s captured")
+        
+        # Process audio when recording stops
+        if not ctx.state.playing and st.session_state.get(f"{voice_key}_processing", False):
+            process_voice_input()
+            
+    except Exception as e:
+        st.error(f"❌ WebRTC Error: {str(e)}")
+        st.info("💡 Try refreshing the page or using a different browser (Chrome recommended).")
+        
+        # Fallback: manual audio input
+        st.subheader("🔄 Fallback: Manual Audio Input")
+        if st.button("Try Alternative Audio Method", key=f"fallback_{voice_key}"):
+            st.info("This feature requires WebRTC support. Please ensure your browser supports WebRTC and try again.")

components/video_recorder.py

@@ -4,6 +4,8 @@ import os
 import streamlit as st
 import datetime
 import av
+import numpy as np
+from typing import Optional
 
 from streamlit_webrtc import webrtc_streamer, WebRtcMode
 
@@ -12,75 +14,127 @@ os.makedirs(VIDEO_CONSENT_DIR, exist_ok=True)
 
 def record_consent_video():
     """
-    Encapsulates the video recording logic using the component's internal state.
-    
-    The video is automatically saved when the user clicks the "STOP" button
-    on the webrtc component.
+    Improved video recording component with better error handling and reliability.
     
     Returns:
         str | None: The file path of the saved video, or None if not saved yet.
     """
-    # Instructions for the new, more intuitive workflow
-    st.info("Instructions: Click START, record your consent, then click STOP to finalize.")
+    st.info("🎥 **Instructions:** Click START to begin recording, speak your consent, then click STOP to save.")
+    
+    # Initialize session state for video recording
+    if "video_frames_buffer" not in st.session_state:
+        st.session_state.video_frames_buffer = []
+    if "video_recording" not in st.session_state:
+        st.session_state.video_recording = False
+    if "video_processed" not in st.session_state:
+        st.session_state.video_processed = False
+    if "recording_start_time" not in st.session_state:
+        st.session_state.recording_start_time = None
+
+    def video_frame_callback(frame: av.VideoFrame):
+        """Callback to collect video frames during recording"""
+        if st.session_state.video_recording:
+            try:
+                # Convert frame to numpy array for easier handling
+                img = frame.to_ndarray(format="bgr24")
+                st.session_state.video_frames_buffer.append(img)
+            except Exception as e:
+                st.error(f"Error processing video frame: {e}")
 
+    # WebRTC streamer configuration
     webrtc_ctx = webrtc_streamer(
         key="video-consent-recorder",
-        mode=WebRtcMode.SENDRECV, # SENDRECV mode is needed for the stop-button-triggered callback
-        media_stream_constraints={"video": True, "audio": True},
-        video_receiver_size=256,
+        mode=WebRtcMode.SENDONLY,
+        rtc_configuration={
+            "iceServers": [
+                {"urls": ["stun:stun.l.google.com:19302"]},
+                {"urls": ["stun:stun1.l.google.com:19302"]}
+            ]
+        },
+        media_stream_constraints={
+            "video": {
+                "width": {"ideal": 640},
+                "height": {"ideal": 480},
+                "frameRate": {"ideal": 30}
+            },
+            "audio": False
+        },
+        video_frame_callback=video_frame_callback,
         async_processing=True,
     )
 
-    # This block executes ONLY when the component is running (after START is clicked)
-    if webrtc_ctx.state.playing and webrtc_ctx.video_receiver:
-        # Inform the user that recording is in progress
-        st.success("🔴 Recording in progress...")
-        
-        # If the 'frames_buffer' is not in session state, initialize it
-        if "frames_buffer" not in st.session_state:
-            st.session_state.frames_buffer = []
+    # Handle recording state
+    if webrtc_ctx.state.playing and not st.session_state.video_recording:
+        st.session_state.video_recording = True
+        st.session_state.video_processed = False
+        st.session_state.recording_start_time = datetime.datetime.now()
+        st.session_state.video_frames_buffer = []  # Clear previous buffer
+        st.success("🔴 **Recording started!** Speak your consent now...")
         
-        # Append each new frame to our session state buffer
-        while True:
-            try:
-                frame = webrtc_ctx.video_receiver.get_frame(timeout=1)
-                st.session_state.frames_buffer.append(frame)
-            except av.error.TimeoutError:
-                break # Break the loop when the stream ends (user clicks STOP)
+    elif webrtc_ctx.state.playing and st.session_state.video_recording:
+        # Show recording progress
+        frames_captured = len(st.session_state.video_frames_buffer)
+        if st.session_state.recording_start_time:
+            elapsed = (datetime.datetime.now() - st.session_state.recording_start_time).total_seconds()
+            st.caption(f"📹 Recording... Frames: {frames_captured} | Duration: {elapsed:.1f}s")
 
-    # This block executes after the user clicks STOP
-    if not webrtc_ctx.state.playing and st.session_state.get("frames_buffer"):
-        with st.spinner("Saving your recording..."):
+    # Process video when recording stops
+    if not webrtc_ctx.state.playing and st.session_state.video_recording and not st.session_state.video_processed:
+        st.session_state.video_recording = False
+        st.session_state.video_processed = True
+        
+        with st.spinner("💾 Processing and saving your recording..."):
             try:
-                video_frames = st.session_state.frames_buffer
+                video_frames = st.session_state.video_frames_buffer.copy()
+                
+                # Enhanced validation
+                if len(video_frames) < 30:  # At least 1 second at 30fps
+                    st.warning(f"⚠️ Recording too short ({len(video_frames)} frames). Please record for at least 2-3 seconds.")
+                    st.session_state.video_frames_buffer = []
+                    return None
                 
-                # Generate a unique filename
+                # Generate unique filename
                 timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
                 video_filename = os.path.join(VIDEO_CONSENT_DIR, f"consent_{timestamp}.mp4")
-
-                # Use the av library to write the buffered frames to a video file
-                with av.open(video_filename, mode="w") as container:
-                    stream = container.add_stream("libx264", rate=24)
-                    stream.width = video_frames[0].width
-                    stream.height = video_frames[0].height
-                    stream.pix_fmt = "yuv420p"
-
-                    for frame in video_frames:
-                        packet = stream.encode(frame)
-                        container.mux(packet)
-                    
-                    # Flush the stream
-                    packet = stream.encode()
-                    container.mux(packet)
                 
-                # Clear the buffer from session state and return the path
-                st.session_state.frames_buffer = [] 
-                st.session_state.video_filename = video_filename
-                return video_filename
-
+                # Get video dimensions from first frame
+                height, width = video_frames[0].shape[:2]
+                fps = 30
+                
+                # Use OpenCV for more reliable video writing
+                import cv2
+                fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+                out = cv2.VideoWriter(video_filename, fourcc, fps, (width, height))
+                
+                # Write frames
+                for frame in video_frames:
+                    out.write(frame)
+                
+                out.release()
+                
+                # Verify the video was created successfully
+                if os.path.exists(video_filename) and os.path.getsize(video_filename) > 1000:
+                    # Clear the buffer
+                    st.session_state.video_frames_buffer = []
+                    st.session_state.video_filename = video_filename
+                    
+                    # Calculate duration
+                    duration = len(video_frames) / fps
+                    st.success(f"✅ **Video saved successfully!**")
+                    st.caption(f"📊 Duration: {duration:.1f}s | Frames: {len(video_frames)} | Size: {os.path.getsize(video_filename)/1024:.1f}KB")
+                    
+                    return video_filename
+                else:
+                    st.error("❌ Failed to save video file properly.")
+                    return None
+                    
             except Exception as e:
-                st.error(f"An error occurred while saving the video: {e}")
-                st.session_state.frames_buffer = [] # Clear buffer on error
+                st.error(f"❌ Error saving video: {str(e)}")
+                st.session_state.video_frames_buffer = []
                 return None
     
+    # Show recording status
+    if st.session_state.video_recording:
+        st.info("🎥 **Recording in progress...** Click STOP when finished.")
+    
     return None

main_streamlit.py

@@ -4,11 +4,13 @@ import os
 import streamlit as st
 from dotenv import load_dotenv
 
+# --- Agent and Component Imports (Cleaned up) ---
 from agents.demystifier_agent import process_document_for_demystification
 from components.video_recorder import record_consent_video
 from utils.pdf_generator import generate_formatted_pdf
-
-# --- Initial Setup ---
+from components.chat_interface import chat_interface
+from agents.general_assistant_agent import ask_gemini
+# --- 1. Initial Setup ---
 load_dotenv()
 st.set_page_config(layout="wide", page_title="Jan-Contract Unified Assistant")
 st.title("Jan-Contract: Your Digital Workforce Assistant")
@@ -16,11 +18,12 @@ st.title("Jan-Contract: Your Digital Workforce Assistant")
 PDF_UPLOAD_DIR = "pdfs_demystify"
 os.makedirs(PDF_UPLOAD_DIR, exist_ok=True)
 
-# --- Tabs ---
-tab1, tab2, tab3 = st.tabs([
-    " **Contract Generator**", 
-    " **Scheme Finder**", 
-    " **Document Demystifier & Chat**"
+# --- 2. Streamlit UI with Tabs ---
+tab1, tab2, tab3, tab4 = st.tabs([
+    "📝 **Contract Generator**", 
+    "🏦 **Scheme Finder**", 
+    "📜 **Document Demystifier & Chat**",
+    "🤖 **General Assistant**"
 ])
 
 # --- TAB 1: Contract Generator ---
@@ -31,7 +34,8 @@ with tab1:
     st.subheader("Step 1: Describe and Generate Your Agreement")
     user_request = st.text_area("Describe the agreement...", height=120, key="contract_request")
     
-    if st.button("Generate Document & Get Legal Info", type="primary"):
+    # --- FIX: Added a unique key="b1" for consistency ---
+    if st.button("Generate Document & Get Legal Info", type="primary", key="b1"):
         if user_request:
             with st.spinner("Generating document..."):
                 from agents.legal_agent import legal_agent
@@ -41,7 +45,7 @@ with tab1:
                 if 'video_path_from_component' in st.session_state:
                     del st.session_state['video_path_from_component']
                 if 'frames_buffer' in st.session_state:
-                    del st.session_state['frames_buffer'] # Clear old frames
+                    del st.session_state['frames_buffer']
         else:
             st.error("Please describe the agreement.")
     
@@ -57,11 +61,22 @@ with tab1:
         
         with col2:
             st.subheader("Relevant Legal Trivia")
-            # ... [Trivia display logic] ...
+            # --- FIX: Restored the missing trivia display logic ---
+            if result.get('legal_trivia') and result['legal_trivia'].trivia:
+                for item in result['legal_trivia'].trivia:
+                    st.markdown(f"- **{item.point}**")
+                    st.caption(item.explanation)
+                    st.markdown(f"[Source Link]({item.source_url})")
+            else:
+                st.write("Could not retrieve structured legal trivia.")
 
         st.divider()
         
         st.subheader("Step 2: Record Video Consent for this Agreement")
+        
+        # Browser compatibility check
+        st.info("🌐 **Browser Requirements:** This feature works best in Chrome, Firefox, or Edge. Make sure to allow camera access when prompted.")
+        
         saved_video_path = record_consent_video()
 
         if saved_video_path:
@@ -71,6 +86,9 @@ with tab1:
             st.success("✅ Your consent has been recorded and saved!")
             st.video(st.session_state.video_path_from_component)
             st.info("This video is now linked to your generated agreement.")
+        else:
+            st.info("💡 **Tip:** If video recording isn't working, try refreshing the page and allowing camera permissions.")
+
 # --- TAB 2: Scheme Finder (Unchanged) ---
 with tab2:
     st.header("Find Relevant Government Schemes")
@@ -81,7 +99,6 @@ with tab2:
     if st.button("Find Schemes", type="primary", key="b2"):
         if user_profile:
             with st.spinner("Initializing models and searching for schemes..."):
-                # Lazy import the agent
                 from agents.scheme_chatbot import scheme_chatbot
                 response = scheme_chatbot.invoke({"user_profile": user_profile})
                 st.session_state.scheme_response = response
@@ -98,67 +115,68 @@ with tab2:
                     st.write(f"**Description:** {scheme.description}")
                     st.link_button("Go to Official Page ➡️", scheme.official_link)
 
-# --- TAB 3: Demystifier & Chat (RESTORED to original functionality) ---
+# --- TAB 3: Demystifier & Chat ---
 with tab3:
-    st.header("Simplify & Chat With Your Legal Document")
-    st.markdown("Get a plain-English summary of your document, then ask specific follow-up questions.")
+    st.header("📜 Simplify & Chat With Your Legal Document")
+    st.markdown("Get a plain-English summary of your document, then ask questions using text or your voice.")
 
     uploaded_file = st.file_uploader("Choose a PDF document", type="pdf", key="demystify_uploader")
 
+    # This button triggers the one-time analysis and embedding process
     if uploaded_file and st.button("Analyze Document", type="primary"):
         with st.spinner("Performing deep analysis and preparing for chat..."):
-            # Save the file to a persistent location
+            # Save the uploaded file to a temporary location for processing
             temp_file_path = os.path.join(PDF_UPLOAD_DIR, uploaded_file.name)
             with open(temp_file_path, "wb") as f:
                 f.write(uploaded_file.getbuffer())
             
-            # Single call to the backend agent logic
+            # Call the master controller function from the agent
             analysis_result = process_document_for_demystification(temp_file_path)
             
-            # Store the results returned by the agent
-            st.session_state.demystify_report = analysis_result["report"]
+            # Store the two key results in the session state
+            st.session_state.demystifier_report = analysis_result["report"]
             st.session_state.rag_chain = analysis_result["rag_chain"]
-            st.session_state.messages = [] # Initialize chat history
 
-    # This part of the UI only displays after the analysis is complete
-    if 'demystify_report' in st.session_state:
-        # Step 1: Display Report
-        report = st.session_state.demystify_report
+    # This UI section only appears after a document has been successfully analyzed
+    if 'demystifier_report' in st.session_state:
         st.divider()
         st.header("Step 1: Automated Document Analysis")
+        report = st.session_state.demystifier_report
         with st.container(border=True):
             st.subheader("📄 Document Summary")
             st.write(report.summary)
             st.divider()
+            
             st.subheader("🔑 Key Terms Explained")
             for term in report.key_terms:
                 with st.expander(f"**{term.term}**"):
                     st.write(term.explanation)
                     st.markdown(f"[Learn More Here]({term.resource_link})")
             st.divider()
+            
             st.success(f"**Overall Advice:** {report.overall_advice}")
+
         st.divider()
 
-        # Step 2: Display Chat
         st.header("Step 2: Ask Follow-up Questions")
-        st.info("The document is now ready for your questions. Chat with it below.")
-
-        for message in st.session_state.get("messages", []):
-            with st.chat_message(message["role"]):
-                st.markdown(message["content"])
-
-        if prompt := st.chat_input("Ask a specific question about the document..."):
-            st.session_state.messages.append({"role": "user", "content": prompt})
-            with st.chat_message("user"):
-                st.markdown(prompt)
-
-            with st.chat_message("assistant"):
-                with st.spinner("Searching the document..."):
-                    rag_chain = st.session_state.rag_chain
-                    response = rag_chain.invoke(prompt)
-                    st.markdown(response)
+        # Call our reusable chat component, passing the RAG chain specific to this document.
+        # The RAG chain's .invoke method is the handler function.
+        chat_interface(
+            handler_function=st.session_state.rag_chain.invoke, 
+            session_state_key="doc_chat_history"  # Use a unique key for this chat's history
+        )
             
-            st.session_state.messages.append({"role": "assistant", "content": response})
-
     elif not uploaded_file:
-        st.info("Upload a PDF document to begin the analysis.")
+        st.info("Upload a PDF document to begin analysis and enable chat.")
+
+# --- TAB 4: General Assistant (Complete) ---
+with tab4:
+    st.header("🤖 General Assistant")
+    st.markdown("Ask a general question and get a response directly from the Gemini AI model. You can use text or your voice.")
+
+    # Call our reusable chat component.
+    # This time, we pass the simple `ask_gemini` function as the handler.
+    chat_interface(
+        handler_function=ask_gemini,
+        session_state_key="general_chat_history" # Use a different key for this chat's history
+    )

requirements.txt

@@ -1,33 +1,42 @@
 # D:\jan-contract\requirements.txt
 
 # Core LangChain libraries
-langchain-core
-langchain
-langchain-community
-langgraph
+langchain-core>=0.2.0
+langchain>=0.2.0
+langchain-community>=0.2.0
+langgraph>=0.2.0
 
 # LLM Integrations
-langchain_google_genai
-langchain-groq
+langchain_google_genai>=0.1.0
+langchain-groq>=0.1.0
+google-generativeai>=0.8.0
 
 # Tooling
-tavily-python
-pypdf
-pymupdf
-fastembed
-faiss-cpu
-python-multipart
+tavily-python>=0.4.0
+pypdf>=4.0.0
+pymupdf>=1.24.0
+fastembed>=0.2.0
+faiss-cpu>=1.7.0
+python-multipart>=0.0.6
+
 # Web Frameworks
-fastapi
-uvicorn
-streamlit
+fastapi>=0.104.0
+uvicorn>=0.24.0
+streamlit>=1.28.0
+
+# Video and Audio Processing
+streamlit-webrtc>=0.63.4
+opencv-python-headless>=4.8.0
+av>=14.0.0
+SpeechRecognition>=3.10.0
+gTTS>=2.4.0
+PyAudio>=0.2.11
 
 # Utilities
-python-dotenv
-pydantic
-fpdf2
+python-dotenv>=1.0.0
+pydantic>=2.5.0
+fpdf2>=2.7.0
+numpy>=1.24.0
 
-# --- NEW: For Video Recording ---
-streamlit-webrtc
-opencv-python-headless
-av
+# Additional dependencies for better audio/video handling
+# Note: webrtc-streamer is not needed as streamlit-webrtc handles this

run_app.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+Jan-Contract App Launcher
+This script helps you run the Streamlit app with proper configuration.
+"""
+
+import os
+import sys
+import subprocess
+import webbrowser
+import time
+
+
+def check_dependencies():
+    """Check if all required dependencies are installed"""
+    # Map human/package names to actual importable module names
+    required_modules = [
+        ("streamlit", "streamlit"),
+        ("streamlit-webrtc", "streamlit_webrtc"),
+        ("opencv-python-headless", "cv2"),  # import cv2, not opencv_python_headless
+        ("av", "av"),
+        ("SpeechRecognition", "speech_recognition"),
+        ("gTTS", "gtts"),
+        ("numpy", "numpy"),
+    ]
+
+    missing = []
+    for package_label, module_name in required_modules:
+        try:
+            __import__(module_name)
+        except ImportError:
+            missing.append(package_label)
+
+    if missing:
+        print("❌ Missing dependencies:")
+        for package in missing:
+            print(f"   - {package}")
+        print("\n💡 Install missing packages with:")
+        print("   pip install -r requirements.txt")
+        return False
+
+    print("✅ All dependencies are installed!")
+    return True
+
+
+def check_directories():
+    """Check if required directories exist"""
+    required_dirs = ['video_consents', 'pdfs_demystify']
+
+    for dir_name in required_dirs:
+        if not os.path.exists(dir_name):
+            os.makedirs(dir_name, exist_ok=True)
+            print(f"📁 Created directory: {dir_name}")
+
+    print("✅ All directories are ready!")
+
+
+def main():
+    print("🚀 Jan-Contract App Launcher")
+    print("=" * 40)
+
+    # Check dependencies
+    if not check_dependencies():
+        print("\n❌ Please install missing dependencies before running the app.")
+        return
+
+    # Check directories
+    check_directories()
+
+    print("\n🌐 Starting Streamlit app...")
+    print("💡 The app will open in your default browser.")
+    print("💡 If it doesn't open automatically, go to: http://localhost:8501")
+    print("\n📋 Tips for best experience:")
+    print("   - Use Chrome, Firefox, or Edge")
+    print("   - Allow camera and microphone permissions")
+    print("   - Record videos for at least 2-3 seconds")
+    print("   - Speak clearly for voice input")
+
+    # Start the Streamlit app using `python -m streamlit` so PATH is not required
+    try:
+        # Open browser after a short delay
+        def open_browser():
+            time.sleep(3)
+            webbrowser.open('http://localhost:8501')
+
+        import threading
+        browser_thread = threading.Thread(target=open_browser)
+        browser_thread.daemon = True
+        browser_thread.start()
+
+        # Run Streamlit
+        subprocess.run([
+            sys.executable, '-m', 'streamlit', 'run', 'main_streamlit.py',
+            '--server.port', '8501',
+            '--server.address', 'localhost'
+        ])
+
+    except KeyboardInterrupt:
+        print("\n👋 App stopped by user.")
+    except Exception as e:
+        print(f"\n❌ Error starting app: {e}")
+        print("💡 Try running manually: python -m streamlit run main_streamlit.py")
+
+
+if __name__ == "__main__":
+    main()