Create app.py

app.py

@@ -0,0 +1,659 @@
+from groq import Groq
+import streamlit as st
+from openai import OpenAI
+import json
+import streamlit.components.v1 as components
+import requests
+from youtube_transcript_api import YouTubeTranscriptApi
+from youtubesearchpython import VideosSearch
+from rdkit import Chem
+from rdkit.Chem import Draw, AllChem
+import os
+import queue
+import re
+import tempfile
+import threading
+import requests
+from bs4 import BeautifulSoup
+from embedchain import App
+from embedchain.config import BaseLlmConfig
+from embedchain.helpers.callbacks import (StreamingStdOutCallbackHandlerYield,
+                                          generate)
+
+client_groq = Groq(api_key="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")
+client_openai = OpenAI(api_key="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")
+
+link_custom_functions = [
+    {
+        'name': 'extract_website_url',
+        'description': 'Get the website url',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'link': {'type': 'string', 'description': 'website url'},
+        }
+    }
+    }
+]
+
+def embedchain_bot(db_path, api_key):
+    return App.from_config(
+        config={
+            "llm": {
+                "provider": "openai",
+                "config": {
+                    "model": "gpt-3.5-turbo-1106",
+                    "temperature": 0.5,
+                    "max_tokens": 1000,
+                    "top_p": 1,
+                    "stream": True,
+                    "api_key": api_key,
+                },
+            },
+            "vectordb": {
+                "provider": "chroma",
+                "config": {"collection_name": "chat-pdf", "dir": db_path, "allow_reset": True},
+            },
+            "embedder": {"provider": "openai", "config": {"api_key": api_key}},
+            "chunker": {"chunk_size": 2000, "chunk_overlap": 0, "length_function": "len"},
+        }
+    )
+
+
+def get_db_path():
+    tmpdirname = tempfile.mkdtemp()
+    return tmpdirname
+
+
+def get_ec_app(api_key):
+    if "app" in st.session_state:
+        print("Found app in session state")
+        app = st.session_state.app
+    else:
+        print("Creating app")
+        db_path = get_db_path()
+        app = embedchain_bot(db_path, api_key)
+        st.session_state.app = app
+    return app
+
+# Initialize your clients with API keys
+client_openai = OpenAI(api_key="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")
+client_groq = Groq(api_key="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")
+client_groq_one = Groq(api_key="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")
+
+# Define your custom functions for OpenAI
+scenario_custom_functions = [
+    {
+        'name': 'extract_scenario_info',
+        'description': 'Get the individual scenarios text',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'scenario_1': {'type': 'string', 'description': 'scenario number 1 full text'},
+                'scenario_2': {'type': 'string', 'description': 'scenario number 2 full text'},
+                'scenario_3': {'type': 'string', 'description': 'scenario number 3 full text'},
+                'scenario_4': {'type': 'string', 'description': 'scenario number 4 full text'},
+            }
+        }
+    }
+]
+
+scenario_keyword_functions = [
+    {
+        'name': 'extract_scenario_info',
+        'description': 'Get the individual scenarios text',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'keyword_1': {'type': 'string', 'description': 'keyword 1'},
+                'keyword_2': {'type': 'string', 'description': 'keyword 2'},
+                'keyword_3': {'type': 'string', 'description': 'keyword 3'},
+                'keyword_4': {'type': 'string', 'description': 'keyword 4'},
+            }
+        }
+    }
+]
+
+video_custom_functions = [
+    {
+        'name': 'extract_video_id',
+        'description': 'Get the video ID',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'video_id': {'type': 'string', 'description': 'video ID'},
+        }
+    }
+    }
+]
+# Initialize a string to store all transcripts
+all_video_transcripts = ""
+
+molecule_custom_functions = [
+    {
+        'name': 'extract_molecule_info',
+        'description': 'Get the molecule name',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'molecule_name': {'type': 'string', 'description': 'name of the molecule'},
+        }
+    }
+    }
+]
+
+keyword_custom_functions = [
+    {
+        'name': 'extract_keyword_info',
+        'description': 'Get the search query keyword',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'keyword': {'type': 'string', 'description': 'keyword of teh search query'},
+        }
+    }
+    }
+]
+
+# Example SMILES strings for each component - replace these with the actual values retrieved from your API calls
+reactant_1_smiles = 'your_reactant_1_smiles_here'
+reactant_2_smiles = 'your_reactant_2_smiles_here'  # This might be an empty string if not present
+reagent_3_smiles = 'your_reagent_3_smiles_here'
+product_4_smiles = 'your_product_4_smiles_here'
+product_5_smiles = 'your_product_5_smiles_here'
+molecule_custom_functions_reaction = [
+    {
+        'name': 'extract_molecules_info',
+        'description': 'Get the name of the individual molecules',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'reactant_1': {'type': 'string', 'description': 'reactant number 1 '},
+                'reactant_2': {'type': 'string', 'description': 'reactant number 2 '},
+                'reagent_3': {'type': 'string', 'description': 'reagent number 1 '},
+                'product_4': {'type': 'string', 'description': 'product number 1'},
+                'product_5': {'type': 'string', 'description': 'product number 2'},
+            }
+        }
+    }
+]
+
+# Streamlit UI
+st.title("Stereo World 🌍")
+image_variable = None
+# Session states initialization
+if 'prompt' not in st.session_state:
+    st.session_state.prompt = ''
+if 'selected_options' not in st.session_state:
+    st.session_state.selected_options = []
+if 'selected_options_reaction' not in st.session_state:
+    st.session_state.selected_options_reaction = []
+
+
+# User inputs
+st.session_state.prompt = st.text_input("Enter your prompt")
+st.session_state.selected_options = st.multiselect("Select options", ["fun based", "context based", "real world based", "conceptual textbook based"])
+check_box = st.checkbox("Open Chem Sketcher")
+with st.sidebar:
+    st.sidebar.title("Chat with the assistant 🤖")
+    # Input for search query
+    search_query = st.sidebar.text_input("Enter your video search query")
+    reaction_query = st.sidebar.text_input("Enter your reaction search query")
+    name_reaction = st.checkbox("I am searching a name reaction")
+    if name_reaction:
+        with st.sidebar:
+            #openai_access_token = st.text_input("OpenAI API Key", key="api_key", type="password")
+            api_key = "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"
+            
+
+            #if st.session_state.api_key:
+            app = get_ec_app(api_key)
+
+            pdf_files = st.file_uploader("Upload your PDF files", accept_multiple_files=True, type="pdf")
+            add_pdf_files = st.session_state.get("add_pdf_files", [])
+            for pdf_file in pdf_files:
+                file_name = pdf_file.name
+                if file_name in add_pdf_files:
+                    continue
+                try:
+                    temp_file_name = None
+                    with tempfile.NamedTemporaryFile(mode="wb", delete=False, prefix=file_name, suffix=".pdf") as f:
+                        f.write(pdf_file.getvalue())
+                        temp_file_name = f.name
+                    if temp_file_name:
+                        st.markdown(f"Adding {file_name} to knowledge base...")
+                        app.add(temp_file_name, data_type="pdf_file")
+                        st.markdown("")
+                        add_pdf_files.append(file_name)
+                        os.remove(temp_file_name)
+                    st.session_state.messages.append({"role": "assistant", "content": f"Added {file_name} to knowledge base!"})
+                except Exception as e:
+                    st.error(f"Error adding {file_name} to knowledge base: {e}")
+                    st.stop()
+            st.session_state["add_pdf_files"] = add_pdf_files
+
+            if "messages" not in st.session_state:
+                st.session_state.messages = []
+
+        for message in st.session_state.messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+        if prompt := st.chat_input("Ask me anything!"):
+            app = get_ec_app(api_key)
+
+            with st.chat_message("user"):
+                st.session_state.messages.append({"role": "user", "content": prompt})
+                st.markdown(prompt)
+
+            with st.chat_message("assistant"):
+                msg_placeholder = st.empty()
+                #msg_placeholder.markdown("Thinking...")
+                full_response = ""
+
+                q = queue.Queue()
+
+                def app_response(result):
+                    llm_config = app.llm.config.as_dict()
+                    llm_config["callbacks"] = [StreamingStdOutCallbackHandlerYield(q=q)]
+                    config = BaseLlmConfig(**llm_config)
+                    answer, citations = app.chat(prompt, config=config, citations=True)
+                    result["answer"] = answer
+                    result["citations"] = citations
+
+                results = {}
+                thread = threading.Thread(target=app_response, args=(results,))
+                thread.start()
+
+                for answer_chunk in generate(q):
+                    full_response += answer_chunk
+                    msg_placeholder.markdown(full_response)
+
+                thread.join()
+                # answer, citations = results["answer"], results["citations"]
+                # if citations:
+                #     full_response += "\n\n**Sources**:\n"
+                #     sources = []
+                #     for i, citation in enumerate(citations):
+                #         source = citation[1]["url"]
+                #         pattern = re.compile(r"([^/]+)\.[^\.]+\.pdf$")
+                #         match = pattern.search(source)
+                #         if match:
+                #             source = match.group(1) + ".pdf"
+                #         sources.append(source)
+                #     sources = list(set(sources))
+                #     for source in sources:
+                #         full_response += f"- {source}\n"
+
+                msg_placeholder.markdown(full_response)
+                print("Answer: ", full_response)
+                st.session_state.messages.append({"role": "assistant", "content": full_response})
+                if full_response:
+                    response_functions = client_openai.chat.completions.create(
+                            model="gpt-3.5-turbo",
+                            messages=[{'role': 'user', 'content': full_response}],
+                            functions=link_custom_functions,
+                            function_call='auto'
+                        )
+                    data = json.loads(response_functions.choices[0].message.function_call.arguments)
+                    website_url = data['link']
+                    # Check if the link starts with 'en.wiki'
+                    request = requests.get(f"https://{website_url}")
+                    if request.status_code == 200:
+                        # Parse the content of the request with BeautifulSoup
+                        soup = BeautifulSoup(request.text, 'html.parser')
+                        
+                        # Extract all text from the webpage
+                        text = soup.get_text(separator=' ', strip=True)
+                        
+                        # Print the extracted text
+                        data_websute = text
+                        chat_completion = client_groq.chat.completions.create(
+                        messages=[
+                            {
+                                "role": "user",
+                                "content": "please give complete step by step reaction along with the complete name of the molecules for the reaction, the requested reaction is : " + data_websute,
+                            }
+                        ],
+                        model="mixtral-8x7b-32768",
+                    )
+                        reaction = chat_completion.choices[0].message.content
+                        response_functions = client_openai.chat.completions.create(
+                            model="gpt-3.5-turbo",
+                            messages=[{'role': 'user', 'content': reaction}],
+                            functions=molecule_custom_functions_reaction,
+                            function_call='auto'
+                        )
+                        data = json.loads(response_functions.choices[0].message.function_call.arguments)
+                        reactant_1 = data.get('reactant_1', '')
+                        reactant_2 = data.get('reactant_2', '')
+                        reagent_3 = data.get('reagent_3', '')
+                        product_4 = data.get('product_4', '')
+                        product_5 = data.get('product_5', '')
+                        
+                        reactant_1_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_1}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_1}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+                        reactant_2_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_2}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_2}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+                        reagent_3_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reagent_3}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reagent_3}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+                        product_4_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_4}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_4}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+                        product_5_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_5}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_5}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+                    
+                        #st.write("Reactant 1: ", reactant_1_smiles)
+                        #st.write("Reactant 2: ", reactant_2_smiles)
+                        #st.write("Reagent 3: ", reagent_3_smiles)
+                        #st.write("Product 4: ", product_4_smiles)
+                        #st.write("Product 5: ", product_5_smiles)
+                        # Building the reaction SMILES string dynamically based on available components
+                        # Building the reaction SMILES string
+                        reaction_components = []
+
+                        # Adding reactants
+                        reactants = [reactant for reactant in [reactant_1_smiles, reactant_2_smiles] if reactant]
+                        if reactants:
+                            reaction_components.append('.'.join(reactants))
+                        else:
+                            reaction_components.append('')
+
+                        # Adding reagents
+                        reagents = [reagent for reagent in [reagent_3_smiles] if reagent]
+                        if reagents:
+                            reaction_components.append('.'.join(reagents))
+                        else:
+                            reaction_components.append('')
+
+                        # Adding products
+                        products = [product for product in [product_4_smiles, product_5_smiles] if product]
+                        if products:
+                            reaction_components.append('.'.join(products))
+                        else:
+                            reaction_components.append('')
+
+                        reaction_smiles = '>'.join(reaction_components)
+                        try:
+                            # Generate the reaction from SMILES
+                            rxn = AllChem.ReactionFromSmarts(reaction_smiles, useSmiles=True)
+                            
+                            # Draw the reaction
+                            d2d = Draw.MolDraw2DCairo(800, 300)  # Adjust size as needed
+                            d2d.DrawReaction(rxn)
+                            png = d2d.GetDrawingText()
+                            
+                            # Save the drawing to a file
+                            with open('reaction_image.png', 'wb+') as f:
+                                f.write(png)
+                            image_variable = png
+                                #st.image('reaction_image.png')                      
+                                
+                        except Exception as e:
+                            st.write(f"An error occurred: {e}")
+                    else:
+                        st.write("Sorry, the website is not available.")
+            
+
+
+    if reaction_query:
+        chat_completion = client_groq.chat.completions.create(
+                messages=[
+                    {
+                        "role": "user",
+                        "content": "please give complete step by step reaction along with the complete name of the molecules for the reaction, the requested reaction is : " + reaction_query,
+                    }
+                ],
+                model="mixtral-8x7b-32768",
+            )
+        reaction = chat_completion.choices[0].message.content
+        response_functions = client_openai.chat.completions.create(
+                    model="gpt-3.5-turbo",
+                    messages=[{'role': 'user', 'content': reaction}],
+                    functions=molecule_custom_functions_reaction,
+                    function_call='auto'
+                )
+        data = json.loads(response_functions.choices[0].message.function_call.arguments)
+        reactant_1 = data.get('reactant_1', '')
+        reactant_2 = data.get('reactant_2', '')
+        reagent_3 = data.get('reagent_3', '')
+        product_4 = data.get('product_4', '')
+        product_5 = data.get('product_5', '')
+        
+        reactant_1_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_1}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_1}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+        reactant_2_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_2}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reactant_2}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+        reagent_3_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reagent_3}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{reagent_3}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+        product_4_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_4}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_4}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+        product_5_smiles = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_5}/property/CanonicalSMILES/TXT").text if requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{product_5}/property/CanonicalSMILES/TXT").status_code == 200 else ''
+    
+        #st.write("Reactant 1: ", reactant_1_smiles)
+        #st.write("Reactant 2: ", reactant_2_smiles)
+        #st.write("Reagent 3: ", reagent_3_smiles)
+        #st.write("Product 4: ", product_4_smiles)
+        #st.write("Product 5: ", product_5_smiles)
+        # Building the reaction SMILES string dynamically based on available components
+        # Building the reaction SMILES string
+        reaction_components = []
+
+        # Adding reactants
+        reactants = [reactant for reactant in [reactant_1_smiles, reactant_2_smiles] if reactant]
+        if reactants:
+            reaction_components.append('.'.join(reactants))
+        else:
+            reaction_components.append('')
+
+        # Adding reagents
+        reagents = [reagent for reagent in [reagent_3_smiles] if reagent]
+        if reagents:
+            reaction_components.append('.'.join(reagents))
+        else:
+            reaction_components.append('')
+
+        # Adding products
+        products = [product for product in [product_4_smiles, product_5_smiles] if product]
+        if products:
+            reaction_components.append('.'.join(products))
+        else:
+            reaction_components.append('')
+
+        reaction_smiles = '>'.join(reaction_components)
+        try:
+            # Generate the reaction from SMILES
+            rxn = AllChem.ReactionFromSmarts(reaction_smiles, useSmiles=True)
+            
+            # Draw the reaction
+            d2d = Draw.MolDraw2DCairo(800, 300)  # Adjust size as needed
+            d2d.DrawReaction(rxn)
+            png = d2d.GetDrawingText()
+            
+            # Save the drawing to a file
+            with open('reaction_image.png', 'wb+') as f:
+                f.write(png)
+            image_variable = png
+                #st.image('reaction_image.png')
+                
+                
+        except Exception as e:
+            st.write(f"An error occurred: {e}")
+    if search_query:
+        video_search = client_groq.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": "please correct the spelling and write teh precise one search keyword for and only give teh keyword, only 1 and nothing else other that that :" + search_query,
+                }
+            ],
+            model="mixtral-8x7b-32768",
+        )
+        search_query = video_search.choices[0].message.content
+        response_functions = client_openai.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[{'role': 'user', 'content': search_query}],
+                functions=keyword_custom_functions,
+                function_call='auto'
+            )
+        data = json.loads(response_functions.choices[0].message.function_call.arguments)
+        keyword = data['keyword']
+        st.sidebar.write(keyword)
+        # Perform the search
+        videosSearch = VideosSearch(search_query, limit=3)
+        video_one = VideosSearch(search_query, limit=1)
+        for video in video_one.result()['result']:
+            video_one_id = video['id']
+        
+        for video in videosSearch.result()['result']:
+            video_id = video['id']  # Extract video ID
+            
+            # Display the video thumbnail
+            #st.image(video['thumbnails'][0]['url'])
+            
+            # Display the video title
+            #st.write(f"**{video['title']}**")
+            
+            try:
+                # Fetch the transcript for the video ID
+                transcript_list = YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
+                
+                # Concatenating all text from the transcript
+                transcript_text = "\n".join([t['text'] for t in transcript_list])
+                
+                # Concatenate the transcript to the all_video_transcripts variable
+                all_video_transcripts += f"\n---\nTranscript for Video ID {video_id}:\n{transcript_text}\n---\n"
+                
+            except Exception as e:
+                error_message = "Transcript not available or error in fetching transcript."
+                # Concatenate the error message to the all_video_transcripts variable
+                all_video_transcripts += f"\n---\nTranscript for Video ID {video_id}:\n{error_message}\n---\n"
+
+    # At this point, all_video_transcripts contains transcripts for all videos concatenated as a single string.
+    # You can display it or process it as needed.
+    # Here's an example of displaying the combined transcripts:
+    video_id = ""
+    if all_video_transcripts:
+        #st.text_area("All Video Transcripts", all_video_transcripts, height=300)
+        video_compression = client_groq_one.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": "write a one sentence summary for the the given videos and always preserve and give me the vido_id always " + all_video_transcripts,
+                }
+            ],
+            model="mixtral-8x7b-32768",
+        )
+        compressed_transcripts = video_compression.choices[0].message.content
+
+        chat_completion = client_groq.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": "give me the best video with maximum content and the best keywords from the transcript and always preserve and give me teh vido_id always " + compressed_transcripts,
+                }
+            ],
+            model="mixtral-8x7b-32768",
+        )
+        #st.write(chat_completion.choices[0].message.content)
+        video_id_fetch = chat_completion.choices[0].message.content
+        #st.write(video_id_fetch)
+        response_functions = client_openai.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[{'role': 'user', 'content': video_id_fetch}],
+                functions=video_custom_functions,
+                function_call='auto'
+            )
+        data = json.loads(response_functions.choices[0].message.function_call.arguments)
+        video_id = data['video_id']
+        st.video(f"https://www.youtube.com/watch?v={video_id}")
+
+    messages = st.container(height=630)
+    if image_variable:
+        messages.chat_message("assistant").write(f"When you react {reactant_1} with {reactant_2} using {reagent_3}, you get {product_4} and {product_5}" + " here is the reaction in 2D bond representation:")
+        messages.image(image_variable)
+    if check_box:
+        messages.chat_message("assistant").write("Here is the Chem Sketcher for you to draw the molecule:")
+        with messages.chat_message("assistant"):
+            components.iframe("https://marvinjs.chemicalize.com/v1/fcc0cc8570204c48a6447859c71cf611/editor.html?frameId=2cd5fd97-f496-4b6f-8cbc-417acc66684f&origin=https%3A%2F%2Fwww.rcsb.org", height=600)     
+    prompt_sidebar = st.chat_input("Say something")
+    if prompt_sidebar:
+        messages.chat_message("user").write(prompt_sidebar)
+        sidebar_chat = client_groq.chat.completions.create(
+            messages=[
+                {"role": "user", "content": prompt_sidebar},
+            ],
+            model="mixtral-8x7b-32768",
+        )
+        response_functions = client_openai.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[{'role': 'user', 'content': prompt_sidebar}],
+            functions=molecule_custom_functions,
+            function_call='auto'
+        )
+        data = json.loads(response_functions.choices[0].message.function_call.arguments)
+        molecule_name = data['molecule_name']
+        if molecule_name:
+            response = requests.get(f"https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{molecule_name}/cids/TXT")
+            cid = response.text
+            with messages.chat_message("assistant"):
+                st.write(f"Here is the molecule {molecule_name} in 3D you can interact with it too 😉:")
+                components.iframe(f"https://embed.molview.org/v1/?mode=balls&cid={cid}")
+                messages.chat_message("assistant").write(sidebar_chat.choices[0].message.content)
+
+if st.session_state.prompt:
+        prompt = st.session_state.prompt
+        selected_options = " ".join(st.session_state.selected_options)
+        messages = [
+            {"role": "user", "content": f"create a {selected_options} scenarios based task question for learning stereochemistry, create 4 scenarios each time and number them: {prompt}"},
+        ]
+        chat_completion = client_groq.chat.completions.create(
+            messages=messages,
+            model="mixtral-8x7b-32768",
+        )
+        response = chat_completion.choices[0].message.content
+
+        if response:
+            response_functions = client_openai.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[{'role': 'user', 'content': response}],
+                functions=scenario_custom_functions,
+                function_call='auto'
+            )
+            data = json.loads(response_functions.choices[0].message.function_call.arguments)
+
+            # Tabs for scenarios
+            scenario_tabs = ['Scenario 1', 'Scenario 2', 'Scenario 3', 'Scenario 4']
+            tabs = st.tabs(scenario_tabs)
+            for i, tab in enumerate(tabs):
+                with tab:
+                    st.header(scenario_tabs[i])
+                    scenario_text = data[f'scenario_{i+1}']
+                    st.write(scenario_text)
+                    chat_completion_subquestions = client_groq.chat.completions.create(
+                            messages=[
+                                {
+                                    "role": "user",
+                                    "content": "subdivide this scenario into three subquestions and only give the questions. The scenario is: " + scenario_text,
+                                }
+                            ],
+                            model="mixtral-8x7b-32768",
+                        )
+                    scenario_generated = chat_completion_subquestions.choices[0].message.content
+                    st.write(scenario_generated)
+                    chat_completion_hint = client_groq.chat.completions.create(
+                            messages=[
+                                {
+                                    "role": "user",
+                                    "content": "give a sample ideal step-by-step format to attempt to answer this scenario question as a hint. Scenario: " + scenario_text,
+                                }
+                            ],
+                            model="mixtral-8x7b-32768",
+                        )
+                    st.text_area("Enter your answer here", key=f'answer_{i}')
+                    
+                    with st.expander("See hint for answering the question" + str(i+1) + "😀"): 
+                        st.write(chat_completion_hint.choices[0].message.content)
+                    # Upload PDF button
+                    uploaded_file = st.file_uploader("Upload your answer (PDF)", type="pdf", key=f"pdf_uploader_{i}")
+                    if uploaded_file is not None:
+                        st.success("File uploaded successfully!")
+                        
+
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        with st.expander("See explanation 3D"):
+                            components.iframe("https://embed.molview.org/v1/?mode=balls&cid=124527813")
+                    with col2:
+                        with st.expander("See explanation 2D"):
+                            components.iframe("https://marvinjs.chemicalize.com/v1/fcc0cc8570204c48a6447859c71cf611/editor.html?frameId=2cd5fd97-f496-4b6f-8cbc-417acc66684f&origin=https%3A%2F%2Fwww.rcsb.org")