Initial Draft

app.py

@@ -0,0 +1,620 @@
+import os
+import json
+import requests
+import streamlit as st
+
+import phoenix as px
+from phoenix.trace.langchain import LangChainInstrumentor
+
+from google.oauth2 import service_account
+from json_repair import repair_json
+from youtube_transcript_api import YouTubeTranscriptApi
+
+import dto.user_story as us
+import dto.release_notes as rs
+import dto.requirement_gathering as rq
+import prompts as pt
+
+from langchain_community.llms import HuggingFaceEndpoint
+from langchain_groq import ChatGroq
+from langchain_cohere import ChatCohere
+from langchain_google_genai  import ChatGoogleGenerativeAI
+from langchain_google_vertexai import ChatVertexAI
+from langchain_openai import ChatOpenAI
+from langchain.prompts import PromptTemplate
+
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.document_loaders import WebBaseLoader
+from langchain_community.document_loaders import PyPDFLoader
+from langchain.output_parsers import PydanticOutputParser
+
+
+
+# Launch phoenix 
+lv_px_session = None
+if "lv_px_session" not in st.session_state:
+    try:
+        lv_px_session = px.launch_app()
+        st.session_state.lv_px_session = lv_px_session
+        LangChainInstrumentor().instrument()
+    except:
+        lv_px_session = st.session_state.lv_px_session
+else:
+    lv_px_session = st.session_state.lv_px_session
+
+# Caching LLM response
+if "lv_response" not in st.session_state: 
+    lv_response = None
+    st.session_state.lv_response = lv_response
+else:
+    lv_response = st.session_state.lv_response
+
+# Caching Extracted Text
+if "lv_extracted_text" not in st.session_state:
+    lv_extracted_text = ""
+    st.session_state.lv_extracted_text = lv_extracted_text
+else:
+    lv_extracted_text = st.session_state.lv_extracted_text
+
+# Caching LLM Model
+if "lv_model_session" not in st.session_state:
+    st.session_state.lv_model_session = None
+
+# Display user Error, Warning or Success Message
+def fn_display_user_messages(lv_extracted_text, lv_type, mv_processing_message):
+    """Display user Info, Error, Warning or Success Messages"""
+    
+    if lv_type == "Success":
+        with mv_processing_message.container(): 
+            st.success(lv_extracted_text)
+    elif lv_type == "Error":
+        with mv_processing_message.container(): 
+            st.error(lv_extracted_text)
+    elif lv_type == "Warning":
+        with mv_processing_message.container(): 
+            st.warning(lv_extracted_text)
+    else:
+        with mv_processing_message.container(): 
+            st.info(lv_extracted_text)
+
+# Function to set proxy
+def fn_set_proxy(ui_proxy_url, ui_no_proxy_url):
+    """Configure http and https proxy programmatically"""
+
+    os.environ['HTTP_PROXY'] = ui_proxy_url
+    os.environ['HTTPS_PROXY'] = ui_proxy_url
+    os.environ['NO_PROXY'] = ui_no_proxy_url
+
+    print("=== Proxy SET ===")
+    print("HTTP_PROXY:", os.environ.get('HTTP_PROXY'))
+    print("HTTPS_PROXY:", os.environ.get('HTTPS_PROXY'))
+    print("NO_PROXY:", os.environ.get('NO_PROXY'))
+    print("=================")
+
+# Function to convert Website URL content into text
+def fn_scrape_website(ui_grounding_url):
+    """Function to convert Website URL content into text"""
+
+    lv_html_loader = WebBaseLoader(ui_grounding_url)
+    lv_html = lv_html_loader.load()
+
+    return lv_html
+
+# Function to convert PDF content into Documents
+def fn_scraper_pdf(ui_grounding_pdf):
+    """Function to convert PDF content into text"""
+
+    # -- Saving file
+    lv_temp_file_path = os.path.join("pdf-data",ui_grounding_pdf.name)
+    if not os.path.exists(lv_temp_file_path):
+        with open(lv_temp_file_path,"wb") as lv_file:
+            lv_file.write(ui_grounding_pdf.getbuffer())
+
+    # -- Extracting Data
+    lv_pdf_loader = PyPDFLoader(lv_temp_file_path)
+    lv_pdf_content = lv_pdf_loader.load()
+
+    return lv_pdf_content
+
+# Function to search internet for information
+def fn_search_web(ui_search_web_input):
+    """Search internet for information"""
+
+    lv_search_run = DuckDuckGoSearchRun()
+    lv_result = lv_search_run.run(ui_search_web_input)
+
+    return lv_result
+
+# Function to extract YouTube Video Transcript
+def fn_you_tube_video_transcript(ui_youtube_url,ui_processing_message):
+    """Extract YouTube Video Transcript"""
+
+    fn_display_user_messages("Generating Youtube Transcript","Info", ui_processing_message)
+
+    try:
+        lv_youtube_transcript = YouTubeTranscriptApi.get_transcript(ui_youtube_url)
+        lv_response = ' '.join([item['text'] for item in lv_youtube_transcript])
+
+        fn_display_user_messages("Successfully generated Youtube transcript","Success", ui_processing_message)
+
+        return lv_response
+    except Exception as error:
+        print('Error Generating Youtube Transcript', error)
+        fn_display_user_messages("Error Generating Youtube Transcript","Error", ui_processing_message)
+        raise error
+
+# Function to unset proxy
+def fn_unset_proxy():
+    """Unset http and https proxy"""
+
+    os.environ.pop('HTTP_PROXY', None)
+    os.environ.pop('HTTPS_PROXY', None)
+    os.environ.pop('NO_PROXY', None)
+
+    print("=== Proxy UNSET ===")
+    print("HTTP_PROXY:", os.environ.get('HTTP_PROXY')) 
+    print("HTTPS_PROXY:", os.environ.get('HTTPS_PROXY'))
+    print("NO_PROXY:", os.environ.get('NO_PROXY'))
+    print("===================")
+
+# Create Chat LLM Instance
+@st.cache_resource
+def fn_create_chatllm(ui_llm_provider, ui_api_key, ui_model_details):
+    """Create Chat LLM Instance"""
+
+    lv_model = None
+
+    try:
+        if(ui_llm_provider == 'Huggingface'):
+            lv_model = HuggingFaceEndpoint(
+                                            repo_id=ui_model_details, 
+                                            temperature=1.0, 
+                                            huggingfacehub_api_token=ui_api_key
+                                          )
+        elif(ui_llm_provider == 'Groq'):
+            lv_model = ChatGroq(
+                                    temperature=1.0, 
+                                    model_name=ui_model_details
+                                )
+            
+        elif(ui_llm_provider == 'Cohere'):
+            lv_model = ChatCohere(
+                                    temperature=1.0, 
+                                    model=ui_model_details
+                                    
+                                )
+        elif(ui_llm_provider == 'Google'):
+            lv_model = ChatGoogleGenerativeAI(
+                                                temperature=1.0, 
+                                                model=ui_model_details,
+                                                max_output_tokens=1000000
+                                            )
+        elif(ui_llm_provider == 'OpenAI'):
+            lv_model = ChatOpenAI(
+                                    temperature=1.0, 
+                                    model=ui_model_details
+                                )
+        elif(ui_llm_provider == 'Google VertexAI'):
+            lv_api_key = json.loads(ui_api_key)
+            g_creds = service_account.Credentials.from_service_account_info(lv_api_key)
+            lv_model = ChatVertexAI(
+                                        project=lv_api_key.get("project_id"),
+                                        temperature=1.0, 
+                                        model=ui_model_details,
+                                        credentials=g_creds
+                                    )
+        
+        print("Returning new model")
+    
+    except Exception as e:
+        print("Error Configuring Model"+str(e))
+
+    return lv_model
+
+# Generate Speech to Text
+@st.cache_resource
+def fn_generate_speech_to_text(ui_audio_bytes,ui_api_key):
+    """Generate Speech to Text"""
+    lv_extracted_text = None
+
+    try:
+        lv_url = "https://api-inference.huggingface.co/models/openai/whisper-large-v3"
+        lv_headers = {
+                        'Authorization': "Bearer "+ui_api_key,
+                        'Content-Type': "audio/wav"
+                     }
+        response = requests.request("POST", lv_url, data=ui_audio_bytes, headers=lv_headers)
+        lv_extracted_text = response.json().get('text')
+        
+        print(lv_extracted_text)
+
+        return lv_extracted_text
+    except Exception as error:
+        print('Error Generating Speech to Text', error)
+        raise error
+
+# Generate LLM response
+def fn_chatllm_response(ui_llm_provider, lv_summarize_prompt_formatted, lv_model, ui_processing_message):
+    """Generate LLM response"""
+
+    fn_display_user_messages("Generating LLM Response","Info", ui_processing_message)
+    lv_response = None
+
+    try:
+        
+        if(ui_llm_provider == 'Google VertexAI' or ui_llm_provider=='Google' or ui_llm_provider=='OpenAI' or ui_llm_provider=='Groq' or ui_llm_provider=='Cohere'):
+            lv_response = lv_model.invoke(lv_summarize_prompt_formatted).content
+        else:
+            lv_response = lv_model.invoke(lv_summarize_prompt_formatted)
+        
+        lv_response = str(lv_response).replace("```json","")
+        lv_response = lv_response.replace("```","")
+
+        fn_display_user_messages("Generated LLM Response","Success", ui_processing_message)
+        return lv_response
+    except Exception as error:
+        print('Error Generating LLM Response', error)
+        fn_display_user_messages("Error Generating LLM Response","Error", ui_processing_message)
+
+        raise error
+
+# Function to convert user story JSON to Markdown
+def fn_convert_user_story_json_to_markdown(lv_json):
+    """Convert User Story JSON to Markdown"""
+
+    lv_markdown = ""
+    try:
+        # Convert the dictionary to Markdown format
+        lv_markdown = f"# {lv_json['title']}\n\n"
+        lv_markdown += f"**Role:** {lv_json['role']}\n\n"
+        lv_markdown += f"**Feature:** {lv_json['feature']}\n\n"
+        lv_markdown += f"**Benefit:** {lv_json['benefit']}\n\n"
+        lv_markdown += "## User Story Scenarios\n"
+
+        for lv_scenario in lv_json['user_story_scenarios']:
+            lv_markdown += f"### {lv_scenario['scenario_title']}\n\n"
+            lv_markdown += f"**Pre-conditions:** {lv_scenario['pre_conditions']}\n\n"
+            lv_markdown += f"**Action Details:** {lv_scenario['action_details']}\n\n"
+            lv_markdown += f"**Expected Outcome:** {lv_scenario['expected_outcome']}\n\n"
+    except Exception as e:
+        print("UserStory - Error converting JSON to Markdown",str(e))
+
+    return lv_markdown
+
+# Function to convert release notes JSON to Markdown
+def fn_convert_release_notes_json_to_markdown(lv_json):
+    """Convert Release Notes JSON to Markdown"""
+
+    lv_markdown = ""
+    try:
+        # Convert the dictionary to Markdown format
+        lv_markdown = f"# Release Notes\n\n"
+        lv_markdown += f"**Release Date:** {lv_json['release_date']}\n\n"
+        lv_markdown += f"**Product Name:** {lv_json['product_name']}\n\n"
+        lv_markdown += f"**Summary:** {lv_json['summary']}\n\n"
+        lv_markdown += "## Enhancements\n"
+
+        for lv_enhancement in lv_json['enhancements']:
+            lv_markdown += f"### {lv_enhancement['title']}\n\n"
+            lv_markdown += f"**Description:** {lv_enhancement['description']}\n\n"
+            lv_markdown += f"**Benefits:** {lv_enhancement['benefits']}\n\n"
+            lv_markdown += f"**Reason:** {lv_enhancement['reason']}\n\n"
+    except Exception as e:
+        print("ReleaseNotes - Error converting JSON to Markdown",str(e))
+    
+    return lv_markdown
+
+# Function to convert requirement generation JSON to Markdown
+def fn_convert_requirement_generation_json_to_markdown(lv_json):
+    """Convert Requirement Generation JSON to Markdown"""
+
+    lv_markdown = ""
+    try:
+        # Convert the dictionary to Markdown format
+        lv_markdown = f"# {lv_json['header']}\n\n"
+        lv_markdown += "## Requirements\n"
+
+        for requirement in lv_json['requirements']:
+            lv_markdown += f"### {requirement['overview']}\n\n"
+            lv_markdown += f"**Description:** {requirement['description']}\n\n"
+            lv_markdown += f"**Benefits:** {requirement['benefits']}\n\n"
+            lv_markdown += f"**Reason:** {requirement['reason']}\n\n"
+            lv_markdown += f"**Priority:** {requirement['priority']}\n\n"
+            if requirement['tags']:
+                tags = ', '.join(requirement['tags'])
+                lv_markdown += f"**Tags:** {tags}\n\n"
+    except Exception as e:
+        print("Requirement Gathering - Error converting JSON to Markdown",str(e))
+    
+    return lv_markdown
+
+# Main Program
+def main():
+    
+    # -- Streamlit Settings
+    st.set_page_config(
+                        page_title="OBMA AI Assist",
+                        page_icon="🧊",
+                        layout="wide",
+                        initial_sidebar_state="expanded"
+                      )
+    
+    # -- Display Processing Details
+    col1, col2, col3 = st.columns(3)
+    ui_processing_message = col2.empty()
+    ui_search_web_input =st.empty()
+    if "lv_model_session" in st.session_state:
+        lv_model = st.session_state.lv_model_session
+    else:
+        lv_model= None
+    
+    global lv_response
+    global lv_extracted_text
+    
+    col2.text("")
+
+    col2.header("OBMA - AI Assist")
+    col2.text("")
+    col2.text("")
+    col2.text("")
+
+    # -- Variables
+    cn_llm_providers_lov_values = ['Huggingface','Groq','Cohere','Google','Google VertexAI','OpenAI']
+    cn_huggingface_models_lov_values = ['meta-llama/Meta-Llama-3-70B-Instruct','CohereForAI/c4ai-command-r-plus','mistralai/Mistral-7B-Instruct-v0.2','microsoft/Phi-3-mini-128k-instruct','google/gemma-7b']
+    lv_user_actions = ["User Story","Release Notes","Requirement Generation","Summarization"]
+
+    # -- Configuration
+    with st.sidebar:
+        st.header("Configurations")
+        st.text("")
+
+        # -- Recording User Output
+        st.subheader("Output")
+        ui_user_actions = st.multiselect(
+                                            label='User Actions',
+                                            options=lv_user_actions,
+                                            default="User Story"
+                                        )
+        ui_show_json = st.toggle("Show JSON", value=False)
+        st.text("")
+
+        # -- Recording Proxy Details
+        try:
+            st.subheader("HTTP Proxy")
+            ui_proxy_url = st.text_input("URL")
+            ui_no_proxy_url = st.text_input("No Proxy URL",value="localhost,127.0.0.1")
+            col1, col2, col3 = st.columns([0.60,0.85,1.40])
+            with col1:
+                if st.button("Set"):
+                    fn_set_proxy(ui_proxy_url,ui_no_proxy_url)
+            with col2:
+                if st.button("Unset"):
+                    fn_unset_proxy()
+        except Exception as e:
+            st.error('Error Configuring LLM Details',str(e))
+            fn_display_user_messages("Error updating proxy details","Error", ui_processing_message)    
+
+        # -- Read LLM Configuration
+        st.text("")
+        try:
+            st.subheader("LLM")
+            ui_llm_provider = st.selectbox(label='LLM Provider',options=cn_llm_providers_lov_values)
+            ui_api_key = st.empty()
+            ui_model_details = st.empty()
+
+            if ui_llm_provider:
+                # -- Prepopulated Configuration Details, Comment in production
+                if ui_llm_provider == 'Huggingface':
+                    ui_api_key = st.text_input("HUGGINGFACEHUB_API_TOKEN",type="password")
+                    ui_model_details = st.selectbox("Model Details",options=cn_huggingface_models_lov_values)
+                    os.environ["HUGGINGFACEHUB_API_TOKEN"] = ui_api_key
+                elif(ui_llm_provider == 'Groq'):
+                    ui_api_key = st.text_input("GROQ_API_KEY",type="password")
+                    ui_model_details = st.text_input("Model Details","mixtral-8x7b-32768")
+                    os.environ["GROQ_API_KEY"] = ui_api_key
+                elif(ui_llm_provider == 'Cohere'):
+                    ui_api_key = st.text_input("COHERE_API_KEY", type="password")
+                    ui_model_details = st.text_input("Model Details","command-r-plus")
+                    os.environ["COHERE_API_KEY"] = ui_api_key
+                elif(ui_llm_provider == 'Google'):
+                    ui_api_key = st.text_input("GOOGLE_API_KEY","AIzaSyAsksUKYnB4SuDNT6rB3d2Qd2hVk_TA5AA",type="password")
+                    ui_model_details = st.text_input("Model Details","gemini-1.5-pro-latest")
+                    os.environ["GOOGLE_API_KEY"] = ui_api_key
+                elif(ui_llm_provider == 'Google VertexAI'):
+                    ui_api_key = st.text_area("GOOGLE_APPLICATION_CREDENTIALS")
+                    ui_model_details = st.text_input("Model Details","gemini-1.5-pro-preview-0409")
+                elif(ui_llm_provider == 'OpenAI'):
+                    ui_api_key = st.text_input("OPENAI_API_KEY", type="password")
+                    ui_model_details = st.text_input("Model Details","gpt-4o")
+                    os.environ["OPENAI_API_KEY"] = ui_api_key
+            else:
+                st.error('Please configure LLM Details')
+                fn_display_user_messages("Please configure LLM Details","Error", ui_processing_message)
+
+            if st.button("Configure LLM"):
+                # -- Create LLM Instance
+                if ui_llm_provider and ui_api_key and ui_model_details:
+                    print("Configuring LLM")
+                    lv_model = fn_create_chatllm(ui_llm_provider, ui_api_key, ui_model_details)
+                    st.session_state.lv_model_session = lv_model
+                else:
+                    st.error('Please configure LLM Details')
+                    fn_display_user_messages("Please configure LLM Details","Error", ui_processing_message)
+        except Exception as e:
+            st.error('Error Configuring LLM Details'+str(e))
+            fn_display_user_messages("Error Configuring LLM Details","Error", ui_processing_message)
+
+        # -- Recording Knowledge Base Details
+        st.text("")
+        try:
+            st.subheader("Knowledge Base")
+            ui_grounding_url = st.text_input("Grounding URL")
+            ui_youtube_url = st.text_input("Youtube Video ID")
+            ui_grounding_pdf = st.file_uploader("Grounding PDF",type="pdf",accept_multiple_files=False)
+            ui_grounding_wav = st.file_uploader("Grounding WAV",type="wav",accept_multiple_files=False)
+            ui_search_web = st.checkbox("Search Web")
+            if ui_search_web:
+                ui_search_web_input = st.text_input("Search Details")
+
+            col1, col2, col3 = st.columns([0.85,0.80,1.40])
+
+            if col1.button("Extract"):
+                
+                if ui_youtube_url:
+                    lv_extracted_text +=fn_you_tube_video_transcript(ui_youtube_url,ui_processing_message)
+                
+                if ui_grounding_url:
+                    lv_extracted_text += ' '.join(doc.page_content for doc in fn_scrape_website(ui_grounding_url))
+                
+                if ui_grounding_pdf:
+                    lv_extracted_text += ' '.join(doc.page_content for doc in fn_scraper_pdf(ui_grounding_pdf))
+
+                if ui_search_web:
+                    if ui_search_web_input:
+                        lv_extracted_text += fn_search_web(ui_search_web_input)
+                
+                if ui_grounding_wav:
+                    lv_extracted_text += fn_generate_speech_to_text(ui_grounding_wav.getvalue(),ui_api_key)
+
+                st.session_state.lv_extracted_text = lv_extracted_text
+
+            if col2.button("Clear"):
+                lv_extracted_text = ""
+                st.session_state.lv_extracted_text = lv_extracted_text
+                lv_response = ""
+                st.session_state.lv_response = lv_response
+        except Exception as e:
+            st.error('Error extracting data - '+str(e))
+            fn_display_user_messages("Error extracting data","Error", ui_processing_message)    
+
+    # -- User Actions
+    user_story, release_notes, requirement_generation, summarization = st.tabs(lv_user_actions)
+
+    with user_story:
+        # -- Generate User Story LLM Response
+        if ui_llm_provider and lv_extracted_text and not(lv_response) and "User Story" in ui_user_actions:
+            # -- Pydantice Schema
+            lv_parser = PydanticOutputParser(pydantic_object=us.UserStory)
+
+            # -- Creating Prompt
+            lv_template = pt.CN_USER_STORY
+            lv_summarize_prompt = PromptTemplate(
+                                                    template=lv_template,
+                                                    input_variables=["context"],
+                                                    partial_variables={"format_instructions": lv_parser.get_format_instructions()},
+                                                )
+            lv_summarize_prompt_formatted = lv_summarize_prompt.format(  
+                                                                        context=lv_extracted_text
+                                                                    )
+
+            # -- LLM Response
+            if lv_model:
+                lv_response = fn_chatllm_response(ui_llm_provider, lv_summarize_prompt_formatted, lv_model, ui_processing_message)
+                st.session_state.lv_response = lv_response
+        
+        # -- Display LLM response
+        if lv_response and "User Story" in ui_user_actions:
+            lv_repaired = repair_json(lv_response, skip_json_loads=True)
+            
+            if ui_show_json:
+                st.header("User Story")
+                st.json(lv_repaired)
+            else:
+                lv_markdown = fn_convert_user_story_json_to_markdown(json.loads(lv_repaired))
+                st.markdown(lv_markdown)
+                # st.json(lv_response)
+    
+    with release_notes:
+        if ui_llm_provider and lv_extracted_text and not(lv_response) and "Release Notes" in ui_user_actions:
+            # -- Pydantice Schema
+            lv_parser = PydanticOutputParser(pydantic_object=rs.ReleaseNotes)
+
+            # -- Creating Prompt
+            lv_template = pt.CN_RELEASE_NOTES
+            lv_summarize_prompt = PromptTemplate(
+                                                    template=lv_template,
+                                                    input_variables=["context"],
+                                                    partial_variables={"format_instructions": lv_parser.get_format_instructions()},
+                                                )
+            lv_summarize_prompt_formatted = lv_summarize_prompt.format(  
+                                                                        context=lv_extracted_text
+                                                                    )
+
+            # -- LLM Response
+            if lv_model:
+                lv_response = fn_chatllm_response(ui_llm_provider, lv_summarize_prompt_formatted, lv_model, ui_processing_message)
+                st.session_state.lv_response = lv_response
+                
+        # -- Display LLM response
+        if lv_response  and "Release Notes" in ui_user_actions:
+            lv_repaired = repair_json(lv_response, skip_json_loads=True)
+            if ui_show_json:
+                st.header("Release Notes")
+                st.json(lv_repaired)
+            else:
+                lv_markdown = fn_convert_release_notes_json_to_markdown(json.loads(lv_repaired))
+                st.markdown(lv_markdown)
+
+    with requirement_generation:
+        if ui_llm_provider and lv_extracted_text and not(lv_response) and "Requirement Generation" in ui_user_actions:
+            # -- Pydantice Schema
+            lv_parser = PydanticOutputParser(pydantic_object=rq.RequirementGatheringDetails)
+
+            # -- Creating Prompt
+            lv_template = pt.CN_REQUIREMENT_GATHERING
+            lv_summarize_prompt = PromptTemplate(
+                                                    template=lv_template,
+                                                    input_variables=["context"],
+                                                    partial_variables={"format_instructions": lv_parser.get_format_instructions()},
+                                                )
+            lv_summarize_prompt_formatted = lv_summarize_prompt.format(  
+                                                                        context=lv_extracted_text
+                                                                      )
+
+            # -- LLM Response
+            if lv_model:
+                lv_response = fn_chatllm_response(ui_llm_provider, lv_summarize_prompt_formatted, lv_model, ui_processing_message)
+                st.session_state.lv_response = lv_response
+        
+        # -- Display LLM response
+        if lv_response and "Requirement Generation" in ui_user_actions:        
+            lv_repaired = repair_json(lv_response, skip_json_loads=True)
+
+            if ui_show_json:
+                st.header("Requirement Generation")
+                st.json(lv_repaired)
+            else:
+                lv_markdown = fn_convert_requirement_generation_json_to_markdown(json.loads(lv_repaired))
+                st.markdown(lv_markdown)
+            
+    with summarization:
+        if ui_llm_provider and "Summarization" in ui_user_actions:
+            st.header("Summarization") 
+            st.text("")
+            st.text("")
+                    
+            ui_summary_input = st.text_area("Input Text", value=lv_extracted_text)
+            if st.button("Summarize",key="summary"):
+                # -- Creating Prompt
+                lv_template = pt.CN_SUMMARY
+                lv_summarize_prompt = PromptTemplate(
+                                                        template=lv_template,
+                                                        input_variables=["context"]
+                                                    )
+                lv_summarize_prompt_formatted = lv_summarize_prompt.format(  
+                                                                            context=ui_summary_input
+                                                                          )
+
+                # -- LLM Response
+                if lv_model:
+                    lv_response = fn_chatllm_response(ui_llm_provider, lv_summarize_prompt_formatted, lv_model, ui_processing_message)
+                    st.session_state.lv_response = lv_response
+
+            # -- Display LLM response
+            if lv_response:
+                st.subheader("Summary")
+                st.markdown(lv_response)
+
+# Loading Main
+if __name__ == "__main__":
+    main()

prompts.py

@@ -0,0 +1,78 @@
+CN_USER_STORY="""
+Instruction:
+- You are an AI assistant product manager that generates a detailed user story based on the provided context.
+- Stories are tailored to create a Lending System for banking institutions.
+- Generate Response in JSON Format only.
+- Don't try to make up an answer.
+- Only extract relevant information from the context.
+- Remove any notes and suggestions in the response.
+- Dont add any comments like ```json
+- Avoid statement like This JSON object confirms to the following schema.
+=======
+{format_instructions}
+=======
+{context}
+=======
+Output:\n"""
+
+CN_RELEASE_NOTES="""
+Instruction:
+- You are an AI assistant product technical document writer that generates a detailed release notes based on the provided context.
+- This document is customer facing for the product Oracle Banking Retail Lending.
+- Ensure the tone is professional, informative, and user-friendly, suitable for a diverse audience of Oracle Banking Retail Lending customers.
+- Generate elaborate release notes details all the feature and do not missing details from the context provided.
+- Generate Response in JSON Format only.
+- Don't try to make up an answer.
+- Only extract relevant information from the context.
+- Remove any notes and suggestions in the response.
+- Dont add any comments like ```json
+- Avoid statement like This JSON object confirms to the following schema.
+=======
+{format_instructions}
+=======
+{context}
+=======
+Output:\n"""
+
+CN_REQUIREMENT_GATHERING="""
+Instruction:
+- You are an AI assistant product manager designed to extract and organize requirements from legal documents into a detailed scope document.
+- Your objective is to identify and group key requirements, while also highlighting areas of potential ambiguity that might need clarification.
+- Generate Response in JSON Format only.
+- Don't try to make up an answer.
+- Only extract relevant information from the context.
+- Remove any notes and suggestions in the response.
+- Dont add any comments like ```json
+- Avoid statement like This JSON object confirms to the following schema.
+=======
+{format_instructions}
+=======
+{context}
+=======
+Output:\n"""
+
+CN_SUMMARY="""
+IDENTITY and PURPOSE:
+- You are an expert content summarizer.
+- Don't try to make up an answer.
+- Only extract relevant information from the context.
+- You take content in and output a Markdown formatted summary using the format below.
+- Take a deep breath and think step by step about how to best accomplish this goal using the following steps.
+OUTPUT SECTIONS:
+- Combine all of your understanding of the content into a single, 20-word sentence in a section called ONE SENTENCE SUMMARY:.
+- Output the 10 most important points of the content as a list with no more than 15 words per point into a section called MAIN POINTS:.
+- Output a list of the 5 best takeaways from the content in a section called TAKEAWAYS:.
+- Output a list Text Classification identified in a section called CLASSIFICATION:.
+- Output a list Entity Recognition identified in a section called ENTITY RECOGNITION:.
+- Output a list Sentiment Analysis identified in a section called SENTIMENT:.
+OUTPUT INSTRUCTIONS:
+- Create the output using the formatting above.
+- You only output human readable Markdown.
+- Output numbered lists, not bullets.
+- Do not output warnings or notes—just the requested sections.
+- Do not repeat items in the output sections.
+- Do not start items with the same opening words.
+=======
+{context}
+=======
+Output:\n"""