- fixed prompt editing (added save_btn)

app.py

@@ -12,9 +12,8 @@ import pandas as pd
 from io import StringIO
 import importlib
 import prompt_configs
-import json
+importlib.reload(prompt_configs) 
 
-SYSTEM_PROMPTS = load_prompts()
 
 def create_ui_component(config: UIConfig, prompt: str = None) -> Any:
     if config.component_type == UIComponentType.TEXTBOX:
@@ -25,6 +24,20 @@ def create_ui_component(config: UIConfig, prompt: str = None) -> Any:
             visible=config.visible,
             value=prompt
         )
+    elif config.component_type == UIComponentType.MARKDOWN:
+        return gr.Markdown(
+            label=config.label,
+            visible=config.visible,
+            show_copy_button=config.show_copy_button,
+            value=prompt,
+            elem_classes=["scrollable-markdown"]
+        )
+    elif config.component_type == UIComponentType.DATAFRAME:
+        return gr.Dataframe(
+            label=config.label,
+            interactive=config.interactive,
+            visible=config.visible
+        )
     return None
 
 def create_prompt_editor_components(prompt_config: PromptConfig) -> Dict[str, Any]:
@@ -34,9 +47,6 @@ def create_prompt_editor_components(prompt_config: PromptConfig) -> Dict[str, An
         with gr.Column(scale=1):
             editor_key = next((k for k in prompt_config.ui.keys() if k.endswith('_prompt_editor')), None)
             if editor_key:
-                # Set the prompt_key based on the current prompt being edited
-                prompt_key = editor_key.replace('_prompt_editor', '')
-
                 lines = prompt_config.prompt.split('\n')
                 if lines:
                     min_indent = min((len(line) - len(line.lstrip()) 
@@ -55,47 +65,100 @@ def create_prompt_editor_components(prompt_config: PromptConfig) -> Dict[str, An
                     prompt_config.ui[editor_key],
                     formatted_prompt
                 )
+                
+                save_button = gr.Button("Save Changes")
+                
                 # Add save status display
                 save_status = gr.Markdown("Ready to save changes...", visible=True)
                 
                 def save_prompt_changes(new_prompt: str, prompt_key: str) -> str:
+                    global PROMPTS
                     try:
+                        # Find the correct prompt key
+                        prompt_key = None
+                        for key, config in PROMPTS.items():
+                            if editor_key in config.ui:
+                                prompt_key = key
+                                break
                         
+                        if not prompt_key:
+                            return "❌ Error: Could not find matching prompt key"
+                        
+                        # Update in-memory config
+                        PROMPTS[prompt_key].prompt = new_prompt.strip()
                         
-                        # Debug: Print the prompt_key to ensure it's correct
-                        print(f"Attempting to update prompt for key: {prompt_key}")
-
                         # Read current file content
-                        with open("prompt_configs.json", "r", encoding='utf-8') as f:
-                            prompts = json.load(f)
+                        with open("prompt_configs.py", "r", encoding='utf-8') as f:
+                            content = f.read()
                         
-                        # Ensure the correct prompt_key is used
-                        if prompt_key in prompts:
-                            prompts[prompt_key]['prompt'] = new_prompt.strip()
-                        else:
-                            return f"❌ Error: Prompt key '{prompt_key}' not found"
+                        # Find the start of the prompt section
+                        section_start = f'    "{prompt_key}": PromptConfig('
+                        start_idx = content.find(section_start)
+                        
+                        if start_idx == -1:
+                            return "❌ Error: Could not locate prompt section in config file"
+                        
+                        # Find the prompt= part
+                        prompt_start = content.find('prompt=', start_idx)
+                        if prompt_start == -1:
+                            return "❌ Error: Could not locate prompt parameter"
+                        
+                        # Find the triple quote after prompt=
+                        first_quote = content.find('"""', prompt_start)
+                        if first_quote == -1:
+                            return "❌ Error: Could not locate start of prompt content"
+                            
+                        # Find the closing triple quote
+                        end_quote = content.find('"""', first_quote + 3)
+                        if end_quote == -1:
+                            return "❌ Error: Could not locate end of prompt content"
+                        
+                        # Format the new prompt with proper indentation
+                        indented_lines = []
+                        for line in new_prompt.strip().split('\n'):
+                            if line.strip():
+                                indented_lines.append(f'        {line.strip()}')
+                            else:
+                                indented_lines.append('        ')
+                        
+                        # Create the new section with proper formatting
+                        new_section = (
+                            'prompt=\n'
+                            '        """\n' + 
+                            '\n'.join(indented_lines) + 
+                            '\n        """'
+                        )
+                        
+                        # Replace just the prompt content
+                        new_content = (
+                            content[:prompt_start] +
+                            new_section +
+                            content[end_quote + 3:]
+                        )
                         
                         # Write back to file
-                        with open("prompt_configs.json", "w", encoding='utf-8') as f:
-                            json.dump(prompts, f, indent=4)
+                        with open("prompt_configs.py", "w", encoding='utf-8') as f:
+                            f.write(new_content)
                         
-                        # Reload the in-memory PROMPTS
-                        global SYSTEM_PROMPTS
-                        SYSTEM_PROMPTS = load_prompts()
+                        # Reload the PROMPTS module to update in-memory state
+                        PROMPTS = prompt_configs.PROMPTS
                         
                         return "✅ Prompt updated successfully"
                         
                     except Exception as e:
                         return f"❌ Error updating prompt: {str(e)}"
                 
-                # Add change handler
-                editor.change(
-                    fn=lambda new_prompt: save_prompt_changes(new_prompt, prompt_key),
-                    inputs=[editor],
+                # Define prompt_key before using it in the lambda function
+                prompt_key = next((key for key, config in PROMPTS.items() if editor_key in config.ui), None)
+                
+                save_button.click(
+                    fn=lambda: save_prompt_changes(editor.value, prompt_key),
+                    inputs=[],
                     outputs=[save_status]
                 )
                 
                 components[editor_key] = editor
+                components[f"{editor_key}_save_button"] = save_button
                 components[f"{editor_key}_save_status"] = save_status
 
     return components

event_handler.py

@@ -146,6 +146,8 @@ def setup_all_handlers(step_buttons, all_components, progress_update, quotation_
             outputs=[progress_update]
         )
         
+        
+        
     except Exception as e:
         print(f"Error setting up handlers: {str(e)}")
         return None

prompt_configs.json

@@ -48,13 +48,13 @@
         "prompt": "You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list.\n\nObjective:\nGenerate a structured CSV output with manday estimates for each planning and testing component.\n\nInstructions:\n1. Use the planning and testing component list to identify all components\n2. For each component:\n- Estimate mandays between 0.2 and 5 days based on real-world complexity\n- Provide a clear description of deliverables and outcomes\n- Ensure estimates account for potential delays or complications\n\nOutput Format Requirements:\n- Generate a CSV with EXACTLY these column headers: \"component,mandays,description\"\n- Each row must have all three columns filled\n- Numeric values should not be quoted\n- Text values must be enclosed in double quotes\n- No empty rows or missing values\n\nExample Output:\ncomponent,mandays,description\n\"Project Planning\",2.5,\"Detailed project planning including timeline and resource allocation\"\n\"Requirements Analysis\",1.5,\"Analysis and documentation of system requirements\"\n\nReturn only the CSV content, no code blocks or additional text."
     },
     "generate_engage_plan_test_mandays": {
-        "prompt": "You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list and the development component list.\n\nObjective:\nGenerate a structured output organized by component. Provide a table with the following columns:\n- Component: The name of component, as defined in the component list.\n- Manday: The estimated effort required for a one-person team to complete the task, based on real-world complexity and scope.\n- Description: A detailed explanation of the task, including deliverables or outcomes, as defined in the component list.\n\nInstruction:\n1. Input:\n- Use the planning and testing component list identify all components and subcomponents. The hierarchy of the document is Phase -> Component -> Subcomponent -> Task\n\n2. Manday Estimation:\nAssign a manday estimate for each component based on the complexity and effort required, ensuring it falls between 0.2 and 5 days.\nEnsure estimates are based on real-world complexity and scope while accounting for potential delays or complications.\n\n**Output Format**:\nCreate a CSV file with the following columns:\n\"component\",\"subcomponent\",\"mandays\",\"description\"\nJust return the csv text and NOTHING else, omit the ``` code guards."
+        "prompt": "You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list and the development component list.\n\nObjective:\nGenerate a structured output organized by component. Provide a table with the following columns:\n- Component: The name of component, as defined in the component list.\n- Manday: The estimated effort required for a one-person team to complete the task, based on real-world complexity and scope.\n- Description: A detailed explanation of the task, including deliverables or outcomes, as defined in the component list.\n\nInstruction:\n1. Input:\n- Use the planning and testing component list identify all components and subcomponents. The hierarchy of the document is Phase -> Component -> Subcomponent -> Task\n\n2. Manday Estimation:\nAssign a manday estimate for each component based on the complexity and effort required, ensuring it falls between 0.2 and 5 days.\nEnsure estimates are based on real-world complexity and scope while accounting for potential delays or complications.\n\n**Output Format**:\n- Create a CSV file with the following columns:\n  \"component\",\"subcomponent\",\"mandays\",\"description\"\n- Just return the csv text and NOTHING else, omit the ``` code guards.\n- Numeric values should not be quoted.\n- Text values must be enclosed in double quotes.\n- No empty rows or missing values."
     },
     "generate_hybrid_plan_test_mandays": {
         "prompt": "You are an experienced project manager tasked to create a detailed task breakdown for a Hybrid project involving both Document Extraction and Chatbot functionalities. The project involves planning and testing components related to document processing, extraction, user interactions, and conversational workflows.\n\nObjective:\nGenerate structured CSV outputs with manday estimates for each planning and testing component, separated into Document Extraction and Chatbot sections.\n\nInstructions:\n1. Input:\n- Use the planning and testing component list to identify all components and subcomponents.\n- The hierarchy of the document is: Phase -> Component -> Subcomponent -> Task.\n\n2. Manday Estimation:\n- Assign manday estimates for each component or subcomponent based on complexity and effort required, ranging from 0.2 to 5 days.\n- Ensure estimates account for real-world complexity, potential delays, and complications.\n\n3. Output Format Requirements:\n- Generate TWO separate CSV files:\n- First, for the Document Extraction section:\n- Columns: \"component, mandays, description\".\n- Description must include deliverables and outcomes.\n- Second, for the Chatbot section:\n- Columns: \"component, subcomponent, mandays, description\".\n- Subcomponents must be clearly listed under each component.\n- Description must include deliverables and outcomes.\n- Clearly indicate Section Breaks between the two files by including:\n----SECTION BREAK----\n\n4. Output:\n- Return **ONLY** the CSV content, no code blocks or additional text.\n- Ensure all rows have all columns filled.\n- Numeric values should not be quoted.\n- Text values must be enclosed in double quotes.\n- No empty rows or missing values.\n- Omit the ``` code guards."
     },
     "generate_dev_mandays": {
-        "prompt": "You are an experienced project manager tasked to create a detailed task breakdown for a project based on the development component list. \n\nObjective:\nGenerate a structured output organized by component. Provide a table with the following columns:\n- Component: The name of component, as defined in the component list.\n- Manday: The estimated effort required for a one-person team to complete the task, based on real-world complexity and scope.\n- Description: A detailed explanation of the task, including deliverables or outcomes, as defined in the component list.\n\nInstruction:\n1. Input:\n- Use the planning and testing component list and the development component list to identify all components, subcomponents, tasks and subtasks.\n\n2. Manday Estimation:\nFor each subcomponent, estimate the manday based on the effort required for a single person to complete it,, ensuring it falls between 0.5 and 7 days.\nEnsure estimates are based on real-world complexity and scope while accounting for potential delays or complications.\n\n**Output Format**:\nCreate a CSV file with the following columns:\n\"component\",\"subcomponent\",\"mandays\",\"description\"\nJust return the csv text and NOTHING else, omit the ``` code guards."
+        "prompt": "You are an experienced project manager tasked to create a detailed task breakdown for a project based on the development component list. \n\nObjective:\nGenerate a structured output organized by component. Provide a table with the following columns:\n- Component: The name of component, as defined in the component list.\n- Manday: The estimated effort required for a one-person team to complete the task, based on real-world complexity and scope.\n- Description: A detailed explanation of the task, including deliverables or outcomes, as defined in the component list.\n\nInstruction:\n1. Input:\n- Use the planning and testing component list and the development component list to identify all components, subcomponents, tasks and subtasks.\n\n2. Manday Estimation:\nFor each subcomponent, estimate the manday based on the effort required for a single person to complete it,, ensuring it falls between 0.5 and 7 days.\nEnsure estimates are based on real-world complexity and scope while accounting for potential delays or complications.\n\n**Output Format**:\n- Create a CSV file with the following columns:\n\"component\",\"subcomponent\",\"mandays\",\"description\"\n- Just return the csv text and NOTHING else, omit the ``` code guards.\n- Enclose all text values, including the column headers, in double quotes (\"\").\n- Retain numeric values as-is, without any quotes."
     },
     "analyze_planning_testing_mandays": {
         "prompt": "You are an experienced project manager tasked with analyzing the provided planning and testing mandays estimates. Your goal is to identify the highest priority components that must be completed to build the MVP. Focus on components that deliver **immediate value to users** and are **critical for the core functionality** of the product. \n\nObjective:\nIdentify the highest priority planning and testing components that are critical for the MVP's core functionality and deliver immediate value to the business. Exclude all non-critical components that do not directly contribute to the MVP's primary functionality. \n\nKey Guidelines:\n- Focus on Core Functionality: Only include components that are essential for the MVP to function and deliver immediate value to users. \n- Exclude Non-Critical Components: Do not include components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is not absolutely necessary for the MVP. \n- Prioritize Business Value: Ensure the selected components align with the business's core objectives and deliver measurable value. \n- Minimalistic Approach: Focus on the least effort required to deliver the most value. \n\nOutput Format Requirements:\n- Generate a CSV with EXACTLY these column headers: \"component,mandays,description\" \n- Each row must have all three columns filled \n- Numeric values should not be quoted \n- Text values must be enclosed in double quotes \n- No empty rows or missing values \n\nReturn only the CSV content, no code blocks or additional text."

prompt_configs.py

@@ -2,14 +2,6 @@ from dataclasses import dataclass
 from dataclasses import dataclass
 from enum import Enum
 from typing import List, Dict, Any, Optional
-import json
-from typing import Dict, Any
-
-def load_prompts() -> Dict[str, Any]:
-    with open("prompt_configs.json", "r", encoding="utf-8") as f:
-        return json.load(f)
-
-SYSTEM_PROMPTS = load_prompts()
 
 class ModelType(Enum):
     O1_MINI = "o1-mini"
@@ -45,9 +37,102 @@ class PromptConfig:
     ui: Dict[str, UIConfig] = None
 
 PROMPTS = {
-    
     "component_agent": PromptConfig(
-        prompt=SYSTEM_PROMPTS['component_agent']['prompt'],
+        prompt=
+        """
+        You are an AI that analyzes a software project’s requirements and determines all possible valid and unique configurations based on the provided constraints.
+        
+        Input Data:
+        
+        - Project Requirement Document (PRD) – Describes the project’s goals and scope.
+        - List of Functions – A predefined set of function names and descriptions. STRICTLY use these ONLY (do not create new functions).
+        
+        Objective:
+        Identify and classify valid project configurations into one of the following categories:
+        
+        - Hybrid Configurations – If the project requires both chatbot and document extraction functionalities.
+        - Chatbot-Only Configurations – If the project is focused solely on chatbot functionality.
+        - Document Extraction-Only Configurations – If the project involves document extraction but does not require chatbot features.
+        
+        Rules for Ensuring Uniqueness:
+        
+        - Each configuration must belong to only one category (Chatbot, Document Extraction, or Hybrid) and be sorted by best match to the project requirements.
+        - Avoid redundant permutations – Ensure no duplicate function combinations under different names.
+        - Do NOT create new functions – Use only those from the provided function list.
+        
+        Expected Output Format:
+        - For Hybrid Configurations , the configuration_type should be "Basic Chatbot and Document Extraction".
+        - A structured JSON object with no duplicate function combinations.
+        - DO NOT include any code guards or placeholders.
+        
+        Example 1:
+        Project Requirement:
+        "The system must provide a chatbot to handle customer queries. It should support intent recognition and predefined workflows. The chatbot must work across web, mobile, and messaging platforms and escalate complex queries to human agents when needed."
+        
+        OUTPUT:
+        [
+        {
+        "configuration_type": "Basic Chatbot",
+        "selected_functions": [
+        "generate_plan_test_components",
+        "generate_intent_list",
+        "generate_engage_dev_components"
+        ]
+        }
+        ]
+        
+        Example 2:
+        Project Requirement:
+        "The system must extract structured data from PDFs. It should identify key fields, validate extracted data, support batch processing, and integrate with our existing software."
+        
+        OUTPUT:
+        [
+        {
+        "configuration_type": "Basic Document Extraction",
+        "selected_functions": [
+        "generate_plan_test_components",
+        "generate_page_dev_components",
+        "reformat_page_dev_components"
+        ]
+        }
+        ]
+        
+        Example 3:
+        Project Requirement:
+        "The system must integrate a chatbot with document extraction. The chatbot should accept user-uploaded documents, extract relevant data, and respond based on extracted content."
+        
+        OUTPUT:
+        [
+        {
+        "configuration_type": "Basic Chatbot and Document Extraction",
+        "selected_functions": [
+        "generate_plan_test_components",
+        "generate_intent_list",
+        "generate_page_dev_components",
+        "generate_engage_dev_components",
+        "reformat_hybrid_dev_components"
+        ]
+        }
+        ]
+        
+        <List of Functions: ONLY use these>
+        generate_plan_test_components: For ALL projects, generates a granular component list for the Planning and Testing phases,while explicitly excluding development-related tasks.
+        
+        generate_page_dev_components: For document extraction projects, produces a structured development component breakdown, categorizing frontend, backend, and integration tasks, while addressing edge cases and special considerations.
+        
+        generate_intent_list: For chatbot projects, analyzes a project’s requirements to define all possible chatbot intents and workflows, categorizing them by complexity (simple, multi-step, fallback, etc.) while also identifying overlooked but industry-relevant intents based on competitor comparisons.
+        
+        generate_engage_dev_components: For chatbot projects, extracts comprehensive development components from the Project Requirement Document (PRD) and Chatbot Intent List (CIL), translating intents, workflows, and fallback scenarios into specific technical deliverables for structured implementation.
+        
+        reformat_page_dev_components: Reformat the generated development components for document extraction projects to ensure consistent naming conventions, clarity, and logical grouping (e.g., Frontend, Backend, Integration).
+        
+        reformat_engage_dev_components: Standardize and harmonize naming conventions for chatbot development components by cross-checking against a reference list, retaining all unique elements, and ensuring proper categorization of subcomponents.
+        
+        reformat_hybrid_dev_components:Merge the chatbot and document extraction component lists into a unified, optimized list by consolidating overlapping elements, eliminating redundancies, and structuring the final output into clearly defined component categories.
+        
+        
+        <Requirements>
+        """,
         inputs=['generated_prd'],
         outputs=["configuration_type"],
         step="Step 1 : Scope & Components",
@@ -77,7 +162,31 @@ PROMPTS = {
     ),
     
     "client_initial_question": PromptConfig(
-        prompt=SYSTEM_PROMPTS['client_initial_question']['prompt'],
+        prompt=
+        """
+        # Client Information Gathering Questions
+        
+        ### Company Background and Industry
+        1. Can you provide some background about your company?
+        2. Which industry do you operate in, and what is your company's niche or specialization?
+        3. Who are your primary customers?
+        4. What are the main objectives you want to achieve?
+        5. What key features or functionalities do you need?
+        
+        ### Current Challenges
+        6. What are the biggest challenges your firm is currently facing?
+        7. Can you describe your current processes?
+        
+        ### Workflow and System Impact
+        8. How will this solution benefit your firm as a whole?
+        
+        ### Existing Workflow or System
+        9. Can you describe your current workflow or system?
+        
+        ### Pain Point Identification
+        10. Where is your current system falling short or causing delays?
+        11. Are there any parts of the process that are particularly time-consuming/ prone to error?
+        """,
         inputs=[],
         outputs=[],
         model=ModelType.O1_MINI,
@@ -94,7 +203,37 @@ PROMPTS = {
     ),
 
     "generate_client_follow_up": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_client_follow_up']['prompt'],
+        prompt=
+        """
+        Based on the initial list of questions and the client's provided answers, generate **insightful and targeted follow-up questions** that will help deepen my understanding of the following critical aspects:
+        
+        1. **Client Overview**
+        **Objective:** ask relevant questions that will directly contribute to better project requirements gathering. (ie: department team that the project is meant for ..etc)
+        
+        2. **Project Vision and Value**
+        **Objective:** Clarify the intended impact of the project on the client's business. Understand how it will improve their processes, solve key challenges, and deliver measurable benefits.
+        **Focus:** Investigate specific outcomes, immediate expected goals, and how success will be defined.
+        
+        3. **Existing System or Workflow Description**
+        **Objective:** Delve deeper into the client's current tools, workflows, and processes to uncover pain points, integration requirements, and opportunities for optimization.
+        **Focus:** Identify inefficiencies, technical limitations, or gaps that the project will address.
+        
+        4. **Budget and Resource Constraints**
+        **Objective:** Clearly define any limitations or constraints—financial, resource-based, or time-related—that could impact project success.
+        **Focus:** Understand the flexibility of the budget, timeline expectations, and resource availability.
+        
+        Instructions:
+        Each question should:
+        Build on provided client information
+        Non repetitive, and unique. Avoid asking similar questions.
+        Include realistic sample answers relevant to the client's context
+        Focus on gathering quantifiable or specific information
+        
+        
+        Output top 10 questions in the following format:
+        <question>(sample answers)
+        Just return the text and NOTHING else. Do not overexplain, omit code guards.
+        """,
         inputs=["project_detail"],
         outputs=["follow_up_questions"],
         model=ModelType.O1_MINI,
@@ -111,7 +250,57 @@ PROMPTS = {
     ),
     
     "generate_engage_follow_up_questions": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_engage_follow_up_questions']['prompt'],
+        prompt=
+        """
+        **You are a Software Development Expert specializing in scalable, secure, and robust chatbot systems.
+        You will be provided with client background information and a requirements rubric.
+        Your task is to create a dynamic, context-aware list of questions to collaboratively gather client requirements for a chatbot application.
+        Use the requirements rubric as a baseline. Generate additional, relevant questions on top of this baseline where appropriate.
+        Use the client's context to add clarity or relevance to the question.
+        Each question should provide actionable insights to uncover critical details about client needs and include sample answers as guidance to the client.
+        
+        Areas to Cover:
+        Business Requirements:
+        <client context>, What specific business outcomes should this chatbot achieve? (e.g., providing information, assisting users, facilitating specific tasks like event-related inquiries)
+        <client context>, Which current customer service challenges should the chatbot address? How are these challenges currently being addressed? Should this chatbot replace or complement existing customer service channels? Can you give more details? (e.g., long response times, lack of 24/7 support)
+        Conversational Design:
+        <client context>, Should the chatbot handle tasks that require only one piece of information, like retrieving an order ID? (e.g., yes, for order status checks)
+        <client context>, Can you provide 2 end-to-end expected conversation flows? (e.g., user asks for order status, chatbot obtains order ID, checks status, and notifies user)
+        <client context>, What are the most frequently asked questions by customers currently? Can you provide an expected number of questions in this FAQ or some sample questions? Where are the answers to these questions stored right now? (e.g., business hours, promotions)
+        <client context>, How should the chatbot handle multiple failed attempts? When should the chatbot escalate to a human agent after failed attempts? (e.g., after 3 failed attempts, escalate to a live agent)
+        <client context>, Will the chatbot handle complex tasks that involve multiple steps, such as booking appointments? If so, can you provide an expected range of questions that fall under this category and some sample scenarios? (e.g., booking a doctor’s appointment)
+        Technical Integration:
+        <client context>, Where would you prefer the chatbot to be hosted? On your own servers, in the cloud, or a mix of both? (e.g., cloud-based hosting for scalability)
+        <client context>, Do you need the chatbot to be deployed in a specific geographical region for data residency or compliance reasons? (e.g., EU region for GDPR compliance)
+        <client context>, Which platforms would you like the chatbot to be available on (e.g., website, mobile app, social media)? Which platform should it be prioritized? (e.g. website and mobile app as priority)
+        <client context>, Are there any existing tools or systems (e.g., CRM, ERP, customer service software) the chatbot should connect to? If so, what are the software names? (e.g., Salesforce, Zendesk)
+        <client context>, Do these systems provide APIs for integration? (e.g., yes, Salesforce and Zendesk provide APIs)
+        <client context>, How do you envision the chatbot interacting with these tools or systems? Will it need to fetch data, trigger actions, or both? (e.g., fetch customer data and create support tickets)
+        Data Requirements:
+        <client context>, What type of data formats will you expect the chatbot to process and handle? Will they be in text, files, images, audio, or perhaps video form? (e.g., text and images for product inquiries)
+        <client context>, Should the chatbot have the ability to update or modify data in these systems (e.g., creating tickets, updating customer information)? (e.g., yes, update customer profiles)
+        <client context>, How does your company store data? Is it in databases, spreadsheets, or cloud storage? If so, provide the name of the database. (e.g., MySQL database, Google Sheets)
+        <client context>, How often does the data in your system update? Is it updated in real-time, daily, or weekly? (e.g., real-time updates for inventory levels)
+        <client context>, Does the chatbot need to retrieve and provide real-time updates on things like prices, stock levels, or delivery status? How are these real-time data being stored or accessed? (e.g., yes, via API integration with inventory management system)
+        Performance and Scalability:
+        <client context>, What are the expected peak hours and maximum volume during these periods? Include timezone considerations and seasonal peaks. (e.g., 10 AM–2 PM, 500 concurrent users during holiday season)
+        <client context>, What is the expected number of simultaneous users accessing the chatbot? What is the required capacity for parallel conversations? (e.g., 200 concurrent users, 500 parallel conversations)
+        <client context>, What are the required response times and reliability expectations for the chatbot? How should we define server capacity and API limits to maintain optimal performance, even during peak traffic? (e.g., response time under 2 seconds, 99.9% uptime)
+        Security and Compliance:
+        <client context>, Will the chatbot handle any sensitive data? Are there industry-specific regulations to follow? (e.g., yes, GDPR compliance for customer data)
+        <client context>, What security measures are required to protect the data processed by the chatbot? (e.g., encryption for data in transit and at rest)
+        User Experience:
+        <client context>, Who are the key user personas for the chatbot? What are their primary needs (e.g., language differences)? (e.g., customers, support agents, multilingual support)
+        <client context>, What languages should the chatbot support? What tone should the chatbot use (e.g., friendly, formal)? (e.g., English and Spanish, friendly tone)
+        <client context>, What kind of metrics do you want to collect from the user, e.g., customer satisfaction for the chatbot? How do you envision these metrics being collected (every interaction/random)? Do you want a dashboard to monitor performance? (e.g., CSAT scores after every interaction, real-time dashboard)
+        System Reliability:
+        <client context>, What actions should be taken if the system fails or experiences downtime (e.g., notifying users, providing estimated response times)? How can we ensure minimal disruption to the user experience? (e.g., notify users of downtime and provide estimated resolution time)
+        <client context>, Would you like to set up automated monitoring and alerting for critical issues, such as system downtime or API failures? (e.g., yes, with email and SMS alerts)
+        
+        Instructions:
+        Replace <client context> with relevant information derived from the provided client background.
+        Only provide the list of formatted questions without any additional introduction or summary.
+        """,
         inputs=["project_detail"],
         outputs=["generated_engage_follow_up_questions"],
         model=ModelType.O1_MINI,
@@ -128,7 +317,53 @@ PROMPTS = {
     ),
     
     "generate_page_follow_up_questions": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_page_follow_up_questions']['prompt'],
+        prompt=
+        """
+        **You are a Software Development Expert specializing in scalable, secure, and robust document processing systems.
+        You will be provided with client background information.
+        Your task is to create a dynamic, context-aware list of questions to collaboratively gather client requirements for a document processing application.
+        Use the list below as a baseline. Generate additional, relevant questions on top of this baseline where appropriate.
+        Use the client's context to add clarity or relevance to the question.
+        Each question should provide actionable insights to uncover critical details about client needs and Sample Answers as guidance to the client to answer the questions.
+        ### Areas to Cover:
+        ---
+        Document Types:
+        <client context>, What specific types of documents will the application need to process (e.g., invoices, legal contracts, ID forms)?
+        <client context>, Are there specific complexities or variations in these documents that we should account for (e.g., multi-page documents, handwritten content)?
+        Inputs and Outputs:
+        <client context>, What are the expected input formats (e.g., PDFs, images, scanned documents)?
+        <client context>, What should the processed outputs look like (e.g., structured data, summaries, reports)?
+        <client context>, Are there any specific formatting requirements for outputs?
+        Document Quality:
+        <client context>, Are the documents typically clean and structured, or will the application need preprocessing capabilities (e.g., OCR, noise reduction)?
+        <client context>, Do you foresee any challenges with document quality, such as low resolution or inconsistent formatting?
+        Workflow Mapping:
+        <client context>, Can you describe your current document processing workflow?
+        <client context>, What are the major pain points or inefficiencies in the current process?
+        <client context>, Which parts of the workflow involve manual interventions, and how would you like to streamline them?
+        Integration Points:
+        <client context>, What existing systems or third-party tools does the application need to integrate with (e.g., CRMs, ERPs, cloud storage, OCR tools)?
+        <client context>, Are there specific APIs, databases, or platforms already in use that we need to consider?
+        Security and Compliance:
+        <client context>, What security measures are required to protect the data processed by the application?
+        <client context>, Are there any industry-specific compliance standards the application must adhere to (e.g., GDPR, HIPAA)?
+        Scalability and Performance:
+        <client context>, What is the expected volume of documents the application should handle on a daily/weekly/monthly basis?
+        <client context>, Are there performance benchmarks or response time requirements that the application must meet?
+        User Management and Access Control:
+        <client context>, What user roles and permissions will be needed within the application?
+        <client context>, How should user authentication and authorization be managed?
+        Reporting and Analytics:
+        <client context>, What types of analytics or reporting capabilities do you require within the application?
+        <client context>, Do you need real-time reporting, or are batch processes sufficient?
+        Deployment and Maintenance:
+        <client context>, Do you have any preferences for the deployment environment (e.g., cloud-based, on-premises)?
+        <client context>, What are your requirements for application maintenance and support post-deployment?
+        
+        Instructions:
+        Replace <client context> with relevant information derived from the provided client background.
+        Only provide the list of formatted questions without any additional introduction or summary.
+        """,
         inputs=['project_detail'],
         outputs=['generated_page_follow_up_questions'],
         model=ModelType.O1_MINI,
@@ -145,16 +380,39 @@ PROMPTS = {
     ),
     
     "generate_further_follow_up_questions": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_further_follow_up_questions']['prompt'],
+        prompt=
+        """
+        You are an AI Solution Expert with extensive experience in developing both intelligent chatbots and robust document extraction systems for startups. You will be provided with client background information pertaining to their project requirements, which may include a chatbot solution, a document extraction solution, or both.
+        
+        Your task is to:
+        1. Determine the Project Scope:
+        Identify whether the project involves only a chatbot solution, only a document extraction solution, or a hybrid of both.
+        2.Identify Gaps and Clarify Requirements:
+        - Generate highly specific and actionable follow-up questions to clarify underlying needs.
+        - Utilize frameworks such as the 5 Whys and root cause analysis for deeper exploration.
+        - Ensure questions are tailored to the identified project scope (Chatbot, Document Extraction, or both).
+        
+        Requirements:
+        You need to FULLY read the input which is given below client background information.
+        Generate follow-up questions to identify missing details or ambiguities.
+        Use specific references to prior responses for continuity. For example: "You mentioned [context]. Can you elaborate on [specific aspect]?"
+        Apply the 5 Whys to delve deeper where necessary. For example: "Why do call centers become overloaded during month-end? Are there specific processes causing bottlenecks?"
+        Highlight systemic issues where patterns emerge (e.g., manual processes across multiple challenges).
+        
+        # Output Format:
+        # <index><question>(sample answers)
+        
+        Just return the generated list of follow up questions as string and nothing else.
+        """,
         inputs=["project_detail"],
         outputs=["generated_engage_further_follow_up_questions"],
         model=ModelType.O1_MINI,
-        description="Generate Further Follow Up Questions",
+        description="Generate Engage Further Follow Up Questions",
         step="Chatbot Prompt Editors",
         ui={
             "generate_further_follow_up_questions_prompt_editor": UIConfig(
                 component_type=UIComponentType.TEXTBOX,
-                label="Further Follow Up Questions Prompt",
+                label="Engage Further Follow Up Questions Prompt",
                 lines=20,
                 interactive=True
             )
@@ -162,7 +420,15 @@ PROMPTS = {
     ),
     
     "generate_prd": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_prd']['prompt'],
+        prompt=
+        """
+        Rewrite this for clarity while keeping all specific details, metrics, and constraints.
+        Please take note of the time constraint to build the MVP.
+        Do not include context or assumptions beyond the input provided.
+        Do not also exclude any input provided.
+        Structure the document to ensure clarity and logical flow.
+        Make sure to make the title "Project Requirements".
+        """,
         inputs=["project_detail"],
         outputs=["generated_prd"],
         model=ModelType.O1_MINI,
@@ -191,7 +457,31 @@ PROMPTS = {
     ),
     
     "generate_intent_list": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_intent_list']['prompt'],
+        prompt=
+        """
+        You are an solution architect and project manager with 20+ years of experience in building chatbots and AI-powered systems.
+        Your task is to analyze the provided project requirement document and help me understand the complexity of the project by defining ALL possible intents and workflows for each requirement.
+        Additionally, anticipate and suggest realistic, real-life intents that might have been overlooked by the client but are critical for a robust and user-friendly chatbot. You can reference **how other chatbots in the same industry are functioning** and suggest intents that are commonly provided by competitors but may not have been explicitly mentioned by the client. List down these suggestion in one seperate table.
+        
+        Instruction:
+        1. **Break Down Requirements**: Identify all the client requirements from the document.
+        2. **Define ALL Possible Intents and Workflows**: For each requirement, list ALL possible intents and their corresponding workflows.  - Use "→" to represent the flow between steps.
+        - Provide your analysis in a clear, highly readable and structured table format. The intents to consider are:
+        - Simple
+        - Complex
+        - Multi-Step
+        - Single-Step
+        - Fallback.Focus on business-centric fallback (e.g., "Order Management Fallback" should address specific order-related issues like invalid SKU, payment failure, or inventory unavailability)
+        - Others (if applicable)
+        
+        Output Format:
+        Present the analysis in a tabular format with the following structure:
+        - Each requirement as the title of a separate table.
+        - **Columns**:
+        - Intent Type (e.g., Simple, Complex, Multi-Step, etc.)
+        - Intent (e.g., Order Status Inquiry, Track Order Progress, etc.)
+        - Workflow (describe the technical/logical steps using "→" and numbered steps, e.g., "1. Extract user input → 2. Query database → 3. Return result").
+        """,
         inputs=["generated_prd"],
         outputs=["generated_intent_list"],
         model=ModelType.O1_MINI,
@@ -220,11 +510,33 @@ PROMPTS = {
     ),
     
     "generate_plan_test_components": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_plan_test_components']['prompt'],
+        prompt=
+        """
+        Context:
+        You are an expert in software project planning and testing. Your task is to create a highly detailed, actionable, and project-specific Component List for a software project, focusing exclusively on the Planning and Testing phases. excluding Development phase. The response must align with the project's goals, technical stack, and compliance requirements, ensuring granularity, specificity, and adherence to the provided Project Requirement Document (PRD).
+        
+        Instructions:
+        Break the project into the following phases:
+        1. Planning Phase ( Potention Focus: Requirement gathering,Technical architecture design, Resource Allocation.. etc)
+        2. Testing Phase ( Potention Focus: Integration testing, System testing, User Acceptance Testing (UAT) )
+        
+        Components:
+        For each phase, include project-specific components that align with the goal of developing the software Project. Break down each phase into granular sub-components, ensuring specificity and alignment with the PRD.
+        Use the PRD to extract relevant, granular components that reflect deliverables unique to this project.
+        
+        Tech Stack:
+        Backend: FastAPI, Python
+        Chatbot: Chatbot Builder , COZE , Yellow.ai
+        Infrastructure: AWS, PostgreSQL, Redis, Docker, Alembic
+        
+        Output Format:
+        Use bullet points for clarity and ensure each component is concise yet descriptive.
+        Include sub-bullets for tasks or subcomponents where necessary to provide additional detail.
+        """,
         inputs=["generated_prd"],
         outputs=["generated_plan_test_components"],
         model=ModelType.O1_MINI,
-        description="Generate Page Planning and Testing Components",
+        description="Generate Planning and Testing Components",
         step="Step 1 : Scope & Components",
         ui={
             "generate_plan_test_components_prompt_editor": UIConfig(
@@ -249,7 +561,46 @@ PROMPTS = {
     ),
     
     "generate_page_dev_components": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_page_dev_components']['prompt'],
+        prompt=
+        """
+        As a Senior Software Architect with 20+ years of experience, you are tasked to generate a detailed, actionable, and project-specific component list exclusively for the development phase of the project. The list must align with the project's goals, technical stack, and compliance requirements as outlined in the provided Project Requirement Document (PRD), ensuring granularity and specificity.
+        
+        **Specific Requirements:**
+        1. Extract relevant **granular components** from the PRD that reflect the tasks and deliverables unique to this project.
+        2. Components should directly reference functionalities or deliverables related to the project.
+        3. Prioritize components that provide high business value, such as core functionality.
+        4. Organize components into logical categories such as Frontend, Backend, Integration Development, etc., with further subdivisions as needed. Avoid Testing, Support and Maintenance, Documentation, and Training components.
+        5. Ensure deliverables focus entirely on outcomes and deliverables, and consider edge cases, avoiding unnecessary instructions (i.e., avoid filler words).
+        6. Identify key business logic and special edge cases that need to be considered during development, which could impact the system's robustness or functionality.
+        7. **Include a separate section titled "Special Edge Cases Considerations"** to explicitly address unhappy paths. The deliverables in this section should focus solely on development outcomes to address these scenarios.
+        
+        **Output Format:**
+        - Title: Component Name as Table Title (e.g., "Frontend Components")
+        - Table Structure:
+        - **Subcomponent**: Subcomponent name (e.g., "User Authentication and Authorization").
+        - **Task**: Task name (e.g., "Login Interface").
+        - **Deliverables**: Lists of technical outcomes or deliverables (e.g., "1. Deliverable 1  2. Deliverable 2  3. Deliverable ..."), as much as possible.
+        - **Special Edge Cases Considerations**: A separate table to address unhappy paths, with the same structure as above.
+        
+        **Example:**
+        Frontend Component
+        | **Component**               | **Task**                     | **Deliverables**                                                                                         |
+        |--------------------------------|------------------------------|----------------------------------------------------------------------------------------------------------|
+        | Document Upload Interface      | Implement File Upload        | 1. React-based file upload component<br>2. Drag-and-drop functionality<br>3. Progress bar for uploads    |
+        
+        **Special Edge Cases Considerations**
+        | **Component**               | **Task**                     | **Deliverables**                                                                                         |
+        |--------------------------------|------------------------------|----------------------------------------------------------------------------------------------------------|
+        | Input Validation               | Handle Invalid Inputs        | 1. File format validation logic<br>2. File size validation logic<br>3. Error messaging UI for invalid inputs |
+        
+        **Tech Stack:**
+        - Backend: FastAPI, Python
+        - Frontend: React
+        - Infrastructure: AWS, PostgreSQL, Redis, Docker, Alembic
+        
+        **Objective:**
+        The final output should deliver a **clear, actionable, and project-specific list of components**, with a separate section for handling unhappy paths. The goal is to provide a foundation for developing granular subcomponents and tasks, ensuring alignment with the unique requirements of this project. A logical grouping and a clean structure that enhance the table's clarity and technical usability is expected.
+        """,
         inputs=["generated_prd"],
         outputs=["generated_page_dev_components"],
         model=ModelType.O1_MINI,
@@ -278,7 +629,70 @@ PROMPTS = {
     ),
     
     "generate_engage_dev_components": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_engage_dev_components']['prompt'],
+        prompt=
+        """
+        **Role**: 
+        You are a technical project manager and software architect specializing in chatbot development.
+        Your task is to create a granular "Development Component List" by extracting components from the **Project Requirement Document (PRD)** and the **Chatbot Intent List (CIL)**.
+        The output should align with the **project's specific goals** and focus on **technical implementation**. 
+    
+        ### **Objectives**: 
+        1. **Complements the CIL**: Ensure the components directly support the intents and workflows defined in the CIL.
+        2. **Aligns with the PRD**: Incorporate project-specific goals, business logic, and technical requirements from the PRD.
+        3. **Focus on Technical Implementation**: Provide actionable development tasks and deliverables.
+        4. **Project-Specific**: Avoid generic components; extract details directly from the PRD and CIL.
+        5. **Granular and Readable**: Maintain a balance between granularity and readability for actionable outputs.
+    
+        **Key Focus**: 
+        - Translate the **intents, workflows, fallbacks, and unhappy paths** from the CIL into **specific development deliverables** or tasks.
+        - Ensure that the deliverables are **actionable** and **context-aware**, aligning with the project's technical stack and business requirements.
+    
+        ### **Inputs**: 
+        1. **PRD**: Contains functional, non-functional, technical, and compliance requirements for the chatbot project. 
+        2. **CIL**: Lists intents the chatbot will handle, including **fallbacks** and **unhappy paths** with their corresponding workflows. 
+    
+        ---
+    
+        ### **Process**: 
+        1. **Read and Analyze the PRD and CIL**: 
+           - Carefully review the PRD to understand the **project's specific goals, business logic, and technical requirements**. 
+           - Review the CIL to identify the intents, workflows, fallbacks, and unhappy paths the chatbot will handle. 
+    
+        2. **Extract Granular Components**:  
+           - Identify *ALL components* in the PRD and the CIL.
+           - Components should directly reference functionalities or deliverables related to the project.
+           - Identify key business logic.
+           - Prioritize components that provide high business value, such as core functionality. 
+           - Organize components into logical categories. Avoid Testing, Support and Maintenance, Documentation and Training components.  
+    
+        3. **Identify Unhappy Paths and Fallbacks**:  
+           - For each intent including the suggested or additional intents, identify unhappy paths or fallbacks (e.g., errors, exceptions, or edge cases) provided in the CIL. Define **specific development deliverables** or tasks. Examples include:
+             - **Order Creation**: Implement SKU validation logic and inventory availability checks.
+             - **Payment Processing**: Integrate payment retry mechanisms and notify users of payment status.
+             - **Document Extraction**: Add field validation logic and manual upload options for failed extractions.
+             - **Input Validation**: Implement file size and type checks, and provide fallback instructions for unsupported inputs.
+           - Ensure that the deliverables are **actionable** and **context-aware**.
+           
+        ---
+    
+        ### **Tech Stack**: 
+        - **Backend**: FastAPI, Python 
+        - **Chatbot Tools**: Chatbot Builder , COZE , Yellow.ai
+        - **Infrastructure**: AWS, PostgreSQL, Redis, Docker, Alembic 
+    
+        ---
+    
+        ### **Output**: 
+        - Compile a list of components from the PRD and CIL. 
+        - Use a clear, tabular format with **project-specific context** for each component: 
+        - Avoid using "Handle" for the Subcomponent naming.
+    
+        | **Component**       | **Subcomponent**       | **Deliverables**               | 
+        |---------------------|------------------------|--------------------------------| 
+        | **<Component 1>**   | **<Subcomponent 1>**   | 1. <Deliverable 1> <br> 2. <Deliverable 2> <br> 3. <Deliverable 3> | 
+    
+        Return the final tables and nothing else. Do not provide a summary at the end.
+        """,
         inputs=["generated_prd" , "generated_intent_list"],
         outputs=["generated_engage_dev_components"],
         model=ModelType.O1_MINI,
@@ -307,7 +721,44 @@ PROMPTS = {
     ),
     
     "reformat_page_dev_components": PromptConfig(
-        prompt=SYSTEM_PROMPTS['reformat_page_dev_components']['prompt'],
+        prompt=
+        """
+        As a Senior Software Architect with 20+ years of experience, you are tasked to reformat the generated development components for a document extraction project to ensure consistent and standardized naming conventions. The reformatted components must align with the project's goals, technical stack, and compliance requirements as outlined in the provided Project Requirement Document (PRD).
+        
+        **Specific Requirements:**
+        1. **Standardize Naming Conventions**:
+        - Use **descriptive and intuitive names** for components, subcomponents, tasks, and deliverables.
+        - Ensure naming is **consistent across all tables** (Frontend, Backend, Integration, Infrastructure, Database, and Special Edge Cases).
+        - Avoid overly technical jargon unless necessary for clarity.
+        - Use **action-oriented language** for tasks and deliverables (e.g., "Implement file upload functionality" instead of "File upload functionality").
+        
+        2. **Common Web Development Document Extraction Components**:
+        - Include standard components such as:
+        - **Document Upload Interface**
+        - **Document Processing Engine**
+        - **Data Validation Module**
+        - **OCR Integration**
+        - **Data Reconciliation Module**
+        - **Report Generation Interface**
+        - **User Authentication and Authorization**
+        - **Notification and Alert System**
+        - **API Integrations**
+        - **Database Schema Design**
+        - **Error Handling and Logging**
+        - **Scalability and Load Balancing**
+        
+        3. **Reformat the Generated Components**:
+        - Ensure all components, subcomponents, tasks, and deliverables follow the standardized naming conventions.
+        - Group related tasks and deliverables under the appropriate subcomponents.
+        - Maintain a clean and logical structure for readability and technical usability.
+        
+        **Output Format:**
+        - Title: Component Name as Table Title (e.g., "Frontend Components")
+        - Table Structure:
+        - **Subcomponent**: Subcomponent name (e.g., "Document Upload Interface").
+        - **Task**: Task name (e.g., "Implement file upload functionality").
+        - **Deliverables**: Lists of technical outcomes or deliverables
+        """,
         inputs=["generated_page_dev_components"],
         outputs=["reformatted_dev_components"],
         model=ModelType.O1_MINI,
@@ -336,7 +787,58 @@ PROMPTS = {
     ),
     
     "reformat_engage_dev_components": PromptConfig(
-        prompt=SYSTEM_PROMPTS['reformat_engage_dev_components']['prompt'],
+        prompt=
+        """
+        **Role**:  
+        You are a technical project manager and software architect responsible for ensuring consistent naming conventions in chatbot development. Your task is to standardize the naming of common chatbot components and subcomponents while preserving all existing components and subcomponents, including unique, domain-specific components.
+
+        ### **Process**:  
+        1. **Analyze the Development Component List (DCL)**:  
+           - Identify components and subcomponents that are common across chatbot projects (e.g., "Chatbot Engine" vs. "Chatbot Interface").
+           - Identify domain-specific components that should remain unchanged.
+           - Ensure that technical terminology and categorization are consistent across component , particularly for components of similar concepts to maintain uniformity.
+
+        2. **Standardize Common Chatbot Components**:  
+           - Cross-check common components against a standardized reference list (see below).
+           - Rename only the common chatbot components to their standardized equivalent while keeping the intended meaning intact.
+           - Ensure all subcomponents are retained and placed under the correct standardized component.
+
+        3. **Preserve All Existing Components and Subcomponents**:  
+           - Ensure that no components or subcomponents are removed during standardization
+           - If a component is highly specific to a particular use case, do not modify it
+           - Retain any unique features that are tailored to the project
+           - Verify that each component has appropriate subcomponents and deliverables
+
+        ### **Standardized Naming Conventions (for Common Chatbot Components)**:
+        | **Standard Component**       | **Common Subcomponents**       |
+        |------------------------------|--------------------------------|
+        | Core Chatbot Engine          | Intent Recognition, NER, Context Management, Dialog Flow, Response Generation, Multi-turn Handling |
+        | LLM Processing Pipeline      | Text Preprocessing, Entity Extraction |
+        | Integration Layer            | API Gateway, CRM/ERP Integration, Knowledge Base Integration, Third-party Services |
+        | Data Management              | ETL Pipelines, Database Operations, Data Versioning, Cache Management |
+        | Security and Compliance      | Authentication, Authorization, Data Encryption, Audit Logging, GDPR/PDPA Compliance |
+        | Infrastructure               | AWS/Cloud Setup, Docker Containerization, CI/CD Pipeline, Environment Management |
+        | Error Handling               | Error Logging, Exception Management, Fallback Responses, Escalation Workflows |
+        | User Management              | User Authentication, Profile Management, Session Handling, Role-based Access |
+        | Monitoring & Analytics       | Performance Metrics, Usage Analytics, Error Tracking, Real-time Dashboards |
+        | Feedback & Learning          | User Feedback Collection, Model Performance Tracking, A/B Testing, Continuous Learning |
+        | Conversation Management      | Context Retention, Topic Switching, Language Support, Flow Control |
+        | Channel Management           | Web Integration, Mobile Support, Social Media Platforms |
+        | AI/ML Components             | LLM Integration, RAG Implementation, Fine-tuning Pipeline, Vector Store Management |
+        | Business Logic Layer         | Custom Rules Engine, Workflow Automation, Business Process Integration |
+        | Knowledge Management         | Content Management, FAQ Updates, Knowledge Graph, Document Processing |
+        | Human Handoff                | Agent Routing, Queue Management, Conversation History Transfer, Live Chat Support |
+        | Performance & Scaling        | Load Balancing, Auto-scaling, Performance Optimization, Resource Management |
+        | Development Tools            | Testing Framework, Debugging Tools, Development Environment, Documentation |
+
+        ### **Output**:  
+        - Return the Updated Component List in a clear, structured format.
+        - Maintain the tabular format while applying consistent naming conventions.
+        - Each component should be distinct and well-defined.
+        - No repeated components or overlapping functionality.
+        - Ensure that all components and subcomponents are included in the output.
+        - Provide only the corrected table and nothing else.
+        """,
         inputs=["generated_engage_dev_components"],
         outputs=["reformatted_dev_components"],
         model=ModelType.O1_MINI,
@@ -365,11 +867,29 @@ PROMPTS = {
     ),
     
     "reformat_hybrid_dev_components": PromptConfig(
-        prompt=SYSTEM_PROMPTS['reformat_hybrid_dev_components']['prompt'],
+        prompt=
+        """
+        You are an expert in software architecture and systems integration. Your task is to merge two component lists: (1) a chatbot development component list and (2) a general/document-related component list. The goal is to create a unified list that consolidates overlapping elements while eliminating redundancies.
+
+        Follow these steps:
+
+        Identify Similarities: Compare both lists and merge similar components without losing granularity. Retain specific steps and detailed tasks.
+        Remove Redundancies: Eliminate duplicate entries by consolidating their tasks and deliverables while preserving the essential details of each task. Ensure that no components are removed
+        Structure Logically: Organize the final list into major categories (e.g., Frontend, Backend, Document Handling.)
+
+        Output Format: Present the final list in a structured tabular format with the following columns:
+        Component: The high-level functionality grouping.
+        Subcomponent: A more granular breakdown of each function.
+        Deliverables: A list of specific tasks associated with the subcomponent. Avoid Filler words("Enable", "Support", "Implement") 
+
+        Output:
+        A refined, logically structured, and optimized merged component list in tabular format.
+
+        """,
         inputs=["generated_engage_dev_components","generated_page_dev_components"],
         outputs=["reformatted_dev_components"],
         model=ModelType.O1_MINI,
-        description="Reformat Hybird Development Components",
+        description="Reformat Hybrid Development Components",
         step="Step 1 : Scope & Components",
         ui={
             "reformat_hybrid_dev_components_prompt_editor": UIConfig(
@@ -394,7 +914,15 @@ PROMPTS = {
     ),
     
     "generate_intents_csv": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_intents_csv']['prompt'],
+        prompt=
+        """
+        You will be provided with an intent list. Your task is to convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "intent_type", "intent", and "workflow". Follow these rules:
+        
+        Enclose all text values, including the column headers, in double quotes ("").
+        Retain numeric values as-is, without any quotes.
+        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
+        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```
+        """,
         inputs=["generated_intent_list"],
         outputs=["generated_intents_csv"],
         model=ModelType.O1_MINI,
@@ -418,11 +946,38 @@ PROMPTS = {
     ),
     
     "generate_page_plan_test_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_page_plan_test_mandays']['prompt'],
+        prompt=
+        """
+        You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list.
+        
+        Objective:
+        Generate a structured CSV output with manday estimates for each planning and testing component.
+        
+        Instructions:
+        1. Use the planning and testing component list to identify all components
+        2. For each component:
+        - Estimate mandays between 0.2 and 5 days based on real-world complexity
+        - Provide a clear description of deliverables and outcomes
+        - Ensure estimates account for potential delays or complications
+        
+        Output Format Requirements:
+        - Generate a CSV with EXACTLY these column headers: "component,mandays,description"
+        - Each row must have all three columns filled
+        - Numeric values should not be quoted
+        - Text values must be enclosed in double quotes
+        - No empty rows or missing values
+        
+        Example Output:
+        component,mandays,description
+        "Project Planning",2.5,"Detailed project planning including timeline and resource allocation"
+        "Requirements Analysis",1.5,"Analysis and documentation of system requirements"
+        
+        Return only the CSV content, no code blocks or additional text.
+        """,
         inputs=["generated_plan_test_components"],
         outputs=["generated_plan_test_mandays"],
         model=ModelType.O1_MINI,
-        description="Generate page planning and testing mandays",
+        description="Generate Page planning and testing mandays",
         step="Step 2 : Mandays & Quotation",
         sub_step="Step 2.1 : Generate Mandays",
         ui={
@@ -441,11 +996,33 @@ PROMPTS = {
     ),
     
     "generate_engage_plan_test_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_engage_plan_test_mandays']['prompt'],
+        prompt=
+        """
+        You are an experienced project manager tasked to create a detailed task breakdown for a project based on the planning and testing component list and the development component list.
+        
+        Objective:
+        Generate a structured output organized by component. Provide a table with the following columns:
+        - Component: The name of component, as defined in the component list. ()
+        - Manday: The estimated effort required for a one-person team to complete the task, based on real-world complexity and scope.
+        - Description: A detailed explanation of the task, including deliverables or outcomes, as defined in the component list.
+        
+        Instruction:
+        1. Input:
+        - Use the planning and testing component list identify all components and subcomponents. The hierarchy of the document is Phase -> Component -> Subcomponent -> Task
+        
+        2. Manday Estimation:
+        Assign a manday estimate for each component based on the complexity and effort required, ensuring it falls between 0.2 and 5 days.
+        Ensure estimates are based on real-world complexity and scope while accounting for potential delays or complications.
+        
+        **Output Format**:
+        Create a CSV file with the following columns:
+        "component",,"subcomponent","mandays","description"
+        Just return the csv text and NOTHING else, omit the ``` code guards.
+        """,
         inputs=["generated_plan_test_components"],
         outputs=["generated_plan_test_mandays"],
         model=ModelType.O1_MINI,
-        description="Generate engage planning and testing mandays",
+        description="Generate Engage planning and testing mandays",
         step="Step 2 : Mandays & Quotation",
         sub_step="Step 2.1 : Generate Mandays",
         ui={
@@ -464,11 +1041,46 @@ PROMPTS = {
     ),
         
     "generate_hybrid_plan_test_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_hybrid_plan_test_mandays']['prompt'],
+        prompt=
+        """
+        You are an experienced project manager tasked to create a detailed task breakdown for a Hybrid project involving both Document Extraction and Chatbot functionalities. The project involves planning and testing components related to document processing, extraction, user interactions, and conversational workflows.
+        
+        Objective:
+        Generate structured CSV outputs with manday estimates for each planning and testing component, separated into Document Extraction and Chatbot sections.
+        
+        Instructions:
+        1. Input:
+           - Use the planning and testing component list to identify all components and subcomponents.
+           - The hierarchy of the document is: Phase -> Component -> Subcomponent -> Task.
+        
+        2. Manday Estimation:
+           - Assign manday estimates for each component or subcomponent based on complexity and effort required, ranging from 0.2 to 5 days.
+           - Ensure estimates account for real-world complexity, potential delays, and complications.
+        
+        3. Output Format Requirements:
+           - Generate TWO separate CSV files:
+             - First, for the Document Extraction section:
+               - Columns: "component, mandays, description".
+               - Description must include deliverables and outcomes.
+             - Second, for the Chatbot section:
+               - Columns: "component, subcomponent, mandays, description".
+               - Subcomponents must be clearly listed under each component.
+               - Description must include deliverables and outcomes.
+           - Clearly indicate Section Breaks between the two files by including:
+               ----SECTION BREAK----
+        
+        4. Output:
+           - Return **ONLY** the CSV content, no code blocks or additional text.
+           - Ensure all rows have all columns filled.
+           - Numeric values should not be quoted.
+           - Text values must be enclosed in double quotes.
+           - No empty rows or missing values.
+           - Omit the ``` code guards.
+        """,
         inputs=["generated_plan_test_components"],
         outputs=["generated_plan_test_mandays"],
         model=ModelType.O1_MINI,
-        description="Generate hybrid planning and testing mandays",
+        description="Generate Hybrid planning and testing mandays",
         step="Step 2 : Mandays & Quotation",
         sub_step="Step 2.1 : Generate Mandays",
         ui={
@@ -487,7 +1099,33 @@ PROMPTS = {
     ),
 
     "generate_dev_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_dev_mandays']['prompt'],
+        prompt=
+        """
+        You are an experienced project manager tasked to create a detailed task breakdown for a project based on the development component list.
+        
+        Objective:
+        Generate a structured output organized by component. Provide a table with the following columns:
+        - Component: The name of component, as defined in the component list.
+        - Subcomponent: The subcategory or module within the component, as defined in the component list.
+        - Manday: The estimated effort required for a one-person team to complete the task, based on real-world complexity and scope.
+        - Description: A detailed explanation of the task, including deliverables or outcomes, as defined in the component list.
+        
+        Instruction:
+        1. Input:
+        - Use the planning and testing component list and the development component list to identify all components, subcomponents, tasks and subtasks.
+        
+        2. Manday Estimation:
+        For each subcomponent, estimate the manday based on the effort required for a single person to complete it,, ensuring it falls between 0.5 and 7 days.
+        - Ensure estimates are based on real-world complexity and scope while accounting for potential delays or complications.
+        
+        **Output Format**:
+        Create a CSV file with the following columns:
+        "component","subcomponent","mandays","description"
+        Make sure you encapsulate all TEXT column in "", and keep numeric columns as is.
+        Just return the csv text and NOTHING else, omit the ``` code guards.
+        Numeric values should not be quoted
+        Text values must be enclosed in double quotes
+        """,
         inputs=["reformatted_dev_components"],
         outputs=["generated_dev_mandays"],
         model=ModelType.O1_MINI,
@@ -511,7 +1149,28 @@ PROMPTS = {
     ),
         
     "analyze_planning_testing_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['analyze_planning_testing_mandays']['prompt'],
+        prompt=
+        """
+        You are an experienced project manager tasked with analyzing the provided planning and testing mandays estimates. Your goal is to identify the highest priority components that must be completed to build the MVP. Focus on components that deliver **immediate value to users** and are **critical for the core functionality** of the product.
+        
+        Objective:
+        Identify the highest priority planning and testing components that are critical for the MVP's core functionality and deliver immediate value to the business. Exclude all non-critical components that do not directly contribute to the MVP's primary functionality.
+        
+        Key Guidelines:
+        - Focus on Core Functionality: Only include components that are essential for the MVP to function and deliver immediate value to users.
+        - Exclude Non-Critical Components: Do not include components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is not absolutely necessary for the MVP.
+        - Prioritize Business Value: Ensure the selected components align with the business's core objectives and deliver measurable value.
+        - Minimalistic Approach: Focus on the least effort required to deliver the most value.
+        
+        Output Format Requirements:
+        - Generate a CSV with EXACTLY these column headers: "component,mandays,description"
+        - Each row must have all three columns filled
+        - Numeric values should not be quoted
+        - Text values must be enclosed in double quotes
+        - No empty rows or missing values
+        
+        Return only the CSV content, no code blocks or additional text.
+        """,
         inputs=["generated_plan_test_mandays"],
         outputs=["identified_planning_testing_components"],
         model=ModelType.O1_MINI,
@@ -535,7 +1194,33 @@ PROMPTS = {
     ),
     
     "analyze_development_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['analyze_development_mandays']['prompt'],
+        prompt=
+        """
+        You are an experienced project manager tasked with analyzing the provided development mandays estimates. Your goal is to assign a priority level to each development component based on its importance to the MVP's core functionality and business value. Focus exclusively on components that deliver immediate value to users and are critical for the core functionality of the product.
+        
+        Key Guidelines:
+        - **Focus on Core Functionality:** Assign priority levels based on how essential each component is for the MVP to function and deliver immediate value to users.
+        - **Exclude Non-Critical Considerations:** Do not label components related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
+        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
+        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
+        - **Assign Priority Levels:** Label each development component as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
+        
+        Objective:
+        Assign a priority level ("high," "medium," or "low") to each development component, ensuring the output reflects the importance of each component to the MVP's core functionality and business value. Retain all original components in the list.
+        
+        Important Notes:
+        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
+        - Do not exclude any components from the list, even if they are low priority.
+        - Only assign "high" priority to components that are absolutely necessary for the MVP to function.
+
+        Output Format Requirements:
+        Convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "component","subcomponent","mandays","description". Follow these rules:
+        
+        Enclose all text values, including the column headers, in double quotes ("").
+        Retain numeric values as-is, without any quotes.
+        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
+        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
+        """,
         inputs=["generated_dev_mandays"],
         outputs=["identified_development_components"],
         model=ModelType.O1_MINI,
@@ -559,7 +1244,33 @@ PROMPTS = {
     ),
         
     "analyze_MVP_intents": PromptConfig(
-        prompt=SYSTEM_PROMPTS['analyze_MVP_intents']['prompt'],
+        prompt=
+        """
+        You are an experienced project manager tasked with analyzing the provided intents mandays estimates. Your goal is to assign a priority level to each intents based on its importance to the MVP's core functionality and business value. Focus exclusively on intents that deliver immediate value to users and are critical for the core functionality of the product.
+        
+        Key Guidelines:
+        - **Focus on Core Functionality:** Assign priority levels based on how essential each intents is for the MVP to function and deliver immediate value to users.
+        - **Exclude Non-Critical Considerations:** Do not label intents related to advanced security, compliance, scalability, authentication, fallback mechanisms, or any feature that is **NOT** absolutely necessary for the MVP as "high" priority.
+        - **Prioritize Business Value:** Ensure the priority levels align with the business's core objectives and deliver measurable value.
+        - **Minimalistic Approach:** Focus on the least effort required to deliver the most value when assigning priority levels.
+        - **Assign Priority Levels:** Label each development intents as "high," "medium," or "low" priority based on its importance to the MVP's core functionality and business value.
+        
+        Objective:
+        Assign a priority level ("high," "medium," or "low") to each development intents , ensuring the output reflects the importance to the MVP's core functionality and business value. Retain all original components in the list.
+        
+        Important Notes:
+        - If a component is not directly tied to the core functionality or can be deferred to a later phase, assign it a lower priority ("medium" or "low").
+        - Do not exclude any intents rom the list, even if they are low priority.
+        - Only assign "high" priority to intents that are absolutely necessary for the MVP to function.
+        
+        Output Format Requirements:
+        Convert the entire list into a CSV string, ensuring that all rows from the list are included without omission. The CSV should contain the following columns: "intent_type", "intent", and "workflow". Follow these rules:
+        
+        Enclose all text values, including the column headers, in double quotes ("").
+        Retain numeric values as-is, without any quotes.
+        Ensure the CSV string is formatted correctly, with commas separating the values and each row represented on a new line.
+        Your response must include every row and correctly reflect the structure and content of the intent list. Just return the CSV text and nothing else. Omit any code guards ```.
+        """,
         inputs=["generated_intent_list"],
         outputs=["identified_mvp_intents"],
         model=ModelType.O1_MINI,
@@ -583,7 +1294,45 @@ PROMPTS = {
     ),
     
     "recalculate_page_MVP_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['recalculate_page_MVP_mandays']['prompt'],
+        prompt=
+        """
+        Based on the identified priority components from the previous analysis, your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
+        
+        Objective:
+        Reread the entire PRD to identify the timelimit of the MVP, then recalculate the manday estimates for the identified priority development components to ensure they fit within the timeline specified in the Project Requirement Document (PRD) to build the MVP. Adjust development mandays while maintaining feasibility and ensuring core functionality delivery.
+        
+        Key Guidelines:
+        1. Convert Time Estimates: Convert all time estimates into raw mandays:
+           - 1 week = 7 mandays
+           - 1 month = 28-31 mandays
+           - If input is in days, use as is.
+           - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
+        2. **Preserve All Components:** Do not remove any components from the list, even if they are low priority.
+        3. **Adjust Mandays Based on Priority:**
+           - For **high priority components**, allocate the majority of mandays (e.g., 1-3) to ensure critical functionalities are minimally viable. However, components such as authentication, security, etc., can be set to 0.
+           - For **medium priority components**, allocate minimal mandays (e.g., 1-2) or set them to 0, as these can be deferred without impacting core functionalities.
+           - For **low priority components**, set mandays to 0, as these are not essential for the MVP.
+        4. **Retain Planning/Testing Components:** All identified planning and testing components must be retained in the list but have their mandays set to 0. Do not remove them.
+        5. **Iterative Adjustment:** If the total mandays for the development components still exceed the MVP timeline after the first adjustment, further reduce or set the mandays to 0 on high and medium priority components if necessary until the total fits within the timeline.
+           - **MVP Timeline Constraint:** Ensure the final total mandays do not exceed the MVP timeline.
+        6. **Justify Adjustments:** Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
+        
+        Output Format Requirements:
+        - **Separate Planning/Testing Components and Development Components:**
+          - Planning/Testing Components:
+            component,mandays,description,priority
+            "Requirements Analysis",0,"Critical user requirements and system specifications","High"
+          - Development Components:
+            component,subcomponent,mandays,description,priority
+            "Frontend","Document Upload Interface",3,"Essential for core functionality of automated document processing","High"
+        - Include the "Priority" column for all components.
+        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
+        - Ensure the output is concise and actionable.
+        
+        Important Notes:
+        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components while keeping high priority components as intact as possible.
+        - Do not remove any components from the list, even if their mandays are reduced to 0.
+        """,
         inputs=["identified_planning_testing_components", "identified_development_components" , "generated_prd"],
         outputs=["revised_mandays_estimates"],
         model=ModelType.O1_MINI,
@@ -613,7 +1362,65 @@ PROMPTS = {
     ),
     
     "recalculate_engage_MVP_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['recalculate_engage_MVP_mandays']['prompt'],
+        prompt=
+        """
+        Based on the identified priority components and the identified priority intent list from the previous analysis , your task is to recalculate the mandays estimates to ensure they fit within the time given (e.g., days or weeks) in building the MVP mentioned in the Project Requirement Document (PRD).
+        
+        Objective:
+        Read the entire PRD and identify the time constraint ; Recalculate the manday estimates for both development components and intents to ensure the total combined mandays fit within the MVP timeline specified in the Project Requirement Document (PRD). Adjust mandays while maintaining feasibility and ensuring core functionality delivery. Retain all components and intents in the list, even if their mandays are set to 0.
+        
+        Key Guidelines:
+        1. Total Combined Mandays Constraint:
+        The combined total mandays for development components and intents must not exceed MVP timeline.
+        Ensure the total is calculated as:
+        Total Combined Mandays = Development Components Mandays + Intents Mandays ≤ MVP timeline.
+        Convert Time Estimates:
+        Convert all time estimates into raw mandays:
+        - 1 week = 7 mandays
+        - 1 month = 28-31 mandays
+        - If input is in days, use as is.
+        - If input is a range (e.g., 1-2 weeks), use the average (1.5 weeks = 7.5 mandays).
+        
+        2. Preserve All Components and Intents:
+        
+        3. Do not remove any components or intents from the list, even if their mandays are set to 0.
+        
+        4. Retain all planning and testing components but set their mandays to 0.
+        
+        5. Adjust Mandays Based on Priority:
+        - For high priority, allocate the majority of mandays to ensure critical functionalities are minimally viable. Significant reductions may be necessary for non-core features (e.g., authentication, security).
+        - For medium priority, allocate minimal mandays or set them to 0, as these can be deferred without impacting core functionalities.
+        - For low priority, set mandays to 0, as these are not essential for the MVP.
+        
+        6. Iterative Adjustment:
+        - If the total combined mandays still exceed the MVP timeline after the first adjustment, further reduce mandays for both high and medium priority components and intents until the total fits within the timeline.
+        - Set mandays to 0 for non-essential components and intents if necessary, but do not remove them from the list.
+        
+        7. Strict Calculation for Intents:
+        Properly calculate the total mandays for development components and MVP intents. Ensure the total combined mandays for both development components and MVP intents DO NOT exceed the MVP timeline.
+        
+        8. Justify Adjustments:
+        - Provide a brief explanation for any adjustments made to the mandays, ensuring they align with the timeline and maintain the MVP's core functionality.
+        
+        Output Format Requirements:
+        - **Separate Planning/Testing Components , Development Components and MVP Intents:**
+        - Planning/Testing Components:
+          component,mandays,description,priority
+          "Requirements Analysis",0,"Critical user requirements and system specifications","High"
+        - Development Components:
+          component,subcomponent,mandays,description,priority
+          "Frontend","Document Upload Interface",3,"Essential for core functionality of automated document processing","High"
+        - MVP Intents:
+          intent_type,intent,workflow,mandays
+          "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details from user input → 3. Save order to database → 4. Confirm creation to user",0.3
+        - Include the "Priority" column for all components.
+        - Include the total mandays for the revised plan and confirm whether it fits within the MVP timeline.
+        - Ensure the output is concise and actionable.
+        
+        Important Notes:
+        - If the total mandays still exceed the timeline after adjustments, prioritize further reductions in medium priority components and intents while keeping high priority components as intact as possible.
+        - Do not remove any components or intents from the list, even if their mandays are reduced to 0.
+        """,
         inputs=["identified_planning_testing_components", "identified_development_components", "identified_mvp_intents", "generated_prd"],
         outputs=["revised_mandays_estimates"],
         model=ModelType.O1_MINI,
@@ -643,7 +1450,32 @@ PROMPTS = {
     ),
     
     "generate_page_MVP_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_page_MVP_mandays']['prompt'],
+        prompt=
+        """
+        Using the revised mandays estimates from the previous step, format the output into two clearly separated CSV sections: one for Planning/Testing Components and another for Development Components.
+        
+        Objective:
+        Structure the output to clearly delineate the two sections while maintaining the original column structure. Ensure that there are no duplicate components or subcomponents in the output.
+        
+        Output Format Requirements:
+        - First Section - Planning & Testing Components:
+        component,mandays,description
+        "Requirements Analysis",0,"Critical user requirements and system specifications"
+        
+        - Second Section - Development Components:
+        component,subcomponent,mandays,description
+        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
+        
+        Important:
+        - Each section must maintain its original column structure.
+        - Sections MUST be separated by the marker: "----SECTION BREAK----".
+        - Include ALL components but ensure there are no duplicates. If a component or subcomponent appears in both sections, include it only in the most relevant section.
+        - No empty rows or missing values.
+        - Text values must be in double quotes.
+        - Numbers must not be in quotes.
+        
+        Return only the CSV content with the section break, no additional text or explanations.
+        """,
         inputs=["revised_mandays_estimates"],
         outputs=["generated_MVP_mandays"],
         model=ModelType.O1_MINI,
@@ -673,7 +1505,36 @@ PROMPTS = {
     ),
 
     "generate_engage_MVP_mandays": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_engage_MVP_mandays']['prompt'],
+        prompt=
+        """
+        Using the revised mandays estimates from the previous step, format the output into three clearly separated CSV sections: one for Planning/Testing Components, one for Development Components, and another for MVP Intents.
+        
+        Objective:
+        Structure the output to clearly delineate the two sections while maintaining the original column structure. Ensure that there are no duplicate components or subcomponents in the output.
+        
+        Output Format Requirements:
+        - First Section - Planning & Testing Components:
+        component,mandays,description
+        "Requirements Analysis",0,"Critical user requirements and system specifications"
+        
+        - Second Section - Development Components:
+        component,subcomponent,mandays,description
+        "Backend","Core API Development",3,"Essential API endpoints for basic functionality"
+        
+        - Third Section - MVP Intents:
+        intent_type,intent,workflow,mandays
+        "Single-Step","Create New Order","1. User initiates order creation → 2. Extract order details from user input → 3. Save order to database → 4. Confirm creation to user",0.3
+        
+        Important:
+        - Each section must maintain its original column structure.
+        - Sections MUST be separated by the marker: "----SECTION BREAK----".
+        - Include ALL the components and intents.
+        - No empty rows or missing values.
+        - Text values must be in double quotes.
+        - Numbers must not be in quotes.
+        
+        Return only the CSV content with the section break, no additional text or explanations.
+        """,
         inputs=["revised_mandays_estimates"],
         outputs=["generated_MVP_mandays"],
         model=ModelType.O1_MINI,
@@ -709,7 +1570,22 @@ PROMPTS = {
     ),
     
     "generate_page_MVP_prd": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_page_MVP_prd']['prompt'],
+        prompt=
+        """
+        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
+        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
+        2. **Revised Mandays Estimates**: Incorporate the specific MVP components, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
+        
+        Follow these instructions:
+        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
+        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
+        - Do not add any context or assumptions beyond the provided inputs.
+        - Do not exclude any details from the inputs.
+        - Structure the document to ensure clarity, logical flow, and readability and use tabular format whenever possible.
+        - Use the title "Project Requirements" for the document.
+        
+        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
+        """,
         inputs=["generated_prd" , "generated_MVP_mandays"],
         outputs=["generated_mvp_prd"],
         model=ModelType.O1_MINI,
@@ -738,7 +1614,22 @@ PROMPTS = {
     ),
     
     "generate_engage_MVP_prd": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_engage_MVP_prd']['prompt'],
+        prompt=
+        """
+        Generate a comprehensive and structured Project Requirement Document (PRD) for a Minimum Viable Product (MVP) using the following inputs:
+        1. **General PRD Guidelines**: Use the provided general PRD as a framework for structure, tone, and level of detail. This includes sections like Introduction, Scope, Functional Requirements, Non-Functional Requirements, Technical Architecture, Workflow, Testing, Deployment, and Appendices.
+        2. **Revised Mandays Estimates**: Incorporate the specific MVP components & intents, including their descriptions, mandays estimates, and functionalities, into the relevant sections of the PRD. Ensure all details are accurately reflected.
+        
+        Follow these instructions:
+        - Retain ALL specific details, metrics, and constraints from both the general PRD and MVP components.
+        - Pay special attention to the time constraint for building the MVP, as outlined in the inputs.
+        - Do not add any context or assumptions beyond the provided inputs.
+        - Do not exclude any details from the inputs.
+        - Structure the document to ensure clarity, logical flow, and readability and structure tabular format if necessary.
+        - Use the title "Project Requirements" for the document.
+        
+        The output should be a well-organized PRD that combines the general PRD guidelines with the specific MVP components, ensuring alignment with the project's goals and constraints.
+        """,
         inputs=["generated_prd" , "generated_MVP_mandays"],
         outputs=["generated_mvp_prd"],
         model=ModelType.O1_MINI,
@@ -767,7 +1658,87 @@ PROMPTS = {
     ),
 
     "generate_page_BD_SOW": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_page_BD_SOW']['prompt'],
+        prompt=
+        """
+        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
+        
+        ### **Scope of Work (SOW)**
+        
+        #### **1. Project Background**
+        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
+        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
+        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentences.
+        
+        #### **2. Project Objective**
+        - Clearly define the project's primary goals and what constitutes success, using the following structure:
+        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
+        - Outcomes: Describe tangible deliverables and metrics for success.
+        
+        #### **3. Project Buyers & Stakeholders**
+        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
+        - Identify their name and roles in the project, using a table.
+        
+        #### **4. System Flow**
+        - Provide description of how the system components interact, describing what each module does and how it works.
+        - Use one of the following:
+        - Visual Representation: Diagram illustrating workflows or data flows between modules.
+        - Textual Description: Detailed explanation of the processes and transitions
+        - Use bullet point, ensure simplicity and avoid overly technical language.
+        
+        #### **5. Modules and Functional Requirements Breakdown**
+        - LEAVE THIS BLANK
+        
+        #### **6. Acceptance Criteria**
+        - Define conditions to be met, including specific, measurable criteria for project completion:
+        - Link each deliverable/module to its validation or testing process (e.g., UAT).
+        - Table format with the following column:
+        - Deliverable (e.g. Field Matching Automation module)
+        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status accordingly)
+        
+        #### **7. Assumptions and Pre-requisites**
+        - List all planning-phase assumptions and pre-requisites, grouped into:
+        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
+        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
+        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
+        - Be written in clear, concise language.
+        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
+        - Be specific and actionable.
+        - Reference who is responsible and what needs to be done.
+        
+        #### **8. Proposed Timeline**
+        - Provide a project timeline, including:
+        - Milestone
+        - Expected Date/Duration
+        - Outcome/Deliverable
+        - Use a Gantt chart or table to visualize the timeline.
+        - Ensure the output are clean, organized, and easy to read.
+        
+        #### **9. Commercial**
+        Summarize the project's commercial details in the following subsections:
+        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
+        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
+        - Payment Terms: Include a text description of payment terms:
+        - Milestones: Specify at which stages payments are due
+        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
+        - Other Terms: Mention late payment fees or additional terms, if applicable
+        - Output Format for tables: {Service}, {Fee} (leave amount blank)
+        
+        #### **10. Sign-Off**
+        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
+        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
+        - Provide placeholder for each party (Company):
+        - Signature
+        - Name
+        - Position
+        - Date
+        
+        #### **Guidelines**
+        - Use bullet points for clarity.
+        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
+        - Maintain structured sections and tables for readability.
+        
+        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
+        """,
         inputs=["generated_prd" , "generated_plan_test_components" , "reformatted_dev_components" , "combined_cost_summary"],
         outputs=["generated_BD_SOW"],
         model=ModelType.O1_MINI,
@@ -796,7 +1767,87 @@ PROMPTS = {
     ),
     
     "generate_engage_BD_SOW": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_engage_BD_SOW']['prompt'],
+        prompt=
+        """
+        As an project manager with 20+ years of experience, you are tasked to create a detailed Scope of Work (SOW) document. Analyze the provided project component list and scope document to generate the following sections. Follow the guidelines below to ensure a professional, structured, and client-ready output:
+        
+        ### **Scope of Work (SOW)**
+        
+        #### **1. Project Background**
+        - Provide a brief overview of the project, including the context, problem statement, and why the project is being initiated.
+        - Break down key challenges (in bullet point) the company currently facing, quantifying the impacts where possible (e.g., lost revenue, downtime).
+        - Close this section with industry trends or other relevant background information, emphasizing risks of inaction leading to the project, in 2-3 sentences.
+        
+        #### **2. Project Objective**
+        - Clearly define the project's primary goals and what constitutes success, using the following structure:
+        - Goals: List specific, measurable goals (e.g., reduce processing time by 20%).
+        - Outcomes: Describe tangible deliverables and metrics for success.
+        
+        #### **3. Project Buyers & Stakeholders**
+        - List key stakeholders involved in the project, e.g. buyers, end-users, and decision-makers.
+        - Identify their name and roles in the project, using a table.
+        
+        #### **4. System Flow**
+        - Provide description of how the system components interact, describing what each module does and how it works.
+        - Use one of the following:
+        - Visual Representation: Diagram illustrating workflows or data flows between modules.
+        - Textual Description: Detailed explanation of the processes and transitions
+        - Use bullet point, ensure simplicity and avoid overly technical language.
+        
+        #### **5. Modules and Functional Requirements Breakdown**
+        - LEAVE THIS BLANK
+        
+        #### **6. Acceptance Criteria**
+        - Define conditions to be met, including specific, measurable criteria for project completion:
+        - Link each deliverable/module to its validation or testing process (e.g., UAT).
+        - Table format with the following column:
+        - Deliverable (e.g. Field Matching Automation module)
+        - Criteria, starting with "able to" (e.g. able to extract, match, and change the case status accordingly)
+        
+        #### **7. Assumptions and Pre-requisites**
+        - List all planning-phase assumptions and pre-requisites, grouped into:
+        - Assumptions: Detailed, scenario-based assumptions that the project relies on. Each assumption should:
+        - Reference specific stakeholders (e.g., PWT staff, Mindhive).
+        - Describe specific conditions or expectations (e.g., document quality, workflow stability).
+        - Be written in clear, concise language.
+        - Pre-requisites or dependencies: Conditions that must be met before the project can proceed. Each pre-requisite should:
+        - Be specific and actionable.
+        - Reference who is responsible and what needs to be done.
+        
+        #### **8. Proposed Timeline**
+        - Provide a project timeline, including:
+        - Milestone
+        - Expected Date/Duration
+        - Outcome/Deliverable
+        - Use a Gantt chart or table to visualize the timeline.
+        - Ensure the output are clean, organized, and easy to read.
+        
+        #### **9. Commercial**
+        Summarize the project's commercial details in the following subsections:
+        - Development Fee: Create a table summarizing the costs for development, including the product, technical work supporting, or other additional services provided
+        - Subscription Fee: If applicable, create a table summarizing subscription fees for system usage.
+        - Payment Terms: Include a text description of payment terms:
+        - Milestones: Specify at which stages payments are due
+        - Invoicing: Define invoicing intervals (e.g., monthly, quarterly) and payment deadlines
+        - Other Terms: Mention late payment fees or additional terms, if applicable
+        - Output Format for tables: {Service}, {Fee} (leave amount blank)
+        
+        #### **10. Sign-Off**
+        - Create a professional and formal Sign-Off section  to acknowledge and approve the SOW.
+        - Include an statement to clearly communicate that both parties have reviewed and agreed to the SOW.
+        - Provide placeholder for each party (Company):
+        - Signature
+        - Name
+        - Position
+        - Date
+        
+        #### **Guidelines**
+        - Use bullet points for clarity.
+        - Keep descriptions concise and client-friendly; avoid technical jargon unless necessary.
+        - Maintain structured sections and tables for readability.
+        
+        Expected output should be professional, well-structured, and designed to help clients and stakeholders clearly understand the project scope. I'm going to tip you for a better outcome!
+        """,
         inputs=["generated_prd" , "generated_plan_test_components" , "reformatted_dev_components" , "generated_intent_list" , "combined_cost_summary" ],
         outputs=["generated_BD_SOW"],
         model=ModelType.O1_MINI,
@@ -825,7 +1876,55 @@ PROMPTS = {
     ),
 
     "generate_Tech_SOW": PromptConfig(
-        prompt=SYSTEM_PROMPTS['generate_Tech_SOW']['prompt'],
+        prompt=
+        """
+        As an experienced project manager with over 20 years of expertise, you are tasked to create a detailed Scope of Work (SOW) document in JSON format. The JSON output should contain markdown-formatted strings as values for each section of the SOW. Analyze the provided project component list and scope document to generate the following sections:
+        
+        ### **Scope of Work (SOW)**
+        
+        #### **1. Scope Summary**
+        - Provide a concise, high-level overview of the project scope. Divide it into three subsections:
+        - In Scope:
+        - List all deliverables, functionalities, and modules included in the project.
+        - Be specific about what will be developed, implemented, or delivered.
+        - Include MVP components (e.g., basic features, functionality, UI, document processing).
+        - Assumptions:
+        - Highlight key project-specific assumptions that the project relies on.
+        - Dependencies:
+        - List all internal and external dependencies required for the project's success.
+        - Include any third-party integrations, resources, or timelines that the project depends on.
+        
+        #### **2. Modules and Functional Requirements Breakdown**
+        - Break down the project into modules or components.
+        - Prsent the details in a succinct and client-friendly table with the following column:
+        - Module
+        ii. Functionalities/Features
+        iii. Notes for any special considerations or constraints (e.g., 'Supports files up to 100MB').
+        - Use clear, concise, non-technical language. (e.g., 'Drag-and-drop support for PDFs, Excel, CSV; progress indicators'). Avoid excessive detail.
+        - Include MVP components as part of the breakdown and provide clear functionalities related to those (e.g., basic document upload, UI features, data processing).
+        
+        #### **3. Out of Scope**
+        - Explicitly define what is excluded from the project's scope. This may include any functionalities, tasks, or deliverables.
+        - Ensure clarity to prevent future misunderstandings.
+        
+        #### **4. System Flow**
+        - Provide a detailed, step-by-step description of how the system components interact.
+        - For each component or module:
+        - Describe what it does and how it works, including both success and unsuccessful scenarios
+        - Explain how it interacts with other components
+        - Include MVP-related components in the system flow, describing their function and interaction within the MVP's framework.
+        
+        Output Requirements:
+        Just return the json object and nothing else, omit code guards ```, where each key represents a section of the SOW, and the value is a markdown-formatted string for that section.
+        Use clear, concise, and client-friendly language. Avoid excessive technical jargon unless necessary.
+        Example JSON Output:
+        {
+        "scope_summary": <markdown content>,
+        "modules_and_functional_requirements": <markdown content>,
+        "out_of_scope": <markdown content>,
+        "system_flow": <markdown content>
+        }
+        """,
         inputs=["generated_plan_test_components","reformatted_dev_components","generated_MVP_mandays"],
         outputs=["generated_Tech_SOW"],
         model=ModelType.O1_MINI,