Update app.py

app.py

@@ -1,4 +1,7 @@
-import os, re, validators, streamlit as st
+import os
+import re
+import validators
+import streamlit as st
 from dotenv import load_dotenv
 from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, VideoUnavailable
 from langchain.prompts import PromptTemplate
@@ -7,67 +10,77 @@ from langchain_groq import ChatGroq
 from langchain.schema import Document
 from langchain_community.document_loaders import UnstructuredURLLoader
 from langchain.document_loaders import PyPDFLoader
+from groq._base_client import APIConnectionError
+
 load_dotenv()
 GROQ_KEY = os.getenv("GROQ_API_KEY")
 
 st.set_page_config(page_title="LangChain Summarizer", page_icon="🦜")
 st.title("🦜 LangChain: Summarize YT / Webpage / PDF")
 
-generic_url = st.text_input("Paste a YouTube / web URL here:")
-uploaded_file = st.file_uploader("…or upload a PDF", type=["pdf"])
-
-MAP_PROMPT = PromptTemplate(template="Write a concise summary of the following:\n\n{text}", input_variables=["text"])
-COMBINE_PROMPT = PromptTemplate(template="Provide an overall summary (~300 words):\n\n{text}", input_variables=["text"])
+url_input = st.text_input("Paste a YouTube / web URL here:")
+file_input = st.file_uploader("…or upload a PDF", type=["pdf"])
 
-def get_video_id(url: str):
+def get_video_id(url):
     m = re.search(r"(?:v=|\/)([0-9A-Za-z_-]{11})", url)
     return m.group(1) if m else None
 
+SUMMARY_PROMPT = PromptTemplate(
+    template="Provide a concise summary (~300 words):\n\nContent:\n{text}",
+    input_variables=["text"],
+)
+
 def build_llm():
     if "llm" not in st.session_state:
         if not GROQ_KEY:
-            raise RuntimeError("Groq API key missing")
-        st.session_state.llm = ChatGroq(model="llama-3.3-70b-versatile", groq_api_key=GROQ_KEY, timeout=60_000)
+            raise RuntimeError("Missing GROQ_API_KEY")
+        st.session_state.llm = ChatGroq(model="deepseek-r1-distill-llama-70b", groq_api_key=GROQ_KEY)
     return st.session_state.llm
 
 def summarize(docs):
     llm = build_llm()
-    chain = load_summarize_chain(llm, chain_type="map_reduce", map_prompt=MAP_PROMPT, combine_prompt=COMBINE_PROMPT)
-    return chain.invoke({"input_documents": docs})["output_text"]
-
-def chunk_text(text, size=4000):
-    return [Document(page_content=text[i:i+size]) for i in range(0, len(text), size)]
+    chain = load_summarize_chain(llm, chain_type="stuff", prompt=SUMMARY_PROMPT)
+    return chain({"input_documents": docs})["output_text"]
 
 if st.button("Summarize"):
     if not GROQ_KEY:
-        st.error("Groq key missing")
-    elif not generic_url and not uploaded_file:
+        st.error("Set GROQ_API_KEY in .env")
+    elif not url_input and not file_input:
         st.error("Provide a URL or upload a PDF")
     else:
         try:
-            with st.spinner("Processing"):
-                if uploaded_file:
-                    tmp_path = f"/tmp/{uploaded_file.name}"
-                    with open(tmp_path, "wb") as f:
-                        f.write(uploaded_file.read())
-                    docs = PyPDFLoader(tmp_path).load()
-                    os.remove(tmp_path)
-                    st.success(summarize(docs))
-                elif "youtube" in generic_url or "youtu.be" in generic_url:
-                    vid = get_video_id(generic_url)
+            with st.spinner("Fetching and summarizing…"):
+                if file_input:
+                    tmp = f"/tmp/{file_input.name}"
+                    with open(tmp, "wb") as f:
+                        f.write(file_input.read())
+                    docs = PyPDFLoader(tmp).load()
+                    summary = summarize(docs)
+                    os.remove(tmp)
+                    st.success(summary)
+                elif "youtube" in url_input or "youtu.be" in url_input:
+                    vid = get_video_id(url_input)
                     if not vid:
-                        st.error("Invalid YouTube URL")
+                        st.error("Couldn’t extract YouTube ID")
                     else:
                         transcript = YouTubeTranscriptApi.get_transcript(vid)
                         text = " ".join(t["text"] for t in transcript)
-                        st.success(summarize(chunk_text(text)))
+                        summary = summarize([Document(page_content=text)])
+                        st.success(summary)
                 else:
-                    if not validators.url(generic_url):
+                    if not validators.url(url_input):
                         st.error("Invalid URL")
                     else:
-                        docs = UnstructuredURLLoader(urls=[generic_url], ssl_verify=False, headers={"User-Agent":"Mozilla/5.0"}).load()
-                        st.success(summarize(docs))
+                        docs = UnstructuredURLLoader(
+                            urls=[url_input],
+                            ssl_verify=False,
+                            headers={"User-Agent": "Mozilla/5.0"}
+                        ).load()
+                        summary = summarize(docs)
+                        st.success(summary)
         except (TranscriptsDisabled, VideoUnavailable) as yt_err:
             st.error(str(yt_err))
+        except APIConnectionError:
+            st.error("Connection to Groq API failed. Check network and API key.")
         except Exception as e:
-            st.exception(e)
+            st.error(f"Unexpected error: {e}")