Upload 3 files

Add webpage and YouTube content extraction and summarization.

This commit enhances the course creator agent to read and analyze external links directly in chat. It updates searcher.py to include extract_web_content (via Tavily extract API) and get_youtube_transcript (using youtube-transcript-api), while preserving run_web_search. In app.py, the assistant detects URLs in user messages, fetches page content or video transcripts, and summarises them with OpenAI before replying. Requirements are updated to include youtube-transcript-api. The assistant can now open webpages and YouTube videos, summarise the content, and use it for brainstorming.

app.py

@@ -4,7 +4,7 @@ import openai
 
 from planner import plan_course
 from generators import generate_course_zip
-from searcher import run_web_search
+from searcher import run_web_search, extract_web_content, get_youtube_transcript
 
 # System prompt guiding the assistant's behaviour during brainstorming
 SYSTEM_PROMPT = (
@@ -25,106 +25,205 @@ def chat(user_message, chat_history, chat_pairs, sources, plan):
     chat_history.append({"role": "user", "content": user_message})
     # Build messages including system prompt for API call
     messages = [{"role": "system", "content": SYSTEM_PROMPT}] + chat_history
-    # Determine if the user is requesting a web search. If so, perform the search instead
-    # of calling the language model. This allows the assistant to fetch resources when
-    # the user asks the agent to "search" or "search the internet".
-    search_triggers = ["search", "internet search", "web search"]
-    lower_msg = user_message.lower()
-    if any(trig in lower_msg for trig in search_triggers):
+    # Check if the user message contains a URL to open and read.
+    url = None
+    # Simple heuristic: look for http/https links in the message
+    for part in user_message.split():
+        if part.startswith("http://") or part.startswith("https://"):
+            url = part
+            break
+    if url:
+        # User is asking to open/read a specific page or YouTube video
         try:
-            # Perform web search using the entire user message as the query
-            results = run_web_search(user_message, num_results=5, domain_filter="")
-            # Normalize results:
-            # Tavily may return a dictionary with a "results" key containing
-            # the list of search results. If so, extract that list. If it's a
-            # list already, use it directly. Otherwise, default to an empty list.
-            if isinstance(results, dict):
-                normalized_results = results.get("results", [])
-            elif isinstance(results, list):
-                normalized_results = results
-            else:
-                normalized_results = []
-            # Ensure the sources list is initialised
-            if sources is None:
-                sources = []
-            sources.extend(normalized_results)
-            # Summarise results into a simple string with title and URL
-            summary_lines = []
-            for r in normalized_results:
-                # Defensive: ensure r is a dict
-                if isinstance(r, dict):
-                    title = r.get("title", "")
-                    url = r.get("url", "")
-                    if title or url:
-                        summary_lines.append(f"{title} - {url}")
-            if summary_lines:
-                assistant_reply = "Here are some resources I found:\n" + "\n".join(summary_lines)
-            else:
-                assistant_reply = "I couldn't find any results for that query."
-        except Exception as e:
-            assistant_reply = (
-                "An error occurred during web search. Please ensure your search API key is configured.\n"
-                f"(Error: {e})"
-            )
-    else:
-        # Call OpenAI's ChatCompletion to get assistant's reply
-        try:
-            # Use a widely supported default model; older OpenAI SDKs (pinned below v1)
-            # do not recognise newer model names like gpt-5. Default to gpt-3.5-turbo
-            # but allow overriding via the OPENAI_MODEL env variable.
-            model = os.getenv("OPENAI_MODEL", "gpt-3.5-turbo")
-            temperature = float(os.getenv("TEMPERATURE", "0.7"))
-            max_tokens = int(os.getenv("MAX_OUTPUT_TOKENS", "1024"))
-            # Support alternative secret name COURSECREATOR_API_KEY as a fallback for the OpenAI API key
-            api_key = os.getenv("OPENAI_API_KEY") or os.getenv("COURSECREATOR_API_KEY")
-            if not api_key:
-                raise ValueError("OPENAI_API_KEY or COURSECREATOR_API_KEY is not set")
-            # Prefer the new OpenAI SDK (>=1.0) if available
-            if hasattr(openai, "OpenAI"):
-                client = openai.OpenAI(api_key=api_key)
-                # Try sending max_tokens; if unsupported, retry with max_completion_tokens
+            page_content = ""
+            # Special handling for YouTube links: attempt to fetch transcript
+            if "youtube.com" in url or "youtu.be" in url:
                 try:
-                    response = client.chat.completions.create(
-                        model=model,
-                        messages=messages,
-                        temperature=temperature,
-                        max_tokens=max_tokens,
-                    )
+                    transcript_text = get_youtube_transcript(url)
                 except Exception:
-                    # Some newer models (e.g. o1 series) do not support max_tokens
-                    response = client.chat.completions.create(
-                        model=model,
-                        messages=messages,
-                        temperature=temperature,
-                        max_completion_tokens=max_tokens,
-                    )
-                assistant_reply = response.choices[0].message.content
+                    transcript_text = ""
+                page_content = transcript_text or ""
+            # For non-YouTube links or fallback if transcript empty, use Tavily extract
+            if not page_content:
+                extract_response = extract_web_content(url)
+                if isinstance(extract_response, dict):
+                    if extract_response.get("content"):
+                        page_content = extract_response.get("content", "")
+                    elif extract_response.get("text"):
+                        page_content = extract_response.get("text", "")
+                    elif extract_response.get("article"):
+                        page_content = extract_response.get("article", "")
+                    elif extract_response.get("results"):
+                        results_list = extract_response.get("results", [])
+                        if isinstance(results_list, list):
+                            page_content = "\n".join([
+                                item.get("content", item.get("title", ""))
+                                for item in results_list
+                                if isinstance(item, dict)
+                            ])
+            if not page_content:
+                assistant_reply = "I couldn't extract content from that page."
             else:
-                # Legacy OpenAI SDK (<1.0)
-                openai.api_key = api_key
+                # Summarise the extracted content using OpenAI
                 try:
-                    response = openai.ChatCompletion.create(
-                        model=model,
-                        messages=messages,
-                        temperature=temperature,
-                        max_tokens=max_tokens,
+                    model = os.getenv("OPENAI_MODEL", "gpt-3.5-turbo")
+                    temperature = float(os.getenv("TEMPERATURE", "0.7"))
+                    max_tokens = int(os.getenv("MAX_OUTPUT_TOKENS", "512"))
+                    api_key = os.getenv("OPENAI_API_KEY") or os.getenv("COURSECREATOR_API_KEY")
+                    if not api_key:
+                        raise ValueError("OPENAI_API_KEY or COURSECREATOR_API_KEY is not set")
+                    summary_system = "You are a helpful assistant. Summarize the given content in a concise and clear way."
+                    # Truncate content to avoid exceeding token limits
+                    truncated_content = page_content[:8000]
+                    summary_messages = [
+                        {"role": "system", "content": summary_system},
+                        {"role": "user", "content": truncated_content},
+                    ]
+                    if hasattr(openai, "OpenAI"):
+                        client = openai.OpenAI(api_key=api_key)
+                        try:
+                            resp = client.chat.completions.create(
+                                model=model,
+                                messages=summary_messages,
+                                temperature=temperature,
+                                max_tokens=max_tokens,
+                            )
+                        except Exception:
+                            resp = client.chat.completions.create(
+                                model=model,
+                                messages=summary_messages,
+                                temperature=temperature,
+                                max_completion_tokens=max_tokens,
+                            )
+                        assistant_reply = resp.choices[0].message.content
+                    else:
+                        openai.api_key = api_key
+                        try:
+                            resp = openai.ChatCompletion.create(
+                                model=model,
+                                messages=summary_messages,
+                                temperature=temperature,
+                                max_tokens=max_tokens,
+                            )
+                        except Exception:
+                            resp = openai.ChatCompletion.create(
+                                model=model,
+                                messages=summary_messages,
+                                temperature=temperature,
+                                max_completion_tokens=max_tokens,
+                            )
+                        assistant_reply = resp["choices"][0]["message"]["content"]
+                except Exception as e:
+                    assistant_reply = (
+                        "An error occurred while summarizing the page content. Please ensure your OpenAI API key is configured.\n"
+                        f"(Error: {e})"
                     )
-                except Exception:
-                    # Fallback for models that require max_completion_tokens
-                    response = openai.ChatCompletion.create(
-                        model=model,
-                        messages=messages,
-                        temperature=temperature,
-                        max_completion_tokens=max_tokens,
-                    )
-                assistant_reply = response["choices"][0]["message"]["content"]
         except Exception as e:
-            # When the API call fails (e.g. missing API key), return an error message
             assistant_reply = (
-                "An error occurred while processing your message. "
-                "Please ensure your OpenAI API key is configured in the Space secrets.\n"
+                "An error occurred while extracting the web page. Please ensure your search API key is configured.\n"
                 f"(Error: {e})"
             )
+    else:
+        # Determine if the user is requesting a web search. If so, perform the search instead
+        # of calling the language model. This allows the assistant to fetch resources when
+        # the user asks the agent to "search" or "search the internet".
+        search_triggers = ["search", "internet search", "web search"]
+        lower_msg = user_message.lower()
+        if any(trig in lower_msg for trig in search_triggers):
+            try:
+                # Perform web search using the entire user message as the query
+                results = run_web_search(user_message, num_results=5, domain_filter="")
+                # Normalize results:
+                # Tavily may return a dictionary with a "results" key containing
+                # the list of search results. If so, extract that list. If it's a
+                # list already, use it directly. Otherwise, default to an empty list.
+                if isinstance(results, dict):
+                    normalized_results = results.get("results", [])
+                elif isinstance(results, list):
+                    normalized_results = results
+                else:
+                    normalized_results = []
+                # Ensure the sources list is initialised
+                if sources is None:
+                    sources = []
+                sources.extend(normalized_results)
+                # Summarise results into a simple string with title and URL
+                summary_lines = []
+                for r in normalized_results:
+                    # Defensive: ensure r is a dict
+                    if isinstance(r, dict):
+                        title = r.get("title", "")
+                        url = r.get("url", "")
+                        if title or url:
+                            summary_lines.append(f"{title} - {url}")
+                if summary_lines:
+                    assistant_reply = "Here are some resources I found:\n" + "\n".join(summary_lines)
+                else:
+                    assistant_reply = "I couldn't find any results for that query."
+            except Exception as e:
+                assistant_reply = (
+                    "An error occurred during web search. Please ensure your search API key is configured.\n"
+                    f"(Error: {e})"
+                )
+        else:
+            # Call OpenAI's ChatCompletion to get assistant's reply
+            try:
+                # Use a widely supported default model; older OpenAI SDKs (pinned below v1)
+                # do not recognise newer model names like gpt-5. Default to gpt-3.5-turbo
+                # but allow overriding via the OPENAI_MODEL env variable.
+                model = os.getenv("OPENAI_MODEL", "gpt-3.5-turbo")
+                temperature = float(os.getenv("TEMPERATURE", "0.7"))
+                max_tokens = int(os.getenv("MAX_OUTPUT_TOKENS", "1024"))
+                # Support alternative secret name COURSECREATOR_API_KEY as a fallback for the OpenAI API key
+                api_key = os.getenv("OPENAI_API_KEY") or os.getenv("COURSECREATOR_API_KEY")
+                if not api_key:
+                    raise ValueError("OPENAI_API_KEY or COURSECREATOR_API_KEY is not set")
+                # Prefer the new OpenAI SDK (>=1.0) if available
+                if hasattr(openai, "OpenAI"):
+                    client = openai.OpenAI(api_key=api_key)
+                    # Try sending max_tokens; if unsupported, retry with max_completion_tokens
+                    try:
+                        response = client.chat.completions.create(
+                            model=model,
+                            messages=messages,
+                            temperature=temperature,
+                            max_tokens=max_tokens,
+                        )
+                    except Exception:
+                        # Some newer models (e.g. o1 series) do not support max_tokens
+                        response = client.chat.completions.create(
+                            model=model,
+                            messages=messages,
+                            temperature=temperature,
+                            max_completion_tokens=max_tokens,
+                        )
+                    assistant_reply = response.choices[0].message.content
+                else:
+                    # Legacy OpenAI SDK (<1.0)
+                    openai.api_key = api_key
+                    try:
+                        response = openai.ChatCompletion.create(
+                            model=model,
+                            messages=messages,
+                            temperature=temperature,
+                            max_tokens=max_tokens,
+                        )
+                    except Exception:
+                        # Fallback for models that require max_completion_tokens
+                        response = openai.ChatCompletion.create(
+                            model=model,
+                            messages=messages,
+                            temperature=temperature,
+                            max_completion_tokens=max_tokens,
+                        )
+                    assistant_reply = response["choices"][0]["message"]["content"]
+            except Exception as e:
+                # When the API call fails (e.g. missing API key), return an error message
+                assistant_reply = (
+                    "An error occurred while processing your message. "
+                    "Please ensure your OpenAI API key is configured in the Space secrets.\n"
+                    f"(Error: {e})"
+                )
     # Append assistant reply to conversation history
     chat_history.append({"role": "assistant", "content": assistant_reply})
     # Append pair to display history for any other uses (kept for compatibility)

requirements.txt

@@ -2,4 +2,7 @@ gradio>=3.0.0
 openai<1.0.0
 tavily-python>=0.3.0
 pydantic>=1.10.0
-python-dotenv>=1.0.0
+python-dotenv>=1.0.0
+
+# Allow the agent to fetch YouTube video transcripts for summarization
+youtube-transcript-api>=1.0.0

searcher.py

@@ -17,3 +17,67 @@ def run_web_search(query, num_results=5, domain_filter=""):
         params["search_kwargs"] = {"site": domain_filter}
     results = client.search(query, **params)
     return results
+
+# New function to extract content from a given URL using Tavily Extract API.
+def extract_web_content(url):
+    """Extract the main content of a web page via Tavily Extract.
+
+    Args:
+        url (str): The URL of the page to extract.
+
+    Returns:
+        dict: The Tavily extract response containing page content and metadata.
+
+    Raises:
+        ImportError: If the tavily-python package is missing.
+        ValueError: If the TAVILY_API_KEY environment variable is not set.
+    """
+    try:
+        from tavily import TavilyClient
+    except ImportError:
+        raise ImportError("Please install tavily-python")
+    api_key = os.getenv("TAVILY_API_KEY")
+    if not api_key:
+        raise ValueError("TAVILY_API_KEY environment variable is required")
+    client = TavilyClient(api_key=api_key)
+    # Call the extract endpoint to retrieve structured content from the URL
+    response = client.extract(url)
+    return response
+
+# New function to get a YouTube video transcript given its URL
+def get_youtube_transcript(video_url):
+    """Fetch the transcript of a YouTube video using youtube-transcript-api.
+
+    Args:
+        video_url (str): The full URL to a YouTube video.
+
+    Returns:
+        str: The concatenated transcript text, or an empty string if none found.
+
+    Raises:
+        ImportError: If youtube-transcript-api is not installed.
+    """
+    # Parse the video ID from the URL
+    try:
+        from urllib.parse import urlparse, parse_qs
+        from youtube_transcript_api import YouTubeTranscriptApi
+    except ImportError:
+        raise ImportError("Please install youtube-transcript-api for YouTube transcript extraction")
+    parsed = urlparse(video_url)
+    video_id = None
+    if "youtube.com" in parsed.netloc:
+        # Extract v parameter
+        query = parse_qs(parsed.query)
+        video_id = query.get("v", [None])[0]
+    elif "youtu.be" in parsed.netloc:
+        # Shortened link; path contains the ID
+        video_id = parsed.path.strip("/")
+    if not video_id:
+        return ""
+    try:
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+    except Exception:
+        return ""
+    # Concatenate all transcript segments into a single string
+    transcript_text = " ".join(seg.get("text", "") for seg in transcript_list)
+    return transcript_text