Update

app.py

@@ -5,7 +5,7 @@ from youtube_transcript_api import YouTubeTranscriptApi
 from langchain_openai import ChatOpenAI
 from langchain.agents import AgentExecutor
 from langchain.memory import ConversationBufferWindowMemory
-from youtube_FC_14 import YouTubeTranscriptTool, MainPointsExtractor, SummaryExtractor, YouTubeAgent
+from FCnew18thJul import YouTubeAgent, set_temperature
 
 import logging
 logging.getLogger().setLevel(logging.ERROR)
@@ -13,26 +13,20 @@ logging.getLogger().setLevel(logging.ERROR)
 import warnings
 warnings.filterwarnings("ignore")
 
+from dotenv import load_dotenv, find_dotenv
+_ = load_dotenv(find_dotenv()) # read local .env file
+openai.api_key = os.environ['OPENAI_API_KEY']
+
 class ChatBot:
     def __init__(self):
-        self.youtube_agent = None
-        self.api_key = None
-
-    def initialize_agent(self, api_key):
-        if api_key:
-            os.environ['OPENAI_API_KEY'] = api_key
-            openai.api_key = api_key
-            self.api_key = api_key
-            self.youtube_agent = YouTubeAgent()
-            return "API key set successfully. Agent initialized."
-        else:
-            return "Please provide a valid API key."
+        self.youtube_agent = YouTubeAgent()
 
-    def chat(self, message, history):
-        if not self.youtube_agent:
-            return "Please set your OpenAI API key first."
-        
+    def chat(self, message, history, temperature):
         try:
+            # Set the temperature using the function from FCnew18thJul.py
+            set_temperature(temperature)
+            # Reinitialize the agent to use the new temperature
+            self.youtube_agent = YouTubeAgent()
             response = self.youtube_agent.invoke(message)
             return response
         except Exception as e:
@@ -40,15 +34,12 @@ class ChatBot:
 
 chatbot = ChatBot()  # Create an instance of ChatBot
 
-def set_api_key(api_key):
-    return chatbot.initialize_agent(api_key)
-
 def user_message(message, history):
     return "", history + [[message, None]]
 
-def bot_message(history):
+def bot_message(history, temperature):
     user_message = history[-1][0]
-    bot_response = chatbot.chat(user_message, history)
+    bot_response = chatbot.chat(user_message, history, temperature)
     history[-1][1] = bot_response
     return history
 
@@ -60,19 +51,33 @@ example_messages = [
     "What tools are available for use?",
     "What is the following video about? https://www.youtube.com/watch?v=dZxbVGhpEkI",
     "Can you summarize this video? https://www.youtube.com/watch?v=hM8unyUM6KA",
-    "Extract the main points from this video: https://www.youtube.com/watch?v=UF8uR6Z6KLc"
+    "Extract the main points from this video: https://www.youtube.com/watch?v=UF8uR6Z6KLc",
+    "What are the main challenges discussed in the video? https://www.youtube.com/watch?v=-OSxeoIAs2w&t=4262s",
+    "What is the speakers name in this video? dZxbVGhpEkI"
 ]
 
 with gr.Blocks() as demo:
-    gr.Markdown("# YouTube Video Analysis Chatbot")
+    gr.Markdown("""
+    # Chat with YouTube Videos
     
-    with gr.Row():
-        api_key_input = gr.Textbox(type="password", label="Enter your OpenAI API key")
-        api_key_button = gr.Button("Set API Key")
+    This application provides a comprehensive set of tools for analyzing YouTube videos,
+    extracting information, and answering questions based on video content. It leverages
+    the LangChain library for natural language processing tasks and the YouTube Transcript
+    API for fetching video transcripts.
+    
+    Key Features:
+    - Main points summarization in multiple formats
+    - Video content summarization
+    - Question answering based on video content
+    - Flexible AI agent for handling various YouTube video-related tasks
+
+    Simply enter your question or request along with a YouTube video link, and the AI will process and respond accordingly.
+    Adjust the temperature slider to control the creativity of the AI's responses.
+    """)
     
-    api_key_status = gr.Textbox(label="API Key Status", interactive=False)
+    temperature_slider = gr.Slider(minimum=0, maximum=1, step=0.1, label="Temperature", value=0)
     
-    chatbot_interface = gr.Chatbot()
+    chatbot_interface = gr.Chatbot(show_copy_button=True)
     msg = gr.Textbox(label="Message")
     
     with gr.Row():
@@ -82,14 +87,12 @@ with gr.Blocks() as demo:
     gr.Markdown("## Example Messages")
     example_btns = [gr.Button(i) for i in example_messages]
 
-    api_key_button.click(set_api_key, inputs=api_key_input, outputs=api_key_status)
-    
     submit_btn.click(user_message, [msg, chatbot_interface], [msg, chatbot_interface], queue=False).then(
-        bot_message, chatbot_interface, chatbot_interface
+        bot_message, [chatbot_interface, temperature_slider], chatbot_interface
     )
     
     msg.submit(user_message, [msg, chatbot_interface], [msg, chatbot_interface], queue=False).then(
-        bot_message, chatbot_interface, chatbot_interface
+        bot_message, [chatbot_interface, temperature_slider], chatbot_interface
     )
     
     clear_btn.click(lambda: None, None, chatbot_interface, queue=False)

requirements.txt

@@ -9,4 +9,5 @@ langchain-core==0.2.19
 langchain-openai==0.1.16
 langchain-text-splitters==0.2.2
 pyperclip==1.9.0
-openai==1.35.13
+openai==1.35.13
+python-dotenv

youtube_FC_14.py

@@ -1,164 +1,71 @@
 """
-YouTube Video Analysis Module
+YouTube Video Analysis and Interaction Module
 
-This module provides tools for analyzing YouTube videos, including transcript extraction
-and main points summarization. It uses the LangChain library for natural language 
-processing tasks and the YouTube Transcript API for fetching video transcripts.
+This module provides a comprehensive set of tools for analyzing YouTube videos,
+extracting information, and answering questions based on video content. It leverages
+the LangChain library for natural language processing tasks and the YouTube Transcript
+API for fetching video transcripts.
 
 Classes:
-    YouTubeTranscriptTool: Handles fetching and processing of YouTube video transcripts.
-    MainPointsExtractor: Extracts and formats main points from YouTube video transcripts.
-    YouTubeAgent: Manages the overall agent setup for interacting with YouTube videos.
-    SummaryExtractor: Extracts summaries from YouTube video transcripts.
-
-Usage:
-    youtube_agent = YouTubeAgent()
-    video_link = "https://www.youtube.com/watch?v=VIDEO_ID"
-    results = process_video(video_link, youtube_agent)
+    MainPointsExtractor: 
+        Extracts and formats main points from YouTube video transcripts. 
+        Timestamps are formatted for direct use in YouTube comments, enabling clickable 
+        links to specific video sections when pasted.
+    SummaryExtractor: 
+        Handles the extraction and formatting of video summaries.
+    QuestionAnswerExtractor: 
+        Processes user questions and extracts answers from video transcripts.
+    YouTubeAgent: 
+        Manages the overall agent setup for interacting with YouTube videos and processing user queries.
+
+Key Features:
+    - Main points summarization in multiple formats
+    - Video content summarization
+    - Question answering based on video content
+    - Flexible AI agent for handling various YouTube video-related tasks
 """
 
 import os
 import openai
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Union, Type
 from youtube_transcript_api import YouTubeTranscriptApi
 from langchain_core.pydantic_v1 import BaseModel, Field
 from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langchain_openai import ChatOpenAI
 from langchain.schema.runnable import RunnableLambda, RunnablePassthrough
 from langchain.agents import tool, AgentExecutor
-from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser
+from langchain.output_parsers.openai_functions import JsonKeyOutputFunctionsParser, JsonOutputFunctionsParser
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain_core.utils.function_calling import convert_to_openai_function
 from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
 from langchain.agents.format_scratchpad import format_to_openai_functions
 from langchain.memory import ConversationBufferWindowMemory
-from functools import wraps
-import functools
-import logging
-import traceback
-
-# Set up logging with more detailed format
-logging.basicConfig(level=logging.INFO, 
-                    format='%(asctime)s - %(levelname)s - %(name)s - %(filename)s:%(lineno)d - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Define a decorator for error logging
-def log_errors(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            logger.error(f"Error in {func.__name__}: {str(e)}")
-            logger.error(f"Traceback: {traceback.format_exc()}")
-            raise
-    return wrapper
-
-class YouTubeTranscriptTool:
-    """
-    A tool for fetching and processing YouTube video transcripts.
-
-    This class provides methods to retrieve transcripts with or without timestamps,
-    and to split transcripts into manageable chunks.
-    """
-
-    @staticmethod
-    @tool(return_direct=True)
-    def get_transcript_with_timestamps(youtube_video_id: str, chunk_number: int = 0) -> str:
-        """
-        Retrieves a YouTube video transcript with timestamps.
-
-        Args:
-            youtube_video_id (str): The ID of the YouTube video.
-            chunk_number (int): The index of the transcript chunk to retrieve.
-
-        Returns:
-            str: The requested transcript chunk with timestamps.
-        """
-        return YouTubeTranscriptTool._get_transcript(youtube_video_id, chunk_number, include_timestamps=True)
-
-    @staticmethod
-    @tool(return_direct=True)
-    def get_transcript_without_timestamps(youtube_video_id: str, chunk_number: int = 0) -> str:
-        """
-        Retrieves a YouTube video transcript without timestamps.
-
-        Args:
-            youtube_video_id (str): The ID of the YouTube video.
-            chunk_number (int): The index of the transcript chunk to retrieve.
-
-        Returns:
-            str: The requested transcript chunk without timestamps.
-        """
-        return YouTubeTranscriptTool._get_transcript(youtube_video_id, chunk_number, include_timestamps=False)
-
-    @staticmethod
-    @log_errors
-    def _get_transcript(youtube_video_id: str, chunk_number: int, include_timestamps: bool) -> str:
-        """
-        Internal method to fetch and process the transcript.
-
-        Args:
-            youtube_video_id (str): The ID of the YouTube video.
-            chunk_number (int): The index of the transcript chunk to retrieve.
-            include_timestamps (bool): Whether to include timestamps in the transcript.
-
-        Returns:
-            str: The processed transcript chunk.
-
-        Raises:
-            ValueError: If the requested chunk number is out of range.
-        """
-        try:
-            transcript_json = YouTubeTranscriptApi.get_transcript(youtube_video_id)
-            text_splitter = RecursiveCharacterTextSplitter(
-                chunk_size=8192,
-                chunk_overlap=0,
-                separators=[f" {char}" for char in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
-            )
-
-            if include_timestamps:
-                transcript_data = [f"{entry['start']:.2f}: {entry['text']} " for entry in transcript_json]
-            else:
-                transcript_data = [entry['text'] for entry in transcript_json]
+from dotenv import load_dotenv, find_dotenv
 
-            transcript_text = " ".join(transcript_data)
-            transcript_splits = text_splitter.split_text(transcript_text)
-            
-            if chunk_number >= len(transcript_splits):
-                raise ValueError(f"Chunk number {chunk_number} is out of range. Total chunks: {len(transcript_splits)}")
-            
-            chunked_text = transcript_splits[chunk_number]
+_ = load_dotenv(find_dotenv()) # read local .env file
+openai.api_key = os.environ['OPENAI_API_KEY']
 
-            return YouTubeTranscriptTool._format_response(transcript_splits, chunk_number, chunked_text)
-        except Exception as e:
-            logger.error(f"Error in _get_transcript: {str(e)}")
-            return f"Error fetching transcript: {str(e)}"
+def get_temperature():
+    return 0  #Default value
 
-    @staticmethod
-    def _format_response(transcript_splits: List[str], chunk_number: int, chunked_text: str) -> str:
-        """
-        Formats the transcript chunk response.
+def set_temperature(new_temperature):
+    global get_temperature
+    def new_get_temperature():
+        return new_temperature
+    get_temperature = new_get_temperature
+    # print(f"Temperature set to: {get_temperature()}")
 
-        Args:
-            transcript_splits (List[str]): All transcript chunks.
-            chunk_number (int): The index of the current chunk.
-            chunked_text (str): The text of the current chunk.
+class Points_1(BaseModel):
+    """Pydantic model for representing extracted points from Youtube-Transcript"""
+    timestamp: float = Field(description="The timestamp (in floating-point number) of when main points are discussed or talked about in the video.")
+    main_point: str = Field(description="A title for Main point.")
+    summary: str = Field(description="A summary of main points discussed at that timestamp. End with fullstop.")
+    emoji: str = Field(description="An emoji that matches the summary.")
 
-        Returns:
-            str: Formatted response string.
-        """
-        if len(transcript_splits) == 1:
-            return f"Note: Complete subtitles returned.\n\nSubtitles:{chunked_text}"
-        elif chunk_number == len(transcript_splits) - 1:
-            return f"Note: Last chunk of subtitles returned.\n\nSubtitles:{chunked_text}"
-        else:
-            return f"Note: Partial subtitles returned. To get the next chunk, use chunk_number = {chunk_number + 1}.\n\nSubtitles:{chunked_text}"
-
-class Points(BaseModel):
+class Points_2(BaseModel):
     """Pydantic model for representing extracted points."""
-    point: str = Field(description="The main topic, theme, or subject extracted from the subtitle.")
-    context: str = Field(description="The context or brief explanation of the main point.")
+    main_point: str = Field(description="The main topic, theme, or subject extracted from the subtitle.")
+    summary: str = Field(description="The context or brief explanation of the main point.")
     emoji: str = Field(description="An emoji that represents or summarizes the main point.")
     timestamp: float = Field(description="The timestamp (in floating-point number) from the video where the main point is mentioned.")
 
@@ -170,16 +77,19 @@ class MainPointsExtractor:
     using natural language processing techniques.
     """
 
-    class Info(BaseModel):
+    class Info_1(BaseModel):
         """Pydantic model for representing a collection of points."""
-        points: List[Points]
+        points: List[Points_1]
+    
+    class Info_2(BaseModel):
+        """Pydantic model for representing a collection of points."""
+        points: List[Points_2]
     
     @staticmethod
     @tool(return_direct=True)
-    @log_errors
     def get_youtube_video_main_points(youtube_video_id: str) -> str:
         """
-        Extracts and formats main points from a YouTube video transcript.
+        Extracts and formats main points with Timestamps from YouTube video transcripts. Timestamps are formatted for direct use in YouTube comments, enabling clickable links to specific video sections when pasted.
 
         Args:
             youtube_video_id (str): The ID of the YouTube video.
@@ -189,14 +99,14 @@ class MainPointsExtractor:
         """
         try:
             transcript = MainPointsExtractor._get_youtube_video_transcript(youtube_video_id)
-            main_points = MainPointsExtractor._extract_main_points(transcript)
-            return MainPointsExtractor._format_youtube_comment(main_points)
+            main_points_1 = MainPointsExtractor._extract_main_points(transcript, MainPointsExtractor.Info_1)
+            main_points_2 = MainPointsExtractor._extract_main_points(transcript, MainPointsExtractor.Info_2)
+            formatted_output = f"""Main points extracted from YouTube video (ID: {youtube_video_id})\nStyle_1:\n```\n{main_points_2}\n```\nStyle_2:\n```\n{main_points_1}\n```\nChoose the style that best suits your needs for presenting the main points of the video."""
+            return formatted_output
         except Exception as e:
-            logger.error(f"Error in get_youtube_video_main_points: {str(e)}")
-            return f"Error extracting main points: {str(e)}"
+            raise
 
     @staticmethod
-    @log_errors
     def _get_youtube_video_transcript(youtube_video_id: str) -> str:
         """
         Fetches the transcript for a YouTube video.
@@ -215,47 +125,66 @@ class MainPointsExtractor:
             transcript_data = [f"{entry['start']:.2f}: {entry['text']} " for entry in transcript_json]
             return "".join(transcript_data)
         except Exception as e:
-            logger.error(f"Error fetching transcript: {str(e)}")
             raise
 
     @staticmethod
-    @functools.lru_cache(maxsize=16)
-    def _extract_main_points(transcript: str) -> List[Dict[str, Any]]:
+    def _extract_main_points(transcript: str, info_model: Union[Type[Info_1], Type[Info_2]]) -> List[Dict[str, Any]]:
         """
         Extracts main points from the transcript using NLP techniques.
-
-        This method is cached to improve performance for repeated calls.
+        
+        This method maintains a conversation history to provide context for subsequent calls.
 
         Args:
             transcript (str): The full transcript of the video.
-
+        
         Returns:
             List[Dict[str, Any]]: A list of dictionaries containing extracted main points.
         """
-        main_points_extraction_function = [convert_to_openai_function(MainPointsExtractor.Info)]
+        main_points_extraction_function = [convert_to_openai_function(info_model)]
         
-        model = ChatOpenAI(temperature=0)
-        extraction_model = model.bind(functions=main_points_extraction_function, function_call={"name": "Info"})
+        model = ChatOpenAI(temperature=get_temperature())
         
-        prompt = ChatPromptTemplate.from_messages([("human", "{input}")])
-        extraction_chain = prompt | extraction_model | JsonKeyOutputFunctionsParser(key_name="points")
+        extraction_model = model.bind(functions=main_points_extraction_function)
+        
+        system_message = f"""
+        You are an AI assistant that extracts info from video transcripts.
+        When extracting info, ensure that:
+        1. Each point has a unique timestamp.
         
+        In addition to these specific requirements, you have the authority to make other improvements as you see fit. This may include:
+
+        - Refining the summaries for clarity and conciseness
+        - Adjusting emoji choices to better represent the content
+        - Reorganizing points for better logical flow
+        - Removing redundant information
+        - Adding context where necessary
+
+        Your goal is to produce a refined and accurate representation of the main points from the video transcript. Use your judgment to balance adherence to the specific rules with overall improvement of the extracted information.
+        """
+        
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", system_message),
+            ("human", "{input}")
+        ])
+        
+        extraction_chain = prompt | extraction_model | JsonKeyOutputFunctionsParser(key_name="points")
+
         text_splitter = RecursiveCharacterTextSplitter(chunk_overlap=0, chunk_size=8192, separators=[f" {char}" for char in "123456789"])
         
         prep = RunnableLambda(lambda x: [{"input": doc} for doc in text_splitter.split_text(x)])
         
-        chain = prep | extraction_chain.map() | MainPointsExtractor._flatten
+        chain = prep | extraction_chain.map() | MainPointsExtractor._flatten | MainPointsExtractor._format_youtube_comment
         
-        return chain.invoke(transcript)
+        result_1 = chain.invoke(transcript)
+                
+        return result_1
 
     @staticmethod
-    @log_errors
     def _flatten(matrix):
         """Flattens a 2D list into a 1D list."""
         return [item for row in matrix for item in row]
 
     @staticmethod
-    @log_errors
     def _format_youtube_comment(json_data: List[Dict[str, Any]]) -> str:
         """
         Formats extracted main points into a YouTube-style comment.
@@ -276,11 +205,18 @@ class MainPointsExtractor:
         for entry in json_data:
             timestamp = _format_timestamp(entry['timestamp'])
             emoji = entry['emoji']
-            point = entry['point']
-            context = entry['context']
-            formatted_comment += f"{timestamp} {emoji} {point}: {context}\n"
+            summary = entry['summary']
+            
+            if entry['main_point'].endswith('.'):
+                point = entry['main_point'][:-1]
+            else:
+                point = entry['main_point']
+                
+            formatted_comment += f"{timestamp} {emoji} {point}: {summary}\n"
             
         return formatted_comment.strip()
+    
+#######################################################################################################################################    
 
 class Summary(BaseModel):
     """Pydantic model for representing extracted summary."""
@@ -300,7 +236,6 @@ class SummaryExtractor:
 
     @staticmethod
     @tool(return_direct=False)
-    @log_errors
     def get_youtube_video_summary(youtube_video_id: str) -> str:
         """
         Extracts and formats a summary from a YouTube video transcript.
@@ -316,11 +251,9 @@ class SummaryExtractor:
             summary = SummaryExtractor._extract_summary(transcript)
             return SummaryExtractor._format_summary(summary)
         except Exception as e:
-            logger.error(f"Error in get_youtube_video_summary: {str(e)}")
             return f"Error extracting summary: {str(e)}"
 
     @staticmethod
-    @log_errors
     def _get_youtube_video_transcript(youtube_video_id: str) -> str:
         """
         Fetches the transcript for a YouTube video.
@@ -339,11 +272,9 @@ class SummaryExtractor:
             transcript_data = [entry['text'] for entry in transcript_json]
             return " ".join(transcript_data)
         except Exception as e:
-            logger.error(f"Error fetching transcript: {str(e)}")
             raise
 
     @staticmethod
-    @functools.lru_cache(maxsize=16)
     def _extract_summary(transcript: str) -> List[Summary]:
         """
         Extracts a summary from a YouTube video transcript.
@@ -356,8 +287,9 @@ class SummaryExtractor:
         """
         summary_extraction_function = [convert_to_openai_function(SummaryExtractor.Info)]
         
-        model = ChatOpenAI(temperature=0)
-        extraction_model = model.bind(functions=summary_extraction_function, function_call={"name": "Info"})
+        model = ChatOpenAI(temperature=get_temperature())
+        
+        extraction_model = model.bind(functions=summary_extraction_function)
         
         prompt = ChatPromptTemplate.from_messages([("human", "{input}")])
         
@@ -382,6 +314,128 @@ class SummaryExtractor:
         """
         return "\n\n".join([s["summary"] for s in summaries])
 
+#############################################################################################################################################################
+
+class Answer(BaseModel):
+    """Pydantic model for representing an answer to a question."""
+    answer: str = Field(description="The answer to the user's question based on the video transcript.")
+    confidence: float = Field(description="A confidence score between 0 and 1 indicating how certain the model is about the answer.")
+
+class QuestionAnswerExtractor:
+    """
+    A tool for answering questions about YouTube videos based on their transcripts.
+
+    This class provides methods to process transcripts and generate answers to user questions
+    using natural language processing techniques.
+    """
+    
+    class Info(BaseModel):
+        """Pydantic model for representing a collection of answers."""
+        answers: List[Answer]
+
+    @staticmethod
+    @tool(return_direct=True)
+    def get_answer(youtube_video_id: str, question: str) -> str:
+        """
+        Answers a question about a YouTube video based on its transcript.
+        
+        Args:
+            youtube_video_id (str): The ID of the YouTube video.
+            question (str): The user's question about the video.
+
+        Returns:
+            str: Formatted string containing the answer to the user's question.
+        """
+        try:
+            transcript = QuestionAnswerExtractor._get_youtube_video_transcript(youtube_video_id)
+            answer = QuestionAnswerExtractor._extract_answer(transcript, question)
+            return QuestionAnswerExtractor._format_answer(answer)
+        except Exception as e:
+            return f"Error answering question: {str(e)}"
+
+    @staticmethod
+    def _get_youtube_video_transcript(youtube_video_id: str) -> str:
+        """
+        Fetches the transcript for a YouTube video.
+        
+        Args:
+            youtube_video_id (str): The ID of the YouTube video.
+        
+        Returns:
+            str: The full transcript of the video.
+        
+        Raises:
+            Exception: If there's an error fetching the transcript.
+        """
+        try:
+            transcript_json = YouTubeTranscriptApi.get_transcript(youtube_video_id)
+            transcript_data = [entry['text'] for entry in transcript_json]
+            return " ".join(transcript_data)
+        except Exception as e:
+            raise
+
+    @staticmethod
+    def _extract_answer(transcript: str, question: str) -> List[Answer]:
+        """
+        Extracts an answer to the user's question from the YouTube video transcript.
+        
+        Args:
+            transcript (str): The full transcript of the video.
+            question (str): The user's question about the video.
+        
+        Returns:
+            List[Answer]: A list of Answer objects containing the extracted answers.
+        """
+        answer_extraction_function = [convert_to_openai_function(QuestionAnswerExtractor.Info)]
+        
+        model = ChatOpenAI(temperature=get_temperature())
+        extraction_model = model.bind(functions=answer_extraction_function, function_call={"name": "Info"})
+        
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are an AI assistant tasked with answering questions about a video based on its transcript."),
+            ("human", "Transcript: {transcript}\n\nQuestion: {question}\n\nProvide an answer to the question based on the transcript, along with a confidence score.")
+        ])
+        
+        extraction_chain = prompt | extraction_model | JsonKeyOutputFunctionsParser(key_name="answers")
+        
+        text_splitter = RecursiveCharacterTextSplitter(chunk_overlap=192, chunk_size=8000, separators=[f" {char}" for char in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"])
+        
+        def prepare_input(x):
+            chunks = text_splitter.split_text(x['transcript'])
+            return [{"transcript": chunk, "question": x['question']} for chunk in chunks]
+        
+        prep = RunnableLambda(prepare_input)
+        
+        chain = prep | extraction_chain.map() | QuestionAnswerExtractor._flatten
+        
+        return chain.invoke({"transcript": transcript, "question": question})
+        
+    @staticmethod
+    def _flatten(matrix):
+        """Flattens a 2D list into a 1D list."""
+        return [item for row in matrix for item in row]
+        
+    @staticmethod
+    def _format_answer(answers: List[Answer]) -> str:
+        """
+        Formats the list of answers into a single string.
+        
+        Args:
+            answers (List[Answer]): List of Answer objects.
+
+        Returns:
+            str: A formatted string containing the best answer and its confidence score.
+        """
+        if not answers:
+            return "I couldn't find an answer to your question based on the video transcript."
+        
+        # Sort answers by confidence score and take the best one
+        best_answer = max(answers, key=lambda x: x['confidence'])
+        
+        return f"{best_answer['answer']}({best_answer['confidence']:.2f})"
+
+#######################################################################################################################################
+
 class YouTubeAgent:
     """
     An agent for interacting with YouTube videos and processing user queries.
@@ -392,28 +446,33 @@ class YouTubeAgent:
 
     def __init__(self):
         """Initializes the YouTubeAgent with necessary tools and components."""
+        
         self.tools = [
-            YouTubeTranscriptTool.get_transcript_with_timestamps,
-            YouTubeTranscriptTool.get_transcript_without_timestamps,
             MainPointsExtractor.get_youtube_video_main_points,
-            SummaryExtractor.get_youtube_video_summary
+            SummaryExtractor.get_youtube_video_summary,
+            QuestionAnswerExtractor.get_answer
         ]
+        
         self.sys_message = "You are a helpful assistant."
+        
         self.functions = [convert_to_openai_function(f) for f in self.tools]
-        self.model = ChatOpenAI(temperature=0).bind(functions=self.functions)
+        
+        self.model = ChatOpenAI(temperature=get_temperature()).bind(functions=self.functions)
+        
         self.prompt = ChatPromptTemplate.from_messages([
             ("system", self.sys_message),
             MessagesPlaceholder(variable_name="history"),
             ("user", "{input}"),
             MessagesPlaceholder(variable_name="agent_scratchpad")
         ])
+        
         self.agent_chain = RunnablePassthrough.assign(
             agent_scratchpad= lambda x: format_to_openai_functions(x["intermediate_steps"])
         ) | self.prompt | self.model | OpenAIFunctionsAgentOutputParser()
+        
         self.memory = ConversationBufferWindowMemory(k=3, return_messages=True, memory_key="history")
         self.agent_executor = AgentExecutor(agent=self.agent_chain, tools=self.tools, memory=self.memory)
-    
-    @log_errors
+
     def invoke(self, input_text: str) -> str:
         """
         Processes a user input and returns the agent's response.
@@ -428,16 +487,8 @@ class YouTubeAgent:
             result = self.agent_executor.invoke({"input": input_text})
             return result['output']
         except Exception as e:
-            logger.error(f"Error in YouTubeAgent.invoke: {str(e)}")
             return f"An error occurred: {str(e)}"
 
-# # Usage example
-# if __name__ == "__main__":
-#     youtube_agent = YouTubeAgent()
-#     video_link = "https://www.youtube.com/watch?v=dZxbVGhpEkI"
-#     try:
-#         main_points = youtube_agent.invoke(f"Can you get summary of the following video {video_link}")
-#     except Exception as e:
-#         logger.error(f"An error occurred during processing: {str(e)}")
-#         print(f"An error occurred: {str(e)}")
-
+# youtube_agent = YouTubeAgent()
+# video_link = "https://www.youtube.com/watch?v=-OSxeoIAs2w"
+# main_points = youtube_agent.invoke(f"The race involves which challenges in the following video {video_link}")