Updated app.py

.gitignore

@@ -0,0 +1,3 @@
+/.streamlit
+script_history.json
+/__pycache__

DOCS.md

@@ -0,0 +1,37 @@
+# Documentation
+### 1. Initial Setup and Requirements
+
+The original boilerplate simply performs only script generating task. The libraries used for this boilerplate includes Langchain, DuckDuckGo, and dotenv.
+### 2. Very Noticeable Changes
+
+Instead of just simply performing YouTube script generation, I had decided to utilize mutimodal technologies for this project that includes out of the box features including thumbnail generation and creative consultation. This may help improve usability and utility of this project as this may help induce creativity in content creation. 
+
+Instead of using the text completion model of the original, I had rather used the ChatOpenAI library instead for richer and straightforward responses using the model GPT-4o mini. For image generation, I have also utilized Dall-E 3, one of the few image generation models provided by OpenAI. This accurately generates images based on style, albeit limitations including options for aspect ratio.
+
+Instead of DuckDuckGo due to unpredictable API limits, we will be using Serpo API for fetching Google Search Results, providing quality search results. This also has a limit of 2500 requests for free tier, which is a limitation but this project is made for personal use in mind.
+
+Storing scripts using **json** provides an organized access to scripts and files which can be stored an prepared later for future use.
+
+To store secrets, we will use Streamlit instead as being modular and quick to set-up rather than dotenv.
+### 3. Every Python File Explained
+
+This project utilizes multiple python files. The **app.py** is where the main application resides. Following that includes the **scriptgen.py (Script Generation)**, **imggen.py (Image Generation)**, **tweaker.py (Creative Consultant)**, and the **secretary.py (Script Secretary)**.
+
+The **scriptgen.py** is where the the interface of the script generation resides. This is also associated with the **generate_script.py** where the loading and the rest of the script generation logic resides. For every script that is generated, this will be saved on a **.json** file storing the script metadata for later use and will be loaded on other tools such as Image Generation and Creative Consultant.
+
+The **imggen.py** contains the interface and the logic of the image generation. This can be used independently for image generation if the **Other** option is selected and can be customized with styles.
+
+The **tweaker.py** is where the creative consultant resides. This only accepts prompts related to its job and gives the user a way to fine-tune scripts with the model. The user has an option to clear the conversation if needed.
+
+Lastly is the **secretary.py** that enables the user to download or delete scripts if needed. This reads the **.json** file and lists them in an orderly manner, giving the users some reference of the generated scripts.
+### 4. Some Bugs and Quirks and Concerns
+
+Being a pre-trained model, OpenAI has filters turned on by default preventing generation of harmful content. This is not a bug but still considered a quirk of their models.
+### 5. What Can we Add?
+
+Implementing a text-to-video model can be possible however since this requires a lot of computing and monetary needs, this may not be possible for now. 
+### 6. Closing Statements
+
+This can be tweaked, changed, modified, or customized for better use, so feel free to experiment this app!
+
+

app.py

@@ -1,26 +1,32 @@
 import streamlit as st
 
-scriptgen = st.Page("scriptgen.py", title="Script Generator", default=True)
-imggen = st.Page("imggen.py", title="Image Generator")
-tweaker = st.Page("tweaker.py", title="Creative Consultant")
+st.set_page_config(layout='wide', page_icon='✨')
 
-replicate_api = st.secrets['REPLICATE_API_TOKEN']
+scriptgen = st.Page("scriptgen.py", title="Script Generator", icon='📃')
+imggen = st.Page("imggen.py", title="Thumbnail Generator", icon='🖼️')
+tweaker = st.Page("tweaker.py", title="Creative Consultant", icon='🎬')
+jsonbase = st.Page("secretary.py", title = "Script Secretary", icon='📚')
+manual = st.Page("manual.py", title="Manual", icon="👓", default= True)
+docs = st.Page("docs.py", title="Documentation", icon= '📑')
+
+api_key = st.secrets['OPENAI_API_KEY']
 
 # Sidebar for API Key input and options
 with st.sidebar:
     # Retrieve API Key from Streamlit secrets or prompt for input
-    if 'REPLICATE_API_TOKEN' in st.secrets:
-        if not (replicate_api.startswith('r8_') and len(replicate_api) == 40):
-            replicate_api = st.text_input('Enter your Replicate API token:', type='password')
+    if 'OPENAI_API_KEY' in st.secrets:
+        if not (api_key.startswith('sk-proj')):
+            api_key = st.text_input('Enter your OpenAI API token:', type='password')
             st.warning('Invalid or no API key! Please try again')
         else:
-            st.success('Try asking now!')
+            st.success('API Key Recognized!')
     else:
-        replicate_api = st.text_input('Enter your Replicate API token:', type='password')
+        api_key = st.text_input('Enter your OpenAI API token:', type='password')
 
     pg = st.navigation(
         {
-            "": [scriptgen, imggen, tweaker]
+            "Others":[manual, docs],
+            "Tools": [scriptgen, imggen, tweaker, jsonbase]
         }
     )
 

docs.py

@@ -0,0 +1,8 @@
+import streamlit as st
+
+def read_markdown_file(file_path):
+    with open(file_path, "r") as file:
+        return file.read()
+
+docs = read_markdown_file('DOCS.md')
+st.markdown(docs)

generate_script.py

@@ -1,41 +1,31 @@
-from langchain_community.llms import Replicate
+from langchain_openai import ChatOpenAI
 from langchain.chains import LLMChain
 from langchain.prompts import PromptTemplate
-from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.utilities import GoogleSerperAPIWrapper
 import os
 
-def generate_script(prompt, video_length, creativity, replicate_api):
+def generate_script(prompt, video_length, creativity, openai_api_key, serper_api_key):
     """
     Generate a YouTube video title and script based on the provided prompt, duration, and creativity level.
-    
-    Parameters:
-        prompt (str): Topic of the video.
-        video_length (float): Desired duration of the video in minutes.
-        creativity (float): Creativity level (0.0 to 1.0).
-        replicate_api (str): Replicate API Key for authentication.
-    
-    Returns:
-        tuple: Generated title, script, and search data.
     """
-    # Ensure the Replicate API key is set
-    if not replicate_api:
-        raise ValueError("Replicate API Key is missing.")
-    os.environ["REPLICATE_API_TOKEN"] = replicate_api
 
-    # Initialize the LLM with the Replicate model
-    llm = Replicate(
-        model="meta/meta-llama-3-8b-instruct",
-        input={
-        "top_k": 0,
-        "top_p": 0.95,
-        "prompt": prompt,
-        "max_tokens": 4096,
-        "temperature": 0.7,
-        "length_penalty": 1,
-        "max_new_tokens": 4096,
-        "presence_penalty": 0,
-        "log_performance_metrics": False
-    },
+    # Ensure the OpenAI API key is set
+    if not openai_api_key:
+        raise ValueError("OpenAI API Key is missing.")
+    os.environ["OPENAI_API_KEY"] = openai_api_key
+
+    # Ensure the Serper API key is set
+    if not serper_api_key:
+        raise ValueError("Serper API Key is missing.")
+    os.environ["SERPER_API_KEY"] = serper_api_key
+
+    # Initialize the LLM
+    llm = ChatOpenAI(
+        model='gpt-4o-mini',
+        temperature=creativity,
+        max_tokens=None,
+        timeout=None,
+        max_retries=2
     )
 
     # Define the title generation prompt
@@ -43,7 +33,7 @@ def generate_script(prompt, video_length, creativity, replicate_api):
         input_variables=["topic"],
         template="Generate a YouTube video title for the topic '{topic}'."
     )
-    title_chain = LLMChain(llm=llm, prompt=title_template, verbose=True)
+    title_chain = LLMChain(llm=llm, prompt=title_template, verbose=False)
 
     # Define the script generation prompt
     script_template = PromptTemplate(
@@ -53,24 +43,20 @@ def generate_script(prompt, video_length, creativity, replicate_api):
             "Incorporate the following research information: {search_data}."
         )
     )
-    script_chain = LLMChain(llm=llm, prompt=script_template, verbose=True)
+    script_chain = LLMChain(llm=llm, prompt=script_template, verbose=False)
 
-    # Fetch relevant search data using DuckDuckGo
-    search_tool = DuckDuckGoSearchRun()
-    search_data = search_tool.run(prompt)
+    # Fetch relevant search data using Google Serper
+    search_tool = GoogleSerperAPIWrapper()
+    search_data = search_tool.results(prompt)
 
-    # Generate the video title
+    # Generate the video title ONCE
     title = title_chain.run({"topic": prompt})
 
-    # Save the generated title to a file
-    with open("generated_title.txt", "w") as file:
-        file.write(title)
-
-    # Generate the video script
+    # Generate the video script using the title
     script = script_chain.run({
         "title": title,
         "duration": video_length,
-        "search_data": search_data
+        "search_data": search_data,
     })
 
     return title, script, search_data

generated_title.txt

@@ -0,0 +1 @@
+"10 Reasons Why AirPods Are the Ultimate Must-Have Tech!"

imggen.py

@@ -1,50 +1,118 @@
 import streamlit as st
-import replicate
+from openai import OpenAI
 import time
 from dotenv import load_dotenv
 import os
 import requests
 from io import BytesIO
 from PIL import Image
-import random
+import json
 
 # Load environment variables
 load_dotenv()
 
-# Check for a title from the script generator
-try:
-    with open("generated_title.txt", "r") as file:
-        title = file.read().strip()
-        prompt = title  # Use the title as the default prompt
-except FileNotFoundError:
-    st.warning("No title found! Please run the script generator first.")
-    prompt = ""  # Set an empty prompt if no title is available
+# Initialize OpenAI client
+client = OpenAI()
+
+# Load script history
+history_file = "script_history.json"
+
+
+def load_script_history():
+    if os.path.exists(history_file):
+        with open(history_file, "r") as file:
+            return json.load(file)
+    return []
+
+
+script_history = load_script_history()
 
 # Retrieve the API key
-replicate_api = st.secrets.get('REPLICATE_API_TOKEN') or os.getenv("REPLICATE_API_TOKEN")
+api_key = st.secrets.get('OPENAI_API_KEY') or os.getenv("OPENAI_API_KEY")
 
-if not replicate_api:
+if not api_key:
     st.error("API Key not provided! Please add it to Streamlit secrets or the .env file.")
 else:
-    os.environ['REPLICATE_API_TOKEN'] = replicate_api  # Set the API key for Replicate
+    os.environ['OPENAI_API_KEY'] = api_key  # Set the API key for OpenAI
 
 # Initialize session state for image history
 if "image_history" not in st.session_state:
     st.session_state.image_history = []
 
-# Streamlit UI setup
-st.title("AI Image Generator")
-prompt = st.text_input("Enter a prompt for the image", value=prompt)  # Use the title as the default value
-styles = st.multiselect("Image artstyle", ['Impressionism', 'Cubism', 'Surrealism', 'Baroque', 'Art Noveau', 'Cyberpunk', 'Synthwave', 'Anime', 'Pixel Art', 'Low Poly', 'Dark Fantasy', 'Space Opera', 'Steampunk', 'Fantasy', 'Abstract','Glitch Art', 'Kawaii','Pop Art'])
+# Main title
+st.title("Thumbnail Generator 🖼️")
+st.subheader('Create thumbnails with AI images for your video!')
+
+# Define layout with two columns
+left_col, right_col = st.columns(2, border= True)
+
+with left_col:
+    st.subheader('Input 👇')
+    # Generate script titles from history
+    script_titles = [f"Script {idx + 1}: {item['title']}" for idx, item in enumerate(script_history)]
+    
+    # Add an "Other" option for custom prompts
+    script_titles_with_other = script_titles + ["Other"]
+
+    # Select a script or choose "Other"
+    selected_option = st.selectbox(
+        "Choose a script to make a thumbnail or write one:",
+        range(len(script_titles_with_other)),
+        format_func=lambda x: script_titles_with_other[x]
+    )
 
-with st.sidebar:
-    st.title("Options")
-    aspect_ratio = st.selectbox("Aspect Ratio", ("16:9", "4:3", "3:2", "1:1", "21:9"))
-    seed = st.number_input("Seed (leave empty for random)", min_value=0, step=1, format="%d")
-    quality = st.slider("Quality", min_value=0, max_value=100, value=90, step=1)
-    strength = st.slider("Prompt Strength", min_value=0.0, max_value=1.0, value=0.9, step=0.01)
-    steps = st.slider("Sampling Steps", min_value=1, max_value=28, value=28, step=1)
-    cfg = st.slider("Similarity", min_value=0.0, max_value=20.0, value= 3.5, step=0.1)
+    # Set the prompt based on the selection
+    if script_titles_with_other[selected_option] == "Other":
+        prompt = st.text_input("Enter your custom script prompt:")
+    else:
+        prompt = script_titles_with_other[selected_option]
+
+    # Choose art styles
+    styles = st.multiselect(
+        "Image artstyle",
+        [
+            'Realism', 'Impressionism','Cubism', 'Surrealism', 'Baroque', 'Art Noveau', 'Cyberpunk',
+            'Synthwave', 'Anime', 'Pixel Art', 'Low Poly', 'Dark Fantasy', 'Space Opera',
+            'Steampunk', 'Fantasy', 'Abstract', 'Glitch Art', 'Kawaii', 'Pop Art'
+        ],
+        max_selections=3
+    )
+
+    # Sidebar options
+    with st.sidebar:
+        st.title("Options")
+        size = st.selectbox("Size", ("1024x1024", "1024x1792", "1792x1024"))
+        quality = st.selectbox("Quality", ("standard", "hd"))
+
+    # Handle image generation
+    if st.button("Generate Image"):
+        if not prompt:
+            st.error("Please enter a prompt!")
+        else:
+            with st.spinner('Generating image...'):
+                start_time = time.time()
+                try:
+                    # Call the OpenAI API to generate images
+                    output = client.images.generate(
+                        model="dall-e-3",
+                        prompt=f"{prompt}. Apply these styles if provided: {', '.join(styles)}" if styles else prompt,
+                        quality=quality,
+                        size=size,
+                        n=1
+                    )
+                    # Access the URL from the response
+                    if output and hasattr(output, 'data'):
+                        image_url = output.data[0].url  # Get the first image URL
+                        right_col.image(image_url, caption="Generated Image", use_container_width=True)
+                        elapsed_time = time.time() - start_time
+                        right_col.write(f"Image Generated in {elapsed_time:.2f} seconds")
+
+                        # Save to session state
+                        st.session_state.image_history.append((image_url, prompt))
+                    else:
+                        right_col.error("No output received. Please try again!")
+                except Exception as e:
+                    right_col.error(f"An error occurred: {str(e)}")
 
 # Function to convert image URL to PNG buffer
 def get_image_buffer(image_url):
@@ -58,62 +126,25 @@ def get_image_buffer(image_url):
     else:
         return None
 
-# Handle image generation
-if st.button("Generate Image"):
-    seed = int(seed) if seed else random.randint(0, 99999)
 
-    if not prompt:
-        st.error("Please enter a prompt!")
-    else:
-        with st.spinner('Generating image...'):
-            start_time = time.time()
-            try:
-                # Replicate API call
-                output = replicate.run(
-                    "stability-ai/stable-diffusion-3",
-                    input={
-                        "cfg": cfg,
-                        "steps": steps,
-                        "prompt": f"With this context of the prompt: {prompt}, make me a video thumbnail with these artstyles: {styles}",
-                        "aspect_ratio": aspect_ratio,
-                        "output_format": "png",
-                        "output_quality": quality,
-                        "negative_prompt": "bad quality, worse quality, deformed",
-                        "prompt_strength": strength,
-                        "seed": seed
-                    }
-                )
-                # Display output and elapsed time
-                if output:
-                    image_url = output[0]
-                    st.image(image_url, caption="Generated Image", use_container_width=True)
-                    end_time = time.time()
-                    elapsed_time = end_time - start_time
-                    st.write(f"Image Generated in {elapsed_time:.2f} seconds")
-
-                    # Save to session state
-                    st.session_state.image_history.append((image_url, prompt))
-                else:
-                    st.error("No output received. Please try again!")
-            except Exception as e:
-                st.error(f"An error occurred: {str(e)}")
-
-# Display image history
-with st.expander("Show Prompt History"):
-    if st.session_state.image_history:
-        for idx, (image_url, image_prompt) in enumerate(reversed(st.session_state.image_history)):
-            st.subheader(f"Image {len(st.session_state.image_history) - idx}")
-            st.text(f"Prompt: {image_prompt}")
-            st.image(image_url, use_container_width=True)
-
-            # Generate download button for each image
-            buffer = get_image_buffer(image_url)
-            if buffer:
-                st.download_button(
-                    label="Download Image",
-                    data=buffer,
-                    file_name=f"generated_image_{len(st.session_state.image_history) - idx}.png",
-                    mime="image/png"
-                )
-    else:
-        st.write("No images generated yet.")
+with right_col:
+    st.subheader('Output ✨')
+    # Display image history
+    with st.expander("Show Prompt History"):
+        if st.session_state.image_history:
+            for idx, (image_url, image_prompt) in enumerate(reversed(st.session_state.image_history)):
+                st.subheader(f"Image {len(st.session_state.image_history) - idx}")
+                st.text(f"Prompt: {image_prompt}")
+                st.image(image_url, use_container_width=True)
+
+                # Generate download button for each image
+                buffer = get_image_buffer(image_url)
+                if buffer:
+                    st.download_button(
+                        label="Download Image",
+                        data=buffer,
+                        file_name=f"generated_image_{len(st.session_state.image_history) - idx}.png",
+                        mime="image/png"
+                    )
+        else:
+            st.write("No images generated yet.")

manual.py

@@ -0,0 +1,28 @@
+import streamlit as st
+
+st.header("Welcome to ImaGen Creator Toolkit! ✨")
+st.write('''Powered with OpenAI, this toolkit helps you create scripts and thumbnails for your next YouTube video. 
+         ''')
+
+st.subheader("1. Things you need before you begin")
+st.markdown("Please make sure you have your **OpenAI API Key** ready to be able to use this toolkit. If none provided, you may be prompted to enter the **API Key**. You may visit the OpenAI for you to retrieve your **API Key**." )
+st.info("Please take note that using the API also requires additional payment")
+
+st.subheader('2. Script Generator')
+st.markdown('The **Script Generator** lets the user prompt to create a script. Below this lets you estimate the timeframe for your script. Simply press **Generate Script** then an output of your script will be ready.')
+st.image('resources/scriptgen.png')
+st.markdown('Some advanced options include **Creativity**. The lower the values, the more on-point the topic will be.')
+
+st.subheader('3. Thumbnail Generator')
+st.markdown('The **Thumbnail Generator** makes you create images based on the titles of your pre-made scripts alongside with **Styles** that helps you configure a particular style. You may opt creating one without the script by selecting **Others** on the select box.  To start creating, simply press **Generate Image**.')
+st.image('resources/imggen.png')
+st.markdown('Some advanced options include the **Image Size** limited by the model and the the **Quality**. For higher quality outputs, you can choose the **hd** option or upscale the image size.')
+st.info('Note that it does not support widescreen (16:9), so you need to manually edit it after.')
+
+st.subheader('4. Creative Consultant')
+st.markdown("The **Creative Consultant** is a chatbot that gives you advice on your scripts or helps you tweak some changes of the generated scripts. On the sidebar contains options for you to select scripts for it to look over. Ask the consultant nearly everything unless it's all about coding or some matters.")
+st.image("resources/tweaker.png")
+
+st.subheader("5. Script Secretary")
+st.markdown("The **Script Secretary** manages all of your saved scripts. It gives you an option to **Download** the script as the text file or **Delete** them entirely. ")
+st.image("resources/secretary.png")

requirements.txt

@@ -1,7 +1,7 @@
 streamlit
 langchain_community
+langchain_openai
 langchain
 replicate
 openai
-duckduckgo_search
 python-dotenv

scriptgen.py

@@ -2,52 +2,98 @@ import streamlit as st
 from dotenv import load_dotenv
 from generate_script import generate_script
 import os
+import json
+
+# File to store script history
+history_file = "script_history.json"
 
 # Load environment variables from .env file
 load_dotenv()
 
-# Streamlit app title and subtitle
-st.title("YouTube-Inator")
-st.subheader("Make fun stuff with YouTube-Inator!")
-
-with st.sidebar:
-    st.title("Options")
-    creativity = st.slider("Set creativity level:", min_value=0.0, max_value=1.0, value=0.5)
-
-
-# Input fields for video generation parameters
-prompt = st.text_input("Provide the topic of the video:", placeholder="e.g., How to bake a cake")
-video_length = st.number_input("Specify length in minutes", min_value=1.0, step=0.5, value= 10.0)
-
-# Button to generate the video script
-generate_script_button = st.button("Generate Script")
-
-# Generate script on button click
-if generate_script_button:
-    if not replicate_api:
-        st.error("Please provide a valid API Key.")
-    else:
-        # Set the API Key in the environment variable for use by other modules
-        os.environ["REPLICATE_API_TOKEN"] = replicate_api
-        
-        try:
-            # Generate the video script using the utility function
-            with st.spinner("Generating your script..."):
-                title, script, search_data = generate_script(prompt, video_length, creativity, replicate_api)
-            
-            # Display the results
-            st.success("Script generated successfully!")
-            st.subheader(f"Title: {title}")
-            st.write(f"Script: {script}")
-            
-            # Display additional search data
-            with st.expander("Show search data for the script"):
-                st.write(search_data)
-        
-        except Exception as e:
-            # Handle any errors that occur during script generation
-            st.error(f"An error occurred. Try again {e}")
-            with st.expander("Expand to see details"):
-                st.write(f'{e}')
-
-            
+st.title("Script Generator 📃")
+st.subheader("Create your script with just a single prompt!")
+
+# Retrieve API key from secrets or environment variables
+api_key = st.secrets.get("OPENAI_API_KEY") or os.getenv("OPENAI_API_KEY")
+serper_api_key = st.secrets.get("SERPER_API_KEY") or os.getenv("SERPER_API_KEY")
+
+if not api_key:
+    st.error("Please provide a valid API Key in Streamlit secrets or .env file.")
+else:
+    os.environ["OPENAI_API_KEY"] = api_key
+
+# Function to load history from file
+def load_history():
+    if os.path.exists(history_file):
+        with open(history_file, "r") as file:
+            return json.load(file)
+    return []
+
+# Function to save history to file
+def save_history(history):
+    with open(history_file, "w") as file:
+        json.dump(history, file, indent=4)
+
+# Load history from JSON file
+script_history = load_history()
+
+# Layout with two columns
+col1, col2 = st.columns(2, border= True)
+
+# Left column for inputs
+with col1:
+    st.subheader("Input 👇")
+    prompt = st.text_input("Provide the topic of the video:", placeholder="e.g., How to bake a cake")
+    video_length = st.number_input("Specify length in minutes", min_value=1.0, step=0.5, value=10.0)
+
+    with st.sidebar:
+        st.title("Options")
+        creativity = st.slider("Set creativity level:", min_value=0.0, max_value=1.0, value=0.5)
+
+    # Button to generate the video script
+    generate_script_button = st.button("Generate Script")
+
+# Right column for results
+with col2:
+    st.subheader("Output ✨")
+
+    if generate_script_button:
+        if not prompt:
+            st.error("Please provide a topic for the video.")
+        else:
+            try:
+                # Generate the video script using the utility function
+                with st.spinner("Generating your script..."):
+                    title, script, search_data = generate_script(prompt, video_length, creativity, api_key, serper_api_key)
+
+                # Display the results
+                st.success("Script generated successfully!")
+                st.subheader(f"Title: {title}")
+                st.write(f"Script: {script}")
+
+                # Save the new script directly to the JSON file
+                new_entry = {
+                    "title": title,
+                    "script": script,
+                    "search_data": search_data,
+                }
+                script_history.append(new_entry)
+                save_history(script_history)
+
+                # Add a download button for the generated script
+                st.download_button(
+                    label="Download Script",
+                    data=script,
+                    file_name="generated_script.txt",
+                    mime="text/plain",
+                )
+
+                # Display additional search data
+                with st.expander("Show search data for the script"):
+                    st.write(search_data)
+
+            except Exception as e:
+                # Handle any errors that occur during script generation
+                st.error("An error occurred. Try again.")
+                with st.expander("Expand to see details"):
+                    st.write(f"{e}")

secretary.py

@@ -0,0 +1,62 @@
+import streamlit as st
+import json
+import os
+
+# Load script history
+history_file = "script_history.json"
+
+def load_script_history():
+    if os.path.exists(history_file):
+        with open(history_file, "r") as file:
+            return json.load(file)
+    return []
+
+def save_script_history(history):
+    with open(history_file, "w") as file:
+        json.dump(history, file, indent=4)
+
+# Load the script history
+script_history = load_script_history()
+
+st.title("Script Secretary 📚")
+st.header('Manage saved scripts in history.')
+
+# Display entries and provide delete/download functionality
+if script_history:
+    for idx, entry in enumerate(script_history):
+        # Add an expander for each script
+        with st.expander(entry.get("title","")):
+            # Display script content in a read-only text area
+            st.text_area(
+                "Script Content", 
+                value=entry.get("script", ""), 
+                height=150, 
+                disabled=True, 
+                key=f"text_area_{idx}"  # Unique key for each text area
+            )
+
+            # Add a button to download the script as a text file
+            st.download_button(
+                label="Download Script",
+                data=entry["script"],
+                file_name=f"{entry.get("title","")}.txt",
+                mime="text/plain"
+                )
+
+            # Add a delete button for each entry
+            if st.button(f"Delete Script", key=f"delete_{idx}"):
+                # Delete the selected entry
+                del script_history[idx]
+                save_script_history(script_history)
+                st.success(f"Script {idx + 1} deleted!")
+                st.rerun()  # Refresh the page to reflect the deletion
+else:
+    st.info("No script history found!")
+
+# Add a button to clear all history
+with st.sidebar:
+    if script_history and st.button("Clear All Scripts"):
+        script_history = []
+        save_script_history(script_history)
+        st.success("All script history cleared!")
+        st.rerun()

tweaker.py

@@ -1,97 +1,124 @@
 import streamlit as st
-from langchain_community.llms import Replicate
+import json
+import os
+from langchain_openai import ChatOpenAI
 from langchain.chains import ConversationChain
 from langchain.memory import ConversationSummaryMemory
 from langchain.prompts import ChatPromptTemplate
-import os
 
-# Setting page title and header
-st.title("Creative Consultant")
-st.subheader("Make fun stuff with YouTube-Inator!")
-
-# Sidebar for API key input and summarisation
-with st.sidebar:
-    # Button to summarise the conversation
-    summarise_button = st.button("Summarise the conversation", key="summarise_button")
-
-    # Check if the summarise button was clicked
-    if summarise_button:
-        if st.session_state.get('conversation') and st.session_state['conversation'].memory:
-            # Generate the summary
-            summary = st.session_state['conversation'].memory.buffer
-            st.session_state['summary'] = summary  # Store in session state
-            st.write("Summary:\n\n" + summary)
-        else:
-            # Handle case where no conversation memory exists
-            summary = "No conversation to summarise leh!"
-            st.write(summary)
-
-    # Add a download button if a summary exists
-    if st.session_state.get('summary'):
-        st.download_button(
-            label="Download Summary",
-            data=st.session_state['summary'],
-            file_name="conversation_summary.txt",
-            mime="text/plain",
-        )
+st.title('Creative Consultant 🎬')
+st.subheader('Ask content creation tips or help tweak your premade script!')
+
+# Load script history from `scriptgen.py`
+history_file = "script_history.json"
+
+def load_script_history():
+    if os.path.exists(history_file):
+        with open(history_file, "r") as file:
+            return json.load(file)
+    return []
+
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = [
+        {"role": "assistant", "content": "Hey there! I'm here to help you improve or tweak your scripts. Feel free to ask me anything related to content creation!"}
+    ]
+if "conversation" not in st.session_state:
+    st.session_state["conversation"] = None
+if "OPENAI_API_KEY" not in st.session_state:
+    st.session_state["OPENAI_API_KEY"] = ""
+
+def clear_chat_history():
+    st.session_state.messages = [{"role": "assistant", "content": "Chat history cleared. What would you like help with next?"}]
+
+
+
+# Load generated scripts from history
+script_history = load_script_history()
+
+# Sidebar for script selection
+if script_history:
+    st.sidebar.header("Previously Generated Scripts")
+    script_titles = [f"Script {idx + 1}: {item['title']}" for idx, item in enumerate(script_history)]
+    selected_script_idx = st.sidebar.selectbox("Choose a script to tweak:", range(len(script_titles)), format_func=lambda x: script_titles[x])
+    selected_script = script_history[selected_script_idx]
 
-# Initialize conversation state if not already done
-if 'conversation' not in st.session_state:
-    st.session_state['conversation'] = None
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
-if 'REPLICATE_API_TOKEN' not in st.session_state:
-    st.session_state['REPLICATE_API_TOKEN'] = ''
-
-# Function to get response from OpenAI model
-def get_response(user_input, replicate_api):
-    if st.session_state['conversation'] is None:
-        llm = Replicate(
-            model=("meta/meta-llama-3-8b-instruct"),
-            model_kwargs={
-                "temperature": 0.01,
-                "top_p": 0.9,
-                "max_length": 128,
-            },
+    # Display the selected script
+    st.sidebar.text_area("Script Content", value=selected_script["script"], height=200, disabled=True)
+else:
+    st.sidebar.info("No scripts available. Please generate scripts using the Script Generator.")
+
+st.sidebar.button('Clear Chat History', on_click=clear_chat_history)
+
+# Prompt template for the Creative Consultant
+prompt_template = ChatPromptTemplate.from_template(
+    """
+    You are a Creative Consultant focused on improving video scripts and YouTube content. 
+    You provide detailed feedback and actionable suggestions to make the scripts more engaging, concise, or tailored to the target audience.
+    
+    This is the conversation history:
+    {history}
+    
+    This is the user's new question or statement:
+    {input}
+    
+    Provide specific recommendations or edits based on the selected script. Ensure your feedback remains within the scope of content creation and creativity.
+    """
+)
+
+# Function to get response from the LLM
+def get_response(user_input):
+    if st.session_state["conversation"] is None:
+        llm = ChatOpenAI(
+            model='gpt-4o-mini',
+            temperature=0.1,
+            max_tokens=512,
+            timeout=None,
+            max_retries=2
         )
-        st.session_state['conversation'] = ConversationChain(
+        st.session_state["conversation"] = ConversationChain(
             llm=llm,
             verbose=True,
             memory=ConversationSummaryMemory(llm=llm),
+            prompt=prompt_template
         )
-    # Call the conversation chain
-    response_dict = st.session_state['conversation'].invoke(input=user_input)
-    
-    # Extract the response field only
-    return response_dict.get("response", "No response generated leh!")
-
-# Function to get user input
-def get_text():
-    chat_input = st.chat_input("Say Hello")
-    return chat_input
+    response_dict = st.session_state["conversation"].invoke(input=user_input)
+    return response_dict.get("response", "No response generated.")
 
 # Display chat history
-if st.session_state.messages:
-    for msg in st.session_state.messages:
-        with st.chat_message(msg["role"]):
-            st.markdown(msg["content"])
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
 
-# Get user input
-user_input = get_text()
+# User input
+user_input = st.chat_input("Ask for feedback or tweaks on your selected script...")
 
 if user_input:
+    # Append user input to session state and display it
+    st.session_state.messages.append({"role": "user", "content": user_input})
+    with st.chat_message("user"):
+        st.markdown(user_input)
+
     try:
-        # Get the response from the LLM
-        response = get_response(user_input, st.session_state['REPLICATE_API_TOKEN'])
-        
-        # Append the user message to session state
-        st.session_state.messages.append({"role": "user", "content": user_input})
-        with st.chat_message("user"):
-            st.markdown(user_input)
-
-        # Append and display the LLM response
-        st.session_state.messages.append({"role": "LLM", "content": response})
-        with st.chat_message("LLM"):
+        # Use the selected script as context for the assistant's response
+        if script_history:
+            user_input_with_context = f"""
+            The user selected the following script for feedback:
+            Title: {selected_script['title']}
+            Script Content: {selected_script['script']}
+            
+            User's query: {user_input}
+            """
+        else:
+            user_input_with_context = user_input
+
+        # Generate the assistant's response
+        with st.spinner():
+            response = get_response(user_input_with_context)
+            st.session_state.messages.append({"role": "assistant", "content": response})
+
+        # Display assistant's response
+        with st.chat_message("assistant"):
             st.markdown(response)
 
     except Exception as e: