Upload 3 files

This version uses llms thrice.
1. To generate the questions from a small context.
2. To generate a prompt based on context and the question and answers.
3. To generate the personalized invites as per the designed user prompt.

app.py

@@ -1,109 +1,454 @@
-import streamlit as st
-import pandas as pd
-#from openai_llms import LLMHandler
-from Groq_llms import LLMHandler
-import tempfile
-import os
-
-# Load environment variables for OpenAI API Key
-from dotenv import load_dotenv
-
-load_dotenv()
-
-# Initialize LLMHandler
-llm_handler = LLMHandler()
-
-
-def process_csv(file, user_prompt):
-    """Read CSV, generate responses using LLMHandler, and return processed DataFrame."""
-    df = pd.read_csv(file)
-    responses = []
-
-    for _, row in df.iterrows():
-        try:
-            response = llm_handler.generate_response(user_prompt, row.to_dict())
-            responses.append(response)
-        except Exception as e:
-            responses.append(f"Error: {e}")
-
-    df["Generated Text"] = responses
-    return df
-
-
-# Streamlit UI
-st.set_page_config(page_title="Invitation Generator", page_icon="💬", layout="wide")
-
-# Header
-st.title("Invite AI")
-st.markdown(
-    """
-    Welcome to the Invitation Generator! This tool helps you create personalized invitations using the power of AI.
-    Follow the steps below to upload your data and generate professional invitation texts.
-    """
-)
-
-# Section: Template Download and Instructions
-st.sidebar.title("Instructions")
-st.sidebar.markdown(
-    """
-    ### Template Download
-    [Click here to download the suggested CSV template](http://surl.li/ptvzzv) 📥
-
-    ### Required Fields
-    - **Unique Identifier for each receiver**
-    - **Name of the receiver**
-    - **Designation/Job title of the receiver**
-    - **Company/Organisation where the receiver works**
-    - **Areas the receiver is interested in / has expertise in**
-    - **Categorize receivers into groups** for consistent instructions.
-    """
-)
-
-# Main Section
-st.markdown(
-    """
-    ### Steps to Use
-    1. **Download the template** from the sidebar.
-    2. **Fill out the details** as per the instructions.
-    3. **Upload the completed CSV file** below.
-    4. Enter a **prompt** to generate personalized invitations.
-    """
-)
-
-# File uploader for CSV
-uploaded_file = st.file_uploader("📂 Upload CSV File", type=["csv"])
-user_prompt = st.text_area(
-    "✍️ Enter the prompt for generating invitation texts:",
-    "Write professional invitation text tailored for the group.",
-    height=150,
-)
-
-# Processing and displaying results
-if uploaded_file is not None and user_prompt:
-    st.write("⏳ Processing your file... Please wait.")
-    processed_df = process_csv(uploaded_file, user_prompt)
-
-    # Display results
-    st.write("### Generated Invitations")
-    st.dataframe(processed_df, use_container_width=True)
-
-    # Option to download the processed CSV
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as temp_file:
-        processed_df.to_csv(temp_file.name, index=False)
-        temp_file.close()  # Ensure the file is properly closed before proceeding
-
-        st.download_button(
-            label="📥 Download Results CSV",
-            data=open(temp_file.name, "rb"),
-            file_name="generated_invitations.csv",
-            mime="text/csv",
-        )
-
-    # Safely delete the temporary file
-    os.unlink(temp_file.name)
-
-# Footer
-st.markdown("---")
-st.markdown(
-    "💡 **Tip:** Ensure your data aligns with the provided template for accurate results."
-)
+import streamlit as st
+import pandas as pd
+from groq_llms import LLMHandler
+import tempfile
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Initialize LLMHandler
+llm_handler = LLMHandler()
+
+
+def process_csv(file, user_prompt):
+    """Read CSV, generate responses using LLMHandler, and return processed DataFrame."""
+    df = pd.read_csv(file)
+    responses = []
+
+    for _, row in df.iterrows():
+        try:
+            response = llm_handler.generate_response(user_prompt, row.to_dict())
+            responses.append(response)
+        except Exception as e:
+            responses.append(f"Error: {e}")
+
+    df["Generated Text"] = responses
+    return df
+
+
+def initialize_session_state():
+    """Initialize session state variables"""
+    if 'prompt_creation_method' not in st.session_state:
+        st.session_state.prompt_creation_method = None
+    if 'current_step' not in st.session_state:
+        st.session_state.current_step = 'choose_method'
+    if 'context' not in st.session_state:
+        st.session_state.context = ""
+    if 'questions' not in st.session_state:
+        st.session_state.questions = []
+    if 'answers' not in st.session_state:
+        st.session_state.answers = {}
+    if 'multiselect_answers' not in st.session_state:
+        st.session_state.multiselect_answers = {}
+    if 'custom_options' not in st.session_state:
+        st.session_state.custom_options = {}
+    if 'final_prompt' not in st.session_state:
+        st.session_state.final_prompt = ""
+    if 'direct_prompt' not in st.session_state:
+        st.session_state.direct_prompt = ""
+
+
+def display_progress_tracker():
+    """Display current progress and previous responses"""
+    with st.expander("📋 View Progress", expanded=True):
+        if st.session_state.prompt_creation_method:
+            st.write(f"**Method chosen:** {st.session_state.prompt_creation_method.title()}")
+
+        if st.session_state.context:
+            st.write("**Initial Context:**")
+            st.info(st.session_state.context)
+            if st.button("Edit Context", key="edit_context"):
+                st.session_state.current_step = 'initial_context'
+                st.rerun()
+
+        if st.session_state.answers:
+            st.write("**Your Responses:**")
+            for i, question in enumerate(st.session_state.questions):
+                if i in st.session_state.multiselect_answers:
+                    answers = ", ".join(st.session_state.multiselect_answers[i])
+                    st.success(f"Q: {question['question']}\nA: {answers}")
+                elif i in st.session_state.answers:
+                    st.success(f"Q: {question['question']}\nA: {st.session_state.answers[i]}")
+            if st.button("Edit Responses", key="edit_responses"):
+                st.session_state.current_step = 'answer_questions'
+                st.rerun()
+
+        if st.session_state.direct_prompt:
+            st.write("**Your Direct Prompt:**")
+            st.info(st.session_state.direct_prompt)
+            if st.button("Edit Prompt", key="edit_direct_prompt"):
+                st.session_state.current_step = 'direct_prompt'
+                st.rerun()
+
+        if st.session_state.final_prompt:
+            st.write("**Final Generated Prompt:**")
+            st.info(st.session_state.final_prompt)
+            if st.button("Edit Final Prompt", key="edit_final_prompt"):
+                st.session_state.current_step = 'edit_prompt'
+                st.rerun()
+
+
+# Streamlit UI
+st.set_page_config(page_title="Invite AI", page_icon="💬", layout="wide")
+
+# Header
+st.title("Invite AI")
+st.markdown(
+    """
+    Welcome to the Invitation Generator! This tool helps you create personalized invitations using the power of AI.
+    """
+)
+
+# Initialize session state
+initialize_session_state()
+
+# Display progress tracker (always visible)
+display_progress_tracker()
+
+# Sidebar with instructions
+st.sidebar.title("Instructions")
+st.sidebar.markdown(
+    """
+    ### Template Download
+    [Click here to download the suggested CSV template](http://surl.li/ptvzzv) 📥
+    ### Suggested Requirements
+    - **Unique Identifier for each receiver**
+    - **Name of the receiver**
+    - **Designation/Job title of the receiver**
+    - **Company/Organisation where the receiver works**
+    - **Areas the receiver is interested in / has expertise in**
+    - **Categorize receivers into groups**
+    
+    [Note: The above template is for your reference, you are free to submit your own data.] 
+    """
+)
+
+# Main content area with steps
+st.markdown("---")  # Separator between progress tracker and current step
+
+if st.session_state.current_step == 'choose_method':
+    st.subheader("Choose Your Prompt Creation Method")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("""
+        ### Guided Prompt Builder
+        - Step-by-step assistance
+        - AI-generated questions
+        - Structured approach
+        """)
+        if st.button("Use Guided Builder"):
+            st.session_state.prompt_creation_method = 'guided'
+            st.session_state.current_step = 'initial_context'
+            st.rerun()
+
+    with col2:
+        st.markdown("""
+        ### Direct Prompt Entry
+        - Write your own prompt
+        - Complete control
+        - Quick setup
+        """)
+        if st.button("Use Direct Entry"):
+            st.session_state.prompt_creation_method = 'direct'
+            st.session_state.current_step = 'direct_prompt'
+            st.rerun()
+
+elif st.session_state.current_step == 'direct_prompt':
+    st.subheader("Enter Your Prompt")
+    st.markdown(
+        "Write your complete prompt for generating invitations. Include all necessary details and requirements.")
+
+    direct_prompt = st.text_area(
+        "Your Prompt:",
+        value=st.session_state.direct_prompt,
+        placeholder="Example: Generate a professional invitation for a product launch...",
+        height=200
+    )
+
+    col1, col2 = st.columns([1, 5])
+    with col1:
+        if st.button("← Back"):
+            st.session_state.current_step = 'choose_method'
+            st.rerun()
+    with col2:
+        if st.button("Continue →"):
+            if direct_prompt:
+                st.session_state.direct_prompt = direct_prompt
+                st.session_state.final_prompt = direct_prompt
+                st.session_state.current_step = 'upload_process'
+                st.rerun()
+            else:
+                st.error("Please enter a prompt before continuing.")
+
+elif st.session_state.prompt_creation_method == 'guided':
+    if st.session_state.current_step == 'initial_context':
+        st.subheader("Step 1: Provide Initial Context")
+        st.markdown("Briefly describe what your invitation is about (e.g., 'Launching a new GPU product')")
+
+        context = st.text_area(
+            "Context:",
+            value=st.session_state.context,
+            placeholder="Example: Launching a new GPU product for AI and HPC applications",
+            height=100
+        )
+
+        col1, col2 = st.columns([1, 5])
+        with col1:
+            if st.button("← Back"):
+                st.session_state.current_step = 'choose_method'
+                st.rerun()
+        with col2:
+            if st.button("Generate Questions →"):
+                if context:
+                    st.session_state.context = context
+                    st.session_state.questions = llm_handler.generate_questions(context)
+                    st.session_state.current_step = 'answer_questions'
+                    st.rerun()
+                else:
+                    st.error("Please provide context before proceeding.")
+
+
+    # In the answer_questions section of your code, replace the multiselect implementation with this:
+
+    elif st.session_state.current_step == 'answer_questions':
+
+        st.subheader("Step 2: Answer Questions")
+
+        for i, question in enumerate(st.session_state.questions):
+
+            if 'choices' in question:
+
+                # Get previously selected options
+
+                previous_selections = st.session_state.multiselect_answers.get(i, [])
+
+                # Initialize base choices
+
+                base_choices = question['choices'].copy()
+
+                if "Custom" not in base_choices:
+                    base_choices.append("Custom")
+
+                # Add any previous custom value to the choices if it exists
+
+                custom_values = [x for x in previous_selections if x not in question['choices'] and x != "Custom"]
+
+                all_choices = base_choices + custom_values
+
+                # Handle word count questions differently
+
+                if any(word in question['question'].lower() for word in ['word count', 'words', 'length']):
+
+                    selected_options = st.multiselect(
+
+                        question['question'],
+
+                        options=all_choices,
+
+                        default=previous_selections,
+
+                        key=f"multiselect_{i}"
+
+                    )
+
+                    if "Custom" in selected_options:
+
+                        # Pre-fill with previous custom value if exists
+
+                        default_custom = next((x for x in previous_selections if x not in base_choices), "")
+
+                        custom_value = st.text_input(
+
+                            "Enter custom word count:",
+
+                            value=default_custom,
+
+                            key=f"custom_{i}"
+
+                        )
+
+                        if custom_value:
+
+                            try:
+
+                                word_count = int(custom_value)
+
+                                if word_count > 0:
+
+                                    selected_options = [opt for opt in selected_options if opt != "Custom"]
+
+                                    if str(word_count) not in selected_options:
+                                        selected_options.append(str(word_count))
+
+                                else:
+
+                                    st.error("Please enter a positive number")
+
+                            except ValueError:
+
+                                st.error("Please enter a valid number")
+
+
+                else:
+
+                    # Regular non-numeric multiselect handling
+
+                    selected_options = st.multiselect(
+
+                        question['question'],
+
+                        options=all_choices,
+
+                        default=previous_selections,
+
+                        key=f"multiselect_{i}"
+
+                    )
+
+                    if "Custom" in selected_options:
+
+                        # Pre-fill with previous custom value if exists
+
+                        default_custom = next((x for x in previous_selections if x not in base_choices), "")
+
+                        custom_value = st.text_input(
+
+                            "Enter your custom response:",
+
+                            value=default_custom,
+
+                            key=f"custom_{i}"
+
+                        )
+
+                        if custom_value:
+
+                            selected_options = [opt for opt in selected_options if opt != "Custom"]
+
+                            if custom_value not in selected_options:
+                                selected_options.append(custom_value)
+
+                # Update session state
+
+                st.session_state.multiselect_answers[i] = selected_options
+
+                st.session_state.answers[i] = ", ".join(selected_options) if selected_options else ""
+
+
+            else:
+
+                # Handle non-choice questions
+
+                st.session_state.answers[i] = st.text_input(
+
+                    question['question'],
+
+                    value=st.session_state.answers.get(i, ""),
+
+                    key=f"question_{i}"
+
+                )
+
+        col1, col2 = st.columns([1, 5])
+
+        with col1:
+
+            if st.button("← Back"):
+                st.session_state.current_step = 'initial_context'
+
+                st.rerun()
+
+        with col2:
+
+            if st.button("Generate Prompt →"):
+
+                if all(st.session_state.answers.values()):
+
+                    st.session_state.final_prompt = llm_handler.generate_final_prompt(
+
+                        st.session_state.context,
+
+                        st.session_state.questions,
+
+                        st.session_state.answers
+
+                    )
+
+                    st.session_state.current_step = 'edit_prompt'
+
+                    st.rerun()
+
+                else:
+
+                    st.error("Please answer all questions before proceeding.")
+    elif st.session_state.current_step == 'edit_prompt':
+        st.subheader("Step 3: Review and Edit Final Prompt")
+        edited_prompt = st.text_area(
+            "Edit your prompt if needed:",
+            value=st.session_state.final_prompt,
+            height=200
+        )
+
+        col1, col2 = st.columns([1, 5])
+        with col1:
+            if st.button("← Back"):
+                st.session_state.current_step = 'answer_questions'
+                st.rerun()
+        with col2:
+            if st.button("Continue to Upload →"):
+                st.session_state.final_prompt = edited_prompt
+                st.session_state.current_step = 'upload_process'
+                st.rerun()
+
+# Common upload and processing section for both paths
+if st.session_state.current_step == 'upload_process':
+    st.subheader("Upload and Process")
+    uploaded_file = st.file_uploader("📂 Upload CSV File", type=["csv"])
+
+    col1, col2 = st.columns([1, 5])
+    with col1:
+        if st.button("← Back"):
+            if st.session_state.prompt_creation_method == 'guided':
+                st.session_state.current_step = 'edit_prompt'
+            else:
+                st.session_state.current_step = 'direct_prompt'
+            st.rerun()
+
+    if uploaded_file is not None and st.session_state.final_prompt:
+        st.write("⏳ Processing your file... Please wait.")
+        processed_df = process_csv(uploaded_file, st.session_state.final_prompt)
+
+        st.write("### Generated Invitations")
+        st.dataframe(processed_df, use_container_width=True)
+
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".csv") as temp_file:
+            processed_df.to_csv(temp_file.name, index=False)
+            temp_file.close()
+
+            st.download_button(
+                label="📥 Download Results CSV",
+                data=open(temp_file.name, "rb"),
+                file_name="generated_invitations.csv",
+                mime="text/csv",
+            )
+            os.unlink(temp_file.name)
+
+# Reset button (moved to sidebar)
+st.sidebar.markdown("---")
+if st.sidebar.button("🔄 Start Over"):
+    st.session_state.prompt_creation_method = None
+    st.session_state.current_step = 'choose_method'
+    st.session_state.context = ""
+    st.session_state.questions = []
+    st.session_state.answers = {}
+    st.session_state.multiselect_answers = {}
+    st.session_state.custom_options = {}
+    st.session_state.final_prompt = ""
+    st.session_state.direct_prompt = ""
+    st.rerun()
+
+st.markdown("---")
+st.markdown("💡 **Tip:** Ensure your data aligns with the provided template for accurate results.")

groq_llms.py

@@ -0,0 +1,225 @@
+import os
+from langchain_groq import ChatGroq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class LLMHandler:
+    def __init__(self, model_name="llama-3.3-70b-versatile"):
+        self.groq_api_key = os.getenv("GROQ_API_KEY")
+        if not self.groq_api_key:
+            raise ValueError("GROQ_API_KEY environment variable not set.")
+        self.llm = ChatGroq(groq_api_key=self.groq_api_key, model_name=model_name)
+
+    def generate_questions(self, context):
+        """Generate questions based on the initial context provided by the user."""
+        prompt = f"""
+        Based on this context about an invitation: "{context}"
+
+        Generate questions to gather necessary information for creating a professional invitation prompt.
+        
+        Generate 8-12 focused questions. Include multiple choice options where appropriate.
+        Questions should cover:
+        1. Senders Company/Organization and role details
+        2. Product/service specific details
+        3. Key specifications or features
+        4. Approximate length of the invite [Word count]
+        5. What information from the receivers details do you want to include and influence in the invite
+        6. Tone and style preferences
+        7. Additional information which you would like to provide [Type N/A if you wish not to]
+        8. Call to action [multiple choice] for example [ contact phone number, visit our website, visit our social media etc]
+        9. In context to Call to action question, ask a followup question [Textual response] for CTA
+         to collect the website link/ phone number/ social media handles etc.
+
+        Return the questions in this exact JSON format:
+        [
+            {{"question": "Question 1", "choices": ["Choice 1", "Choice 2"]}},
+            {{"question": "Question 2"}},
+            {{"question": "Question 3", "choices": ["Choice 1", "Choice 2", "Choice 3"]}}
+        ]
+
+        For questions without multiple choice options, omit the 'choices' key.
+        Make choices relevant but not exhaustive, as users will have option for custom responses.
+        """
+
+        # Default questions to use as fallback
+        default_questions = [
+            {
+                "question": "What is your role in the company?",
+                "choices": ["CEO", "CTO", "Director", "Product Manager"]
+            },
+            {
+                "question": "What is your company name?",
+            },
+            {
+                "question": "What is the name of your product/service?",
+            },
+            {
+                "question": "What is the suggested Invite lenght[word count] you prefer?",
+            },
+            {
+                "question": "What is the key technical specification or feature?",
+            },
+            #{
+             #   "question": "What are the primary target applications?",
+              #  "choices": ["AI/ML", "Scientific Computing", "Graphics/Gaming", "Enterprise"]
+            #},
+            {
+                "question": "Can you explain in brief about what the invite is about?",
+            },
+            {
+                "question": "Select the preferred tone for the invitation:",
+                "choices": ["Professional", "Innovation-focused", "Casual", "Business & Strategic", "Friendly"]
+            }
+        ]
+
+        try:
+            # Get response from LLM
+            response = self.llm.invoke(prompt)
+
+            # Extract the JSON string from the response
+            response_text = response.content.strip()
+
+            # Find the start and end of the JSON array
+            start_idx = response_text.find('[')
+            end_idx = response_text.rfind(']') + 1
+
+            if start_idx == -1 or end_idx == 0:
+                raise ValueError("Could not find JSON array in response")
+
+            json_str = response_text[start_idx:end_idx]
+
+            # Parse the JSON string
+            import json
+            questions = json.loads(json_str)
+
+            # Validate the question format
+            for question in questions:
+                if 'question' not in question:
+                    raise ValueError("Question missing 'question' field")
+                if 'choices' in question and not isinstance(question['choices'], list):
+                    raise ValueError("'choices' must be a list")
+
+            # If we successfully parsed the questions, return them
+            return questions
+
+        except Exception as e:
+            #print(f"Error parsing LLM response: {str(e)}")
+            print("Using default questions as fallback")
+            return default_questions
+
+    def generate_final_prompt(self, context, questions, answers):
+        """Generate the final prompt based on context and question answers."""
+        # Create a formatted string of answers, handling both predefined and custom responses
+        formatted_answers = []
+        for i, question in enumerate(questions):
+            answer = answers[i]
+            formatted_answers.append(f"Q: {question['question']}\nA: {answer}")
+
+        answers_text = "\n".join(formatted_answers)
+        prompt = (
+            f"Your task is to generate a professional prompt for invitation generation by using the below context and answers: \n"
+            f" The initial context provided by user to generate the questions are [Context] :{context} and"
+            f" The questions and answers provide detail information on how the prompt has to be designed [Answers]: {answers_text}. \n"
+            f" Please follow the below instructions while drafting the prompt: \n"
+            f" 1. Use the Complete Information in the context and answers. \n"
+            f" 2. You Should draft best suitable prompt that can be used for generating personalized invites based on the information provided by user. \n"
+            f" 3. Generate only the prompt and DO NOT include any statements like this in the beginning: \n"
+            f" [Here is a professional prompt for invitation generation based on the provided context and answers] \n"
+            #f"In addition, make sure the prompt generated includes the below points: \n"
+            #f" 1. If the receivers information is not related to context and answers, generate a professional generic invite.\n "
+            #f" for example: If the context is about gpu device, the receiver is a farmer, then provide a generic response highlighting its features. \n"
+            #f"but if the receiver is GENAI engineer, provide an invite highlighting on how it is suitable to their needs and ease their work. "
+            #f" 2. Aptly fit the receivers information in the invite and make sure it is not forcefully added in the invite"
+            f" The goal is by using this prompt, the user can obtain personalized invites to wide range of receivers work domain."
+        )
+        #response = self.llm.invoke(prompt)
+        #return response.content.strip()
+        prompt2 = f"""
+        Based on the initial context: "{context}" and the provided answers: {answers_text}, 
+        Generate a professional prompt for invitation generation by USING COMPLETE INFORMATION in the context and answers, 
+        which is most suitable to generate the best invites. 
+        The goal is, you should draft best suitable prompt that can be sent to LLM for generating personalized invites 
+       # based on the information available in context and answers. \n
+
+        f" STRICTLY provide NO preamble.\n"
+        #f"2. If the recipient's field does not match the product domain, generate a professional generic invite instead.\n"
+        #f"3. If the recipient is not working at any company[for ex: self employed] do consider this case while drafting the prompt
+         #and think on how to handle this case.
+
+        #The response should consist ONLY of the generated prompt as per these instructions.
+        """
+        response = self.llm.invoke(prompt)
+        return response.content.strip()
+
+    def generate_response(self, user_prompt, data):
+        """Generate a concise response using the LLM based on user prompt and data."""
+
+        prompt = (
+            f"You are a professional AI model tasked with writing personalized invite texts that are brochure-suitable "
+            f"and tailored to the user's request and recipient details.\n\n"
+            f"User Prompt: {user_prompt}\n"
+            f"Recipient Details: {data}\n\n"
+            f"**Instructions:**\n"
+            f"1. Start the response with an appropriate salutation, such as 'Hello {data['Name']}' if available.\n"
+            f"2. Match the tone specified in the user prompt. If no tone is mentioned, use a formal tone.\n"
+            f"3. Write the invite within 90-100 words unless a specific length is provided.\n"
+            f"4. Strictly adhere to all instructions and details given in the user prompt.\n\n"
+            f"**Additional Guidelines:**\n"
+            f"1. Tailor the invite to align with the recipient’s context and profession. For example:\n"
+            f"   - If the recipient's information is unrelated to the context, provide a general formal invite highlighting key features.\n"
+            f"   - If the recipient is closely related to the context (e.g., a GENAI engineer for an AI product), highlight specific benefits relevant to their needs.\n"
+            f"2. Seamlessly incorporate recipient-specific details (e.g., Job Title, Industry) mentioned in user prompt only if they fit naturally into the invite.\n"
+            f"3. Do not forcefully match the applications of the user product with the recipients information. \n"
+            f"3. Avoid preambles, unnecessary symbols, or extraneous text.\n"
+            f"4. Return the final invite text cleanly, in concise with no demeaning language.\n\n"
+            f"**Goal:** Generate personalized invites suitable for a wide range of recipients while aligning with the product or service described in the user prompt."
+        )
+
+        prompt2 = (
+            f" You are a professional AI model tasked with writing personalized invite texts that are brochure-suitable "
+            f" and tailored as per the user prompt and details of the recipient.\n\n"
+            f"User Prompt: {user_prompt}\n\n"
+            f"Details of the Recipient: {data}\n\n"
+            f"Please follow the below instructions while drafting the Invite of the recipient:\n"
+            f"1. The response must start with appropriate salutations.\n"
+            f"2. Match the tone of the invite specified in the user prompt. If not mentioned, use a formal tone.\n"
+            f"3. If the user prompt does not specify the invite length, write the invite within 80-90 words.\n"
+            f"4. Make sure to **follow all the instructions** given in the user prompt. \n\n"
+            f"In addition, the invite generated SHOULD include the below points: \n"
+            f" 1. If the recipients information is not related to context of the user prompt, generate a professional formal invite with NO demeaning words.\n "
+            f" for example: If the context is about gpu device, the receiver is a farmer, then provide a generic response highlighting its features. \n"
+            f"but if the recipient is GENAI engineer, provide an invite highlighting on how it is suitable to their needs and ease their work. "
+            f" 2. Aptly fit the recipient-specific details (e.g., Job Title, Industry, Areas of Interest) as specified in the user prompt in the invite "
+            f"and make sure it is not forcefully added in the invite. \n"
+            f" 3. Avoid preambles, extraneous symbols, or unnecessary text.\n"
+            f" 4. Return only the final invite text in clean, concise language.\n\n"
+
+            f"The goal is to generate personalized invites to wide range of receivers in terms of work domain, while matching it with the product/service "
+            f"provided by the user, make sure the invites are fulfilling this goal. "
+
+
+
+
+        )
+       # prompt = (
+        #    f"You are a professional AI model tasked with writing personalized invite texts that are brochure-suitable "
+         #   f"and tailored to the user's request.\n\n"
+          #  f"User Prompt: {user_prompt}\n\n"
+           # f"Details of the Recipient: {data}\n\n"
+            #f"Please follow the below instructions while drafting the Invite of the recipient:\n"
+           # f"1. The response must start with appropriate salutations.\n"
+           # f"2. Match the tone of the invite specified in the user prompt. If not mentioned, use a formal tone.\n"
+           # f"3. Incorporate recipient-specific details (e.g., Job Title, Industry, Areas of Interest) as specified in the user prompt. If not mentioned, "
+           # f"use the provided recipient details.\n"
+           # f"4. Adjust the technical depth based on the recipient's expertise level.\n"
+           # f"5. If the recipient's details does not match the product domain, generate a professional generic invite instead.\n"
+           # f"6. If the user prompt does not specify the invite length, write the invite within 50-60 words.\n\n"
+           # f"Constraints:\n"
+           # f"- Strictly adhere to all details mentioned in the user prompt.\n"
+           # f"- Avoid preambles, extraneous symbols, or unnecessary text.\n"
+           # f"- Return only the final invite text in clean, concise language."
+        #)
+
+        response = self.llm.invoke(prompt)
+        return response.content.strip()