En este tutorial, te guiaré a través de la creación de un chatbot personalizado utilizando la potente API de OpenAI GPT-3.5 Turbo y AWS Lambda. Este chatbot puede ser adaptado para responder preguntas sobre un tema específico que tú elijas. Te proporcionaré el código completo junto con explicaciones detalladas para que puedas implementarlo fácilmente.

Requisitos Previos

Antes de comenzar, asegúrate de tener lo siguiente:

1. Una cuenta de AWS.
2. Tu API Key de OpenAI GPT-3.5 Turbo. Puedes obtenerla registrándote en OpenAI.

Paso 1: Configurar la API de OpenAI

Asegúrate de obtener tu API Key de OpenAI y configúrala en tu entorno. Esta clave se utilizará para acceder a la API de GPT-3.5 Turb

Paso 2: Crear una Función Lambda en AWS

1. Accede al panel de AWS Lambda y crea una nueva función Lambda.
2. Elige un nombre y configura las opciones adecuadas, como el lenguaje de ejecución y la asignación de memoria.
3. Agrega un gatillo (trigger) para invocar la función. Puedes utilizar una API Gateway o cualquier otro método de tu elecci

Paso 3: Código Python

A continuación, encontrarás el código completo del chatbot junto con comentarios explicativos:

import openai
from datetime import datetime
from json import dumps, loads
import os
import json

# Configura la API Key de OpenAI
openai.api_key = os.environ["OPENAI_API_KEY"]


class Chatbot:
    # Máximo número de preguntas antes de invitar a llamar a un agente.
    MAX_RESPONSES = 5
    # Máximo número de peticiones a GPT antes de responder con un mensaje genérico
    MAX_GPT_REQUESTS = 15
    # Mensaje genérico después de alcanzar el límite de peticiones a GPT
    GENERIC_MESSAGE = "Parece que no tengo las respuestas que buscas, te recomiendo llamar al {}. Fue un placer haber intentado responder tus dudas."
    # Número de teléfono de contacto (opcional) para comunicarse con el cliente
    TELEPHONE = "Añade un número de teléfono de contacto aquí"

    def create_or_get_chat(self, user_id, name, email, phone):
        """
        Crea o recupera una conversación de chat en la base de datos.

        :param user_id: ID del usuario
        :param name: Nombre del usuario
        :param email: Correo electrónico del usuario
        :param phone: Número de teléfono del usuario
        :return: Objeto ChatHistory
        """
        chat = ChatbotTable.get(ID=user_id)
        if chat is None:
            chat = ChatbotTable(
                ID=user_id,
                name=name,
                email=email,
                phone=phone,
                history="",
                response_count=0,
                last_updated=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            )
            chat.save()
        return chat

    def get_response(self, user_id, name, email, phone, message):
        """
        Genera una respuesta del chatbot y gestiona la lógica de la conversación.

        :param user_id: ID del usuario
        :param name: Nombre del usuario
        :param email: Correo electrónico del usuario
        :param phone: Número de teléfono del usuario
        :param message: Mensaje del usuario
        :return: Respuesta del chatbot
        """
        try:
            chat = self.create_or_get_chat(user_id, name, email, phone)
            current_date = datetime.now().strftime("%d de %B de %Y")
            chatLongCount = chat.response_count
            should_call = chatLongCount >= self.MAX_RESPONSES

            if chatLongCount >= self.MAX_GPT_REQUESTS:
                return self.GENERIC_MESSAGE.format(self.TELEPHONE)

            if chat.history == "":
                content = f"Aquí puedes proporcionar un mensaje de introducción general sobre el chatbot y su propósito."
                history_messages = [{"role": "system", "content": content}]
            else:
                history_messages = loads(chat.history)

            history_messages.append({"role": "user", "content": message})

            if should_call:
                content = (
                    f"Continúa respondiendo a las preguntas del usuario, pero en cada respuesta, "
                    f"invita amablemente a una llamada telefónica al {self.TELEPHONE} para una asistencia más detallada. "
                    f"Si el usuario no tiene más dudas, intenta cerrar la conversación de manera amable."
                )
                history_messages.append({"role": "system", "content": content})

            response = self.call_openai(history_messages)

            history_messages.append({"role": "assistant", "content": response})

            chat.history = dumps(history_messages)
            chat.response_count += 1
            chat.last_updated = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            chat.save()

            return response
        except Exception as e:
            print("Entro en una excepción {}".format(e))

    def call_openai(self, messages):
        """
        Llama a la API de OpenAI para generar una respuesta basada en los mensajes proporcionados.

        :param messages: Lista de mensajes en la conversación
        :return: Respuesta generada por OpenAI
        """
        completion = openai.ChatCompletion.create(
            model="gpt-3.5-turbo", messages=messages
        )
        return completion.choices[0].message["content"].strip()


def lambda_handler(event, context):
    try:
        user_data_post = event.get("bodyjson")
        # DATOS QUE VIENEN DEL POST
        chatbot = Chatbot()
        user_id = user_data_post.get("uuid")
        name = user_data_post.get("name")
        email = user_data_post.get("email")
        phone = user_data_post.get("tel")
        message = user_data_post.get("message")
        response = chatbot.get_response(user_id, name, email, phone, message)
        if response:
            return {"statusCode": 200, "body": response}
        else:
            raise Exception("No se obtuvo una respuesta válida")
    except Exception as e:
        return {
            "statusCode": 500,
            "body": json.dumps(
                {"error": "Error al intentar interactuar con el chat: " + str(e)}
            ),
        }

Este es el código completo del chatbot junto con comentarios para ayudarte a entender mejor su funcionamiento. Asegúrate de personalizar las partes necesarias y de configurar correctamente las variables de entorno en AWS Lambda. ¡Espero que te sea útil!

Si deseas una atención personalizada o ayuda para implementar el código puedes ponerte en contacto con Asimov Ingeniería.