Update app.py

app.py

@@ -4,48 +4,109 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
 from langchain.prompts import PromptTemplate
 from youtube_transcript_api import YouTubeTranscriptApi
+import requests
 import os
 
-# Environment variables
+
+# 🔑 Environment variables
 api_key = os.getenv("HF_API_KEY")
+RAPIDAPI_KEY = (os.getenv("RAPIDAPI_KEY") or "").strip()
+
 
-# 📋 List Available Languages
+# 📋 List Available Languages (RapidAPI → fallback YouTube)
 @st.cache_data
 def list_available_languages(video_id):
-    """Fetch all available transcript languages for a video"""
+    """Try RapidAPI first to list languages, fallback to YouTubeTranscriptApi."""
+    languages = []
+
+    # --- Try RapidAPI ---
+    try:
+        if not RAPIDAPI_KEY:
+            raise ValueError("RapidAPI key missing")
+
+        url = "https://youtube-transcript3.p.rapidapi.com/"
+        querystring = {"video_id": video_id}
+        headers = {
+            "x-rapidapi-key": RAPIDAPI_KEY,
+            "x-rapidapi-host": "youtube-transcript3.p.rapidapi.com"
+        }
+
+        response = requests.get(url, headers=headers, params=querystring, timeout=15)
+        response.raise_for_status()
+        data = response.json()
+
+        if "languages" in data and isinstance(data["languages"], list):
+            for lang in data["languages"]:
+                lang_code = lang.get("code", "unknown")
+                lang_name = lang.get("name", lang_code)
+                label = f"{lang_name} ({lang_code})"
+                languages.append((lang_code, label))
+        elif "availableLanguages" in data:
+            for lang in data["availableLanguages"]:
+                code = lang.get("language_code", "unknown")
+                name = lang.get("language_name", code)
+                languages.append((code, f"{name} ({code})"))
+
+        if languages:
+            return languages
+        else:
+            st.info("RapidAPI did not return language list; using YouTubeTranscriptApi fallback.")
+
+    except Exception as e:
+        st.info(f"RapidAPI language fetch failed: {e}")
+
+    # --- Fallback: YouTubeTranscriptApi ---
     try:
-        api = YouTubeTranscriptApi()
-        transcript_list = api.list(video_id)
-        
-        languages = []
+        transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
         for transcript in transcript_list:
             lang_code = transcript.language_code
             lang_name = transcript.language
             is_generated = transcript.is_generated
-            label = f"{lang_name} ({lang_code})" + (" - Auto-generated" if is_generated else " - Manual")
+            label = f"{lang_name} ({lang_code})" + (" - Auto-generated" if is_generated else "")
             languages.append((lang_code, label))
-        
-        return languages
-    except Exception as e:
-        st.warning(f"Could not fetch available languages: {e}")
-        return [("en", "English (en) - Default")]
+        if languages:
+            return languages
+    except Exception as e2:
+        st.warning(f"YouTubeTranscriptApi also failed: {e2}")
+
+    # --- Final fallback ---
+    return [("en", "English (en) - Default")]
 
 
-# 📼 Transcript Fetcher (Using youtube_transcript_api)
+# 📼 Transcript Fetchers (two sources)
 @st.cache_data
-def get_transcript(video_id, language_code="en"):
-    """Fetch transcript using youtube_transcript_api"""
+def get_transcript_youtube(video_id, language_code):
+    """Fetch transcript using YouTubeTranscriptApi."""
     try:
-        api = YouTubeTranscriptApi()
-        transcript_list = api.fetch(video_id, languages=[language_code])
+        transcript_list = YouTubeTranscriptApi().fetch(video_id, languages=[language_code])
         transcript = ' '.join([snippet.text for snippet in transcript_list])
         return transcript
     except Exception as e:
-        st.error(f"Error fetching transcript: {str(e)}")
+        st.warning(f"YouTubeTranscriptApi failed: {e}")
+        return None
+
+
+@st.cache_data
+def get_transcript_rapidapi(video_id, language_code):
+    """Fetch transcript via RapidAPI."""
+    try:
+        url = "https://youtube-transcript3.p.rapidapi.com/"
+        querystring = {"video_id": video_id, "lang": language_code}
+        headers = {
+            "x-rapidapi-key": RAPIDAPI_KEY,
+            "x-rapidapi-host": "youtube-transcript3.p.rapidapi.com"
+        }
+        response = requests.get(url, headers=headers, params=querystring, timeout=20)
+        response.raise_for_status()
+        data = response.json()
+        transcript = " ".join([item["text"] for item in data.get("transcript", [])])
+        return transcript if transcript else None
+    except Exception as e:
+        st.error(f"RapidAPI transcript fetch failed: {e}")
         return None
 
 
-# 🧱 Vector Store (keeping multilingual-e5-base as requested)
+# 🧱 Vector Store
 @st.cache_data
 def create_vector_store(transcript):
     splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
@@ -57,7 +118,7 @@ def create_vector_store(transcript):
     return FAISS.from_documents(docs, embeddings)
 
 
-# 🧩 Build model (ALL using Inference API now)
+# 🧩 Build Model
 def build_model(model_choice, temperature=0.7):
     if model_choice == "Flan-T5 (Free)":
         llm = HuggingFaceEndpoint(
@@ -67,6 +128,7 @@ def build_model(model_choice, temperature=0.7):
             temperature=temperature
         )
         return ChatHuggingFace(llm=llm)
+
     elif model_choice == "DeepSeek":
         llm = HuggingFaceEndpoint(
             repo_id="deepseek-ai/DeepSeek-V3.2-Exp",
@@ -75,6 +137,7 @@ def build_model(model_choice, temperature=0.7):
             max_new_tokens=500
         )
         return ChatHuggingFace(llm=llm, temperature=temperature)
+
     elif model_choice == "OpenAI":
         llm = HuggingFaceEndpoint(
             repo_id="openai/gpt-oss-20b",
@@ -100,73 +163,67 @@ prompt_template = PromptTemplate(
 # 🚀 Streamlit UI
 st.title("🎥 YouTube Transcript Chatbot")
 
-# Video ID input
-video_id = st.text_input("YouTube Video ID", value="lv1_-RER4_I", help="Enter the video ID from YouTube URL")
+video_id = st.text_input("🎬 YouTube Video ID", value="lv1_-RER4_I")
+query = st.text_area("💬 Your Query", value="What is RAG?")
+model_choice = st.radio("🧠 Model to Use", ["Flan-T5 (Free)", "DeepSeek", "OpenAI"])
+temperature = st.slider("🔥 Temperature", 0, 100, value=50) / 100.0
+
+source_choice = st.radio(
+    "📜 Transcript Source",
+    ["Auto (Try RapidAPI, then YouTubeTranscriptApi)", "RapidAPI", "YouTubeTranscriptApi"]
+)
 
-# Language selection
-language_code = "en"
 if video_id:
-    with st.spinner("Checking available transcripts..."):
+    with st.spinner("🔎 Checking available transcript languages..."):
         available_langs = list_available_languages(video_id)
-    
     if available_langs:
         st.success(f"Found {len(available_langs)} available transcript(s)")
-        
-        # Create dropdown with available languages
         lang_options = {label: code for code, label in available_langs}
-        selected_label = st.selectbox(
-            "Select Transcript Language",
-            options=list(lang_options.keys()),
-            help="Choose from available transcripts for this video"
-        )
+        selected_label = st.selectbox("🌐 Select Transcript Language", options=list(lang_options.keys()))
         language_code = lang_options[selected_label]
     else:
-        st.info("Using default English transcript")
-        language_code = "en"
-
-# Query input
-query = st.text_area("Your Query", value="What is RAG?", help="Ask a question about the video content")
+        st.warning("No transcripts found for this video.")
+        language_code = None
+else:
+    language_code = None
 
-# Model selection
-model_choice = st.radio("Model to Use", ["Flan-T5 (Free)", "DeepSeek", "OpenAI"])
-
-# Temperature slider
-temperature = st.slider("Temperature", 0, 100, value=50, help="Higher = more creative, Lower = more focused") / 100.0
-
-# Run button
 if st.button("🚀 Run Chatbot"):
-    if not video_id or not query:
-        st.warning("Please fill in all fields.")
+    if not video_id or not query or not language_code:
+        st.warning("Please provide video ID, query, and select a language.")
     else:
-        with st.spinner("Fetching transcript..."):
-            transcript = get_transcript(video_id, language_code)
+        with st.spinner("🧾 Fetching transcript..."):
+            transcript = None
+            if source_choice == "RapidAPI":
+                transcript = get_transcript_rapidapi(video_id, language_code)
+            elif source_choice == "YouTubeTranscriptApi":
+                transcript = get_transcript_youtube(video_id, language_code)
+            else:  # Auto mode
+                transcript = get_transcript_rapidapi(video_id, language_code)
+                if not transcript:
+                    transcript = get_transcript_youtube(video_id, language_code)
+
             if not transcript:
-                st.error("Could not fetch transcript.")
+                st.error("❌ Could not fetch transcript from any source.")
             else:
-                st.success(f"✅ Transcript fetched! ({len(transcript)} characters)")
+                st.success(f"✅ Transcript fetched successfully ({len(transcript)} characters).")
 
-                with st.spinner("Generating response..."):
-                    retriever = create_vector_store(transcript).as_retriever(
-                        search_type="mmr", 
-                        search_kwargs={"k": 5}
-                    )
+                with st.spinner("⚙️ Generating response..."):
+                    retriever = create_vector_store(transcript).as_retriever(search_type="mmr", search_kwargs={"k": 5})
                     relevant_docs = retriever.invoke(query)
                     context_text = "\n\n".join(doc.page_content for doc in relevant_docs)
                     prompt = prompt_template.format(context=context_text, question=query)
 
                     model = build_model(model_choice, temperature)
                     response = model.invoke(prompt)
-                    
-                    # Extract content from response
                     response_text = response.content if hasattr(response, 'content') else str(response)
-                    st.text_area("Model Response", value=response_text, height=400)
+                    st.text_area("🧩 Model Response", value=response_text, height=400)
 
-# Sidebar with info
+# 📘 Sidebar Info
 with st.sidebar:
-    st.header("ℹ️ About")
-    st.write("This chatbot analyzes YouTube videos using their transcripts.")
-    st.write("**Features:**")
-    st.write("- Auto-detect available languages")
-    st.write("- RAG-based Q&A")
-    st.write("- Multiple model options")
-    st.write("- Cached for performance")
+    st.header("ℹ️ About this App")
+    st.write("""
+    - Uses both **RapidAPI** and **YouTubeTranscriptApi**  
+    - Detects transcript languages dynamically (RapidAPI first)  
+    - RAG-based Q&A powered by Hugging Face models  
+    - Models supported: Flan-T5 (Free), DeepSeek, OpenAI (via HF)
+    """)