Init Project v2

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.11 (pythonProject1)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.11 (pythonProject1)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/pythonProject1.iml" filepath="$PROJECT_DIR$/.idea/pythonProject1.iml" />
+    </modules>
+  </component>
+</project>

.idea/pythonProject1.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

app.py

@@ -0,0 +1,455 @@
+import streamlit as st
+import pandas as pd
+from groq_llms import LLMHandler
+#from openrouter_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.")

flask_api.py

@@ -0,0 +1,143 @@
+import os
+import io
+import json
+import tempfile
+import pandas as pd
+from flask import Flask, request, jsonify, send_file
+from flask_cors import CORS
+from dotenv import load_dotenv
+from groq_llms import LLMHandler
+
+# Load environment variables
+load_dotenv()
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for all routes
+
+# Initialize LLM Handler
+llm_handler = LLMHandler()
+
+
+def process_csv(file, user_prompt):
+    """
+    Process CSV file and generate responses using LLMHandler
+
+    Args:
+        file (werkzeug.datastructures.FileStorage): Uploaded CSV file
+        user_prompt (str): Prompt for invitation generation
+
+    Returns:
+        pandas.DataFrame: DataFrame with generated invitations
+    """
+    try:
+        # Read CSV directly from file storage
+        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
+    except Exception as e:
+        raise ValueError(f"Error processing CSV: {str(e)}")
+
+@app.route('/generate-questions', methods=['POST'])
+def generate_questions():
+    """
+    Generate questions based on initial context
+
+    Request Payload:
+    {
+        "context": "Initial context for invitation"
+    }
+
+    Returns:
+        JSON array of questions
+    """
+    data = request.json
+    context = data.get('context', '')
+
+    try:
+        questions = llm_handler.generate_questions(context)
+        return jsonify(questions)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route('/generate-final-prompt', methods=['POST'])
+def generate_final_prompt():
+    """
+    Generate final prompt based on context, questions, and answers
+
+    Request Payload:
+    {
+        "context": "Initial context",
+        "questions": [...],
+        "answers": {...}
+    }
+
+    Returns:
+        Generated final prompt
+    """
+    data = request.json
+    context = data.get('context', '')
+    questions = data.get('questions', [])
+    answers = data.get('answers', {})
+
+    try:
+        final_prompt = llm_handler.generate_final_prompt(context, questions, answers)
+        return jsonify({"prompt": final_prompt})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route('/process-invitations', methods=['POST'])
+def process_invitations():
+    """
+    Process CSV file and generate invitations
+
+    Request Parameters:
+    - file: CSV file
+    - prompt: Invitation generation prompt
+
+    Returns:
+        Processed CSV file with generated invitations
+    """
+    if 'file' not in request.files:
+        return jsonify({"error": "No file uploaded"}), 400
+
+    file = request.files['file']
+    user_prompt = request.form.get('prompt', '')
+
+    if file.filename == '':
+        return jsonify({"error": "No selected file"}), 400
+
+    try:
+        # Process CSV and generate invitations
+        processed_df = process_csv(file, user_prompt)
+
+        # Save processed DataFrame to a bytes buffer
+        output = io.BytesIO()
+        processed_df.to_csv(output, index=False)
+        output.seek(0)
+
+        # Return the file
+        return send_file(
+            output,
+            mimetype='text/csv',
+            as_attachment=True,
+            download_name='generated_invitations.csv'
+        )
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+if __name__ == '__main__':
+    # Configurable port, defaults to 5000
+    port = int(os.environ.get('PORT', 5000))
+    app.run(host='0.0.0.0', port=port, debug=True)

groq_llms.py

@@ -0,0 +1,243 @@
+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], take a text response from the user instead of multiple choice for this question.
+        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": "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):
+        formatted_answers = []
+        for i, question in enumerate(questions):
+            # Use str(i) to match the string keys in the answers dictionary
+            answer = answers.get(str(i), "")
+            formatted_answers.append(f"Q: {question['question']}\nA: {answer}")
+
+        answers_text = "\n".join(formatted_answers)
+        # Rest of the method remains the same
+        # Rest of the method remains the same
+        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" 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()
+
+        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, for example: 'Hello {data.get('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. You are free to choose complete or partial recipient-specific details (e.g., Job Title, Industry) mentioned in user prompt to make sure it fits naturally into the invite "
+            # 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"4. "
+            f"4. Avoid preambles, unnecessary symbols, or extraneous text.\n"
+            f"5. Return the final invite text cleanly, in concise with no demeaning language.\n\n"
+            f"Validate the invite to make sure it is following all the guidelines. "
+            # f"**Goal:** Generate personalized invites suitable for a wide range of recipients while aligning with the product or service described in the user prompt."
+        )
+
+        response = self.llm.invoke(prompt)
+        return response.content.strip()
+
+
+# Prompt for instruction generator:
+prompt1 = (
+    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."
+)
+prompt4 = 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.
+        """
+
+# prompt for invite generation
+
+prompt2 = (
+    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."
+)
+prompt3 = (
+    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. "
+
+)

requirements.txt

@@ -0,0 +1,15 @@
+numpy~=1.26.4
+pandas~=2.2.3
+sentence-transformers~=3.2.0
+python-dotenv~=1.0.1
+langchain-openai
+langchain_groq
+langchain
+langchain_community
+openai
+langchain-community~=0.3.3
+langchain-core~=0.3.12
+streamlit
+openrouter
+flask
+flask-cors

supplement/api.js

@@ -0,0 +1,47 @@
+// api.js
+const API_BASE_URL = 'http://localhost:5000/api';
+
+export const generateQuestions = async (context) => {
+  const response = await fetch(`${API_BASE_URL}/generate-questions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ context }),
+  });
+  return response.json();
+};
+
+export const generateFinalPrompt = async (context, questions, answers) => {
+  const response = await fetch(`${API_BASE_URL}/generate-final-prompt`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ context, questions, answers }),
+  });
+  return response.json();
+};
+
+export const processInvitations = async (file, prompt) => {
+  const formData = new FormData();
+  formData.append('file', file);
+  formData.append('prompt', prompt);
+
+  const response = await fetch(`${API_BASE_URL}/process-invitations`, {
+    method: 'POST',
+    body: formData,
+  });
+  return response.json();
+};
+
+export const updateSession = async (sessionData) => {
+  const response = await fetch(`${API_BASE_URL}/session`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(sessionData),
+  });
+  return response.json();
+};

supplement/llm_merger.py

@@ -0,0 +1,86 @@
+import os
+from dotenv import load_dotenv
+from langchain_groq import ChatGroq
+from openai import OpenAI
+
+load_dotenv()
+
+
+class PrimaryLLMHandler:
+    def __init__(self, model_name="gpt-4o-mini"):
+        """
+        Initializes the Primary LLM Handler (GPT0-mini).
+        """
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        if not self.openai_api_key:
+            raise ValueError("OPENAI_API_KEY environment variable not set.")
+
+        self.client = OpenAI(api_key=self.openai_api_key)
+        self.model_name = model_name
+
+    def generate_response(self, user_prompt, data):
+        """
+        Generates a response using the primary LLM.
+        """
+        prompt = (
+            f"You are a professional AI model tasked with writing personalized invite texts "
+            f"that are concise (less than 40 words), brochure-suitable, and tailored as per the category in the given sample."
+            f"\n\n"
+            f"User prompt: {user_prompt}\n\n"
+            f"Details of the individual:\n"
+            f"- Name: {data['Name']}\n"
+            f"- Job Title: {data['Job Title']}\n"
+            f"- Organisation: {data['Organisation']}\n"
+            f"- Area of Interest: {data['Area of Interest']}\n"
+            f"- Category: {data['Category']}\n\n"
+            f"The response should start with 'Hello {data['Name']}'."
+            f"Ensure the tone aligns with the instructions. STRICTLY give only one response."
+        )
+
+        completion = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": "You are a professional assistant AI."},
+                {"role": "user", "content": prompt},
+            ],
+        )
+
+        return completion.choices[0].message.content.strip()
+
+
+class ValidatorLLMHandler:
+    def __init__(self, model_name="gemma2-9b-it"):
+        """
+        Initializes the Validator LLM Handler (Llama 3.3 8B).
+        """
+        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 validate_and_correct_response(self, user_prompt, original_response, data):
+        """
+        Validates and corrects the response using the secondary LLM.
+        """
+        validation_prompt = (
+            f"You are a professional AI model tasked with validating and correcting AI-generated texts. "
+            f"The original response must align strictly with the provided user prompt and input details. "
+            f"If the response fails to meet the requirements, generate a corrected version."
+            f"\n\n"
+            f"User prompt: {user_prompt}\n\n"
+            f"Details of the individual:\n"
+            f"- Name: {data['Name']}\n"
+            f"- Job Title: {data['Job Title']}\n"
+            f"- Organisation: {data['Organisation']}\n"
+            f"- Area of Interest: {data['Area of Interest']}\n"
+            f"- Category: {data['Category']}\n\n"
+            f"Original response: {original_response}\n\n"
+            f"Instructions:\n"
+            f"- If the original response aligns with the user prompt and input details, reply with 'Valid Response'.\n"
+            f"- Otherwise, provide a corrected version starting with 'Hello {data['Name']}'.\n"
+            f"- Keep it concise (less than 40 words) and brochure-suitable.\n"
+        )
+
+        response = self.llm.invoke(validation_prompt)
+        return response.content.strip()

supplement/main.py

@@ -0,0 +1,56 @@
+import csv
+import os
+#from query_handler import LLMHandler
+from openai_llms import LLMHandler
+
+def main():
+    """
+    Main function to process input CSV, query LLM, and save responses.
+    """
+    # Ask user for input CSV file path and user prompt
+    #input_csv = input("Enter the path to the input CSV file: ").strip()
+    input_csv = "D:\Projects\Liminal\InviteAI\Test_sample.csv"
+    if not os.path.exists(input_csv):
+        print(f"Error: File '{input_csv}' not found.")
+        return
+    user_prompt = input("Enter your user prompt: ").strip()
+
+    # Output CSV file path
+    output_csv = "D:\Projects\Liminal\InviteAI\Response_sample.csv"
+
+    # Check if the input file exists
+    if not os.path.exists(input_csv):
+        print(f"Error: File '{input_csv}' not found.")
+        return
+
+    # Initialize the LLM handler
+    llm_handler = LLMHandler()
+    #llm_handler = LLMOpenAI()
+
+    # Read the input CSV and process each instance
+    with open(input_csv, mode="r", newline="", encoding="utf-8") as infile:
+        reader = csv.DictReader(infile)
+        fieldnames = reader.fieldnames + ["Generated Text"]
+
+        rows = []
+        for row in reader:
+            # Generate response for the current row
+            try:
+                response = llm_handler.generate_response(user_prompt, row)
+                row["Generated Text"] = response
+                rows.append(row)
+            except Exception as e:
+                print(f"Error generating response for UID {row.get('UID')}: {e}")
+                row["Generated Text"] = "Error generating response"
+                rows.append(row)
+
+    # Save the updated rows to the output CSV
+    with open(output_csv, mode="w", newline="", encoding="utf-8") as outfile:
+        writer = csv.DictWriter(outfile, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+    print(f"Responses saved to '{output_csv}'.")
+
+if __name__ == "__main__":
+    main()

supplement/openai_llms.py

@@ -0,0 +1,63 @@
+from openai import OpenAI
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+
+class LLMHandler:
+    def __init__(self, model_name="gpt-4o-mini"):
+        """
+        Initializes the LLMHandler with the specified OpenAI model.
+        """
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        if not self.openai_api_key:
+            raise ValueError("OPENAI_API_KEY environment variable not set.")
+
+        # Initialize OpenAI client
+        self.client = OpenAI(api_key=self.openai_api_key)
+        self.model_name = model_name
+
+    def generate_response(self, user_prompt, data):
+        """
+        Generate a concise response using the LLM based on user prompt and data.
+        :param user_prompt: Prompt provided by the user.
+        :param data: Dictionary containing the instance information.
+        :return: Generated response text.
+        """
+        # Refined prompt to handle encoding and formatting
+        prompt = (
+            f"You are a professional AI model tasked with writing personalized invite texts "
+            f"that are concise (less than 40 words), brochure-suitable, and tailored as per the user prompt.\n\n"
+            f"Consider the user prompt: {user_prompt}\n\n"
+            f"Details of the individual:\n"
+            f"- Name: {data['Name']}\n"
+            f"- Job Title: {data['Job Title']}\n"
+            f"- Organisation: {data['Organisation']}\n"
+            f"- Area of Interest: {data['Area of Interest']}\n"
+            f"- Category: {data['Category']}\n\n"
+            f"The response **MUST**:\n"
+            f"- Start with 'Hello {data['Name']}'.\n"
+            f"- Be concise, professional, and STRICTLY DO NOT generate invalid characters or encoding errors (e.g. 'SoraVR’s').\n"
+            f"- Use standard English punctuation, such as single quotes (e.g., 'can't', 'it's').\n"
+            f"- STRICTLY Give only one response for the Category the sample belongs to.\n"
+            f"- Do NOT include preambles or unnecessary text.\n\n"
+            f"Return the final response cleanly, without any extraneous symbols or characters."
+        )
+
+        # Query the OpenAI client and return the response
+        completion = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": "You are a professional assistant."},
+                {"role": "user", "content": prompt},
+            ]
+        )
+
+        # Extract and clean the generated response
+        response = completion.choices[0].message.content.strip()
+
+        # Optional: Post-process to clean invalid characters
+        #response_cleaned = response.encode('utf-8').decode('utf-8', errors='ignore')
+
+        return response

supplement/openrouter_llms.py

@@ -0,0 +1,172 @@
+import os
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class LLMHandler:
+    def __init__(self, model_name="meta-llama/llama-3.3-70b-instruct"):
+        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+        if not self.openrouter_api_key:
+            raise ValueError("OPENROUTER_API_KEY environment variable not set.")
+
+        # Initialize OpenAI client with OpenRouter base URL and default headers
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=self.openrouter_api_key,
+            default_headers={
+                "HTTP-Referer": "http://localhost:8501",  # Local development URL
+                "X-Title": "Invite AI",  # Application name
+                "x-routing-config": '{"provider": {"order": ["Together", "Avian.io", "DeepInfra", "Lambda"]}, "allow_fallbacks": false}'
+            }
+        )
+
+        self.model_name = model_name
+
+    def _make_api_call(self, messages):
+        """Helper method to make API calls"""
+        return self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages
+        )
+
+    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": "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:
+            response = self._make_api_call([{"role": "user", "content": prompt}])
+            response_text = response.choices[0].message.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")
+
+            return questions
+
+        except Exception as 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."""
+        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"The goal is by using this prompt, the user can obtain personalized invites to wide range of receivers work domain."
+        )
+
+        response = self._make_api_call([{"role": "user", "content": prompt}])
+        return response.choices[0].message.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, for example: 'Hello {data.get('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. You are free to choose complete or partial recipient-specific details (e.g., Job Title, Industry) mentioned in user prompt that would fit naturally into the invite "
+            #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"4. "
+            f"4. Avoid preambles, unnecessary symbols, or extraneous text.\n"
+            f"5. Return the final invite text cleanly, in concise with no demeaning language.\n\n"
+            f"Validate the invite to make sure it is following all the guidelines. "
+            #f"**Goal:** Generate personalized invites suitable for a wide range of recipients while aligning with the product or service described in the user prompt."
+        )
+
+        response = self._make_api_call([{"role": "user", "content": prompt}])
+        return response.choices[0].message.content.strip()