import pandas as pd
    import os

    df = pd.read_csv('friends.csv')

    refined_df = df[['text','speaker']]

    characters = ['Monica Geller', 'Joey Tribbiani', 'Chandler Bing', 'Phoebe Buffay', 'Ross Geller', 'Rachel Green']

    output_dir = "char_wise_dialogs"

    os.makedirs(output_dir, exist_ok=True)

    for character in characters:
        char_dialogs = refined_df[refined_df['speaker'] == character]

        file_name = f"{character.replace(' ','_')}_dialogues.csv"
        output_file = os.path.join(output_dir, file_name)

        char_dialogs.to_csv(output_file, index=False)
        print(f"Saved {character}'s dialogues to {output_file}")

 import boto3
    import pandas as pd
    import os
    import json
    from opensearchpy import OpenSearch, RequestsHttpConnection, helpers

    # AWS OpenSearch domain details
    OPENSEARCH_HOST = "open search endpoint without https"  # Replace with your endpoint
    INDEX_NAME = "friends-dialogues"

    # Initialize OpenSearch client
    client = OpenSearch(
        hosts=[{'host': OPENSEARCH_HOST, 'port': 443}],
        http_auth=('admin', '******'),  # Replace with your OpenSearch credentials
        use_ssl=True,
        verify_certs=True,
        connection_class=RequestsHttpConnection
    )

    # Initialize Bedrock client
    bedrock_client = boto3.client('bedrock-runtime', region_name='us-east-1')  # Replace with your region

    # Folder containing dialogues
    input_folder = "char_wise_dialogs"

    # Batch size for processing
    BATCH_SIZE = 20

    # Function to generate an embedding using Bedrock
    def generate_embedding(text):
        payload = {
            "inputText": text
        }
        response = bedrock_client.invoke_model(
            modelId="amazon.titan-embed-text-v2:0",
            contentType="application/json",
            accept="application/json",
            body=json.dumps(payload)
        )
        response_body = json.loads(response['body'].read())
        return response_body.get('embedding')

    # Function to index documents in bulk in OpenSearch
    def bulk_index_documents(batch):
        actions = [
            {
                "_index": INDEX_NAME,
                "_source": {
                    "character": doc["character"],
                    "dialogue": doc["dialogue"],
                    "embedding": doc["embedding"]
                }
            }
            for doc in batch
        ]
        helpers.bulk(client, actions)

    # Create the index in OpenSearch (if not already created)
    if not client.indices.exists(INDEX_NAME):
        client.indices.create(index=INDEX_NAME, body={
            "settings": {
                "number_of_shards": 1,
                "number_of_replicas": 1,
                "index": {
                    "knn": True  # Enable kNN search for this index
                }
            },
            "mappings": {
                "properties": {
                    "character": {"type": "keyword"},
                    "dialogue": {"type": "text"},
                    "embedding": {
                        "type": "knn_vector",
                        "dimension": 1024  # Replace with the embedding size
                    }
                }
            }
        })
        print(f"Created index with knn_vector: {INDEX_NAME}")

    # Process each character file
    for file_name in os.listdir(input_folder):
        if file_name.endswith('.csv'):
            # Read character dialogues
            character_file = os.path.join(input_folder, file_name)
            df = pd.read_csv(character_file)

            # Process in batches
            batch = []
            for index, row in df.iterrows():
                dialogue = row['text']
                character = row['speaker']

                try:
                    # Generate embedding for each dialogue
                    embedding = generate_embedding(dialogue)
                    batch.append({"dialogue": dialogue, "character": character, "embedding": embedding})

                    # Process the batch if it reaches the batch size
                    if len(batch) == BATCH_SIZE:
                        # Bulk index the batch into OpenSearch
                        bulk_index_documents(batch)
                        print(f"Indexed batch of size {len(batch)}")
                        batch = []  # Reset the batch
                except Exception as e:
                    print(f"Error processing dialogue: {dialogue[:50]} - {e}")

            # Process any remaining documents in the last batch
            if batch:
                bulk_index_documents(batch)
                print(f"Indexed remaining batch of size {len(batch)}")

import boto3
    import json
    from opensearchpy import OpenSearch, RequestsHttpConnection

    # OpenSearch configuration
    OPENSEARCH_HOST = "open search endpoint without https"
    INDEX_NAME = "friends-dialogues"

    # Initialize OpenSearch client
    client = OpenSearch(
        hosts=[{'host': OPENSEARCH_HOST, 'port': 443}],
        http_auth=('admin', '******'),
        use_ssl=True,
        verify_certs=True,
        connection_class=RequestsHttpConnection
    )

    # Bedrock clients for embedding and refinement
    bedrock_client = boto3.client('bedrock-runtime', region_name='us-east-1')

    # Function to generate embedding for user input
    def generate_embedding(text):
        payload = {"inputText": text}
        response = bedrock_client.invoke_model(
            modelId="amazon.titan-embed-text-v2:0",
            contentType="application/json",
            accept="application/json",
            body=json.dumps(payload)
        )
        response_body = json.loads(response['body'].read())
        return response_body.get('embedding')

    # Function to query OpenSearch for similar dialogues
    def query_opensearch(user_embedding):
        query = {
            "size": 1,
            "query": {
                "knn": {
                    "embedding": {
                        "vector": user_embedding,
                        "k": 1
                    }
                }
            }
        }
        response = client.search(index=INDEX_NAME, body=query)
        hits = response["hits"]["hits"]
        if hits:
            return hits[0]["_source"]
        return None

    def refine_response(user_prompt, character, retrieved_dialogue):
        # Construct a guided and controlled prompt
        prompt = (
            f"You are an assistant generating responses for a Friends-themed chatbot. Your task is to:\n"
            f"1. Respond in the tone and style of the specified character.\n"
            f"2. Avoid adding irrelevant details or extra sentences.\n"
            f"3. Ensure responses are casual and character-specific.\n"
            f"4. Exclude any metadata or instructional text in the response.\n\n"
            f"Examples:\n"
            f"- User Prompt: \"What's your favorite food?\"\n"
            f"  Character: Joey Tribbiani\n"
            f"  Dialogue: \"Joey doesn't share food!\"\n"
            f"  Response: \"Joey doesn't share food! But I do love a big meatball sub.\"\n\n"
            f"- User Prompt: \"Let's go for a vacation.\"\n"
            f"  Character: Ross Geller\n"
            f"  Dialogue: \"Spring vacation.\"\n"
            f"  Response: \"Spring vacation! I’ll pack my fossils!\"\n\n"
            f"User Prompt: {user_prompt}\n"
            f"Retrieved Dialogue: \"{retrieved_dialogue}\"\n"
            f"Character: {character}\n\n"
            f"Now, generate a response as the specified character, ensuring it aligns with the dialogue and the user's prompt."
        )

        payload = {"inputText": prompt}

        try:
            # Invoke the Titan Text G1 - Express model
            response = bedrock_client.invoke_model(
                modelId="amazon.titan-text-g1-express:0",
                contentType="application/json",
                accept="application/json",
                body=json.dumps(payload)
            )
            response_body = json.loads(response['body'].read())
            generated_response = response_body['results'][0]['outputText']

            # Post-process the response
            # 1. Remove metadata or prompt details
            if "User Prompt" in generated_response:
                generated_response = generated_response.split("User Prompt")[0].strip()

            # 2. Limit response length
            max_length = 150
            if len(generated_response) > max_length:
                generated_response = generated_response[:max_length].rsplit(" ", 1)[0] + "..."

            # 3. Ensure relevance: Fallback to retrieved dialogue if response is invalid
            if not generated_response or "irrelevant" in generated_response.lower():
                return retrieved_dialogue

            return generated_response

        except Exception as e:
            print(f"Error refining response: {e}")
            # Fallback to the retrieved dialogue in case of an error
            return retrieved_dialogue

        # Construct a controlled and guided prompt
        prompt = (
            f"You are an assistant generating responses for a Friends-themed chatbot. Your task is to:\n"
            f"1. Maintain the original tone and personality of the character.\n"
            f"2. Avoid adding irrelevant details or extra sentences.\n"
            f"3. Ensure the response aligns with the retrieved dialogue.\n"
            f"4. Make responses casual and consistent with the character's personality.\n\n"
            f"Examples:\n"
            f"- User Prompt: \"What's your favorite food?\"\n"
            f"  Character: Joey Tribbiani\n"
            f"  Dialogue: \"Joey doesn't share food!\"\n"
            f"  Response: \"Joey doesn't share food! But I do love a big meatball sub.\"\n\n"
            f"- User Prompt: \"I feel sad.\"\n"
            f"  Character: Chandler Bing\n"
            f"  Dialogue: \"I'm sorry you're feeling this way.\"\n"
            f"  Response: \"I'm sorry you're feeling this way. But remember, I can make you laugh. Want a joke?\"\n\n"
            f"User Prompt: {user_prompt}\n"
            f"Retrieved Dialogue: \"{retrieved_dialogue}\"\n"
            f"Character: {character}\n\n"
            f"Now, generate a response that refines the retrieved dialogue to better match the user's prompt while staying true to the character's tone and avoiding verbosity."
        )

        # Payload for the Bedrock API
        payload = {"inputText": prompt}

        try:
            # Invoke the Titan Text G1 - Express model
            response = bedrock_client.invoke_model(
                modelId="amazon.titan-text-express-v1",
                contentType="application/json",
                accept="application/json",
                body=json.dumps(payload)
            )
            response_body = json.loads(response['body'].read())
            generated_response = response_body['results'][0]['outputText']

            # Post-processing: Ensure the refined response adheres to guidelines
            # 1. Limit response length
            max_length = 150
            if len(generated_response) > max_length:
                generated_response = generated_response[:max_length] + "..."

            # 2. Ensure relevance: If response is missing or irrelevant, fallback to retrieved dialogue
            if not generated_response or "irrelevant" in generated_response.lower():  # Replace with advanced checks if needed
                return retrieved_dialogue

            return generated_response

        except Exception as e:
            print(f"Error refining response: {e}")
            # Fallback to the retrieved dialogue in case of an error
            return retrieved_dialogue

        # Construct a controlled prompt
        prompt = (
            f"You are an assistant generating responses for a Friends-themed chatbot. Your task is to:\n"
            f"1. Maintain the original tone and personality of the character.\n"
            f"2. Avoid adding irrelevant details or extra sentences.\n"
            f"3. Ensure the response aligns with the retrieved dialogue.\n\n"
            f"Here is the context:\n"
            f"- User Prompt: {user_prompt}\n"
            f"- Retrieved Dialogue: \"{retrieved_dialogue}\"\n"
            f"- Character: {character}\n\n"
            f"Now, generate a response that refines the retrieved dialogue to better match the user's prompt while staying true to the character's tone and avoiding verbosity."
        )

        # Payload for the Bedrock API
        payload = {"inputText": prompt}

        try:
            # Invoke the Titan Text G1 - Express model
            response = bedrock_client.invoke_model(
                modelId="amazon.titan-text-express-v1",
                contentType="application/json",
                accept="application/json",
                body=json.dumps(payload)
            )
            response_body = json.loads(response['body'].read())
            generated_response = response_body['results'][0]['outputText']

            # Post-processing: Ensure the refined response adheres to guidelines
            # 1. Limit response length
            max_length = 150
            generated_response = generated_response[:max_length]

            # 2. Ensure relevance by comparing with the retrieved dialogue
            # If generated response deviates significantly, fallback to the retrieved dialogue
            if not generated_response or "irrelevant" in generated_response.lower():  # Placeholder for advanced checks
                return retrieved_dialogue

            return generated_response

        except Exception as e:
            print(f"Error refining response: {e}")
            # Fallback to the retrieved dialogue in case of an error
            return retrieved_dialogue


    # Lambda function handler
    def lambda_handler(event, context):
        try:
            # Extract user input
            body = json.loads(event["body"])
            user_input = body["message"]

            # Generate embedding for user input
            user_embedding = generate_embedding(user_input)

            # Query OpenSearch for the most relevant dialogue
            result = query_opensearch(user_embedding)

            if not result:
                return {
                    "statusCode": 200,
                    "headers": {
                        "Content-Type": "application/json",
                        "Access-Control-Allow-Origin": "*"
                    },
                    "body": json.dumps({"character": "Unknown", "response": "I'm not sure how to respond to that!"})
                }

            # Refine the response
            # refined_response = f"{result['dialogue']}"
            refined_response = refine_response(user_input, result["character"], result["dialogue"])
            print(refined_response)

            # Return the refined response
            return {
                "statusCode": 200,
                "headers": {
                    "Content-Type": "application/json",
                    "Access-Control-Allow-Origin": "https://friendschat.cloudnirvana.in"
                },
                "body": json.dumps({
                    "character": result["character"],
                    "response": refined_response
                })
            }

        except Exception as e:
            return {
                "statusCode": 500,
                "headers": {
                    "Content-Type": "application/json",
                    "Access-Control-Allow-Origin": "https://friendschat.cloudnirvana.in"
                },
                "body": json.dumps({"error": str(e)})
            }

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Friends Chatbot</title>
        <style>
            #chat-container {
                width: 90%;
                max-width: 600px;
                margin: 20px auto;
                font-family: Arial, sans-serif;
            }
            #messages {
                height: 400px;
                overflow-y: auto;
                border: 1px solid #ccc;
                padding: 10px;
                border-radius: 5px;
                background-color: #f9f9f9;
            }
            .message {
                margin: 10px 0;
            }
            .user {
                text-align: right;
                color: blue;
            }
            .bot {
                text-align: left;
                color: green;
            }
            #input-container {
                display: flex;
                margin-top: 10px;
            }
            #user-input {
                flex: 1;
                padding: 10px;
                border: 1px solid #ccc;
                border-radius: 5px;
            }
            button {
                margin-left: 5px;
                padding: 10px 20px;
                background-color: #007bff;
                color: white;
                border: none;
                border-radius: 5px;
                cursor: pointer;
            }
            button:hover {
                background-color: #0056b3;
            }
        </style>
    </head>
    <body>
        <div id="chat-container">
            <div id="messages"></div>
            <div id="input-container">
                <input type="text" id="user-input" placeholder="Type your message...">
                <button onclick="sendMessage()">Send</button>
            </div>
        </div>
        <script>
            const apiEndpoint = "replace with you api gateway endpoint";

            function sendMessage() {
                const inputField = document.getElementById("user-input");
                const message = inputField.value.trim();
                if (!message) return;

                const messagesContainer = document.getElementById("messages");

                // Add user message
                const userMessage = document.createElement("div");
                userMessage.className = "message user";
                userMessage.textContent = message;
                messagesContainer.appendChild(userMessage);

                // Clear input
                inputField.value = "";

                // Send API request
                fetch(apiEndpoint, {
                    method: "POST",
                    headers: { "Content-Type": "application/json" },
                    body: JSON.stringify({ message }),
                })
                    .then((response) => response.json())
                    .then((data) => {
                        // Add bot response
                        const botMessage = document.createElement("div");
                        botMessage.className = "message bot";
                        botMessage.textContent = `${data.character}: ${data.response}`;
                        messagesContainer.appendChild(botMessage);

                        // Scroll to bottom
                        messagesContainer.scrollTop = messagesContainer.scrollHeight;
                    })
                    .catch((error) => {
                        console.error("Error:", error);
                        const botMessage = document.createElement("div");
                        botMessage.className = "message bot";
                        botMessage.textContent = "Error connecting to the chatbot.";
                        messagesContainer.appendChild(botMessage);
                    });
            }
        </script>
    </body>
    </html>