Desarrollando un Chatbot Personalizado con OpenAI

Creando un Chatbot Personalizado con OpenAI

Introducción

Los chatbots, que ofrecen soporte automatizado y experiencias personalizadas, han revolucionado la forma en que las empresas se conectan con sus clientes. Los recientes avances en inteligencia artificial (IA) han elevado el nivel de funcionalidad de los chatbots. Este detallado libro proporciona instrucciones detalladas sobre cómo crear un chatbot personalizado utilizando OpenAI, una plataforma líder en IA reconocida por sus potentes modelos de lenguaje.

Este artículo se publicó como parte del Data Science Blogathon.

¿Qué son los chatbots?

Los chatbots son programas informáticos que imitan las conversaciones humanas. Utilizan técnicas de procesamiento de lenguaje natural (NLP) para comprender lo que los usuarios están diciendo y responder de manera relevante y útil.

Gracias a la disponibilidad de conjuntos de datos masivos y excelentes algoritmos de aprendizaje automático, los chatbots se han vuelto cada vez más inteligentes en los últimos años. Estas capacidades permiten a los chatbots comprender mejor la intención del usuario y ofrecer respuestas que suenan más auténticas.

Algunos ejemplos concretos de cómo se utilizan actualmente los chatbots:

  • Los chatbots en el servicio al cliente pueden responder preguntas frecuentes y ayudar a los consumidores las 24 horas del día.
  • Los chatbots en marketing pueden ayudar a las empresas a calificar y generar clientes potenciales, así como responder consultas sobre productos o servicios.
  • Los chatbots en educación pueden proporcionar tutorías personalizadas y permitir a los estudiantes estudiar a su propio ritmo.
  • Los chatbots en el ámbito de la salud pueden proporcionar información sobre problemas de salud, responder preguntas sobre medicamentos y conectar a los pacientes con médicos u otros profesionales de la salud.

Introducción a OpenAI

OpenAI está a la vanguardia de la investigación y desarrollo de inteligencia artificial. Ha liderado la creación de modelos de lenguaje de vanguardia que destacan en la interpretación y creación de lenguaje natural.

OpenAI proporciona modelos de lenguaje sofisticados como GPT-4, GPT-3, Text-davinci que se utilizan ampliamente para actividades de procesamiento de lenguaje natural como la construcción de chatbots y muchas más.

Ventajas de utilizar chatbots

Antes de adentrarnos en la codificación e implementación, primero comprendamos algunos beneficios de utilizar chatbots:

  1. Disponibilidad 24/7: Los chatbots pueden ofrecer asistencia a los usuarios las 24 horas del día, los 7 días de la semana, eliminando las limitaciones de los representantes de servicio al cliente humanos y permitiendo a las empresas satisfacer las demandas de sus clientes en cualquier momento.
  2. Mejora del servicio al cliente: Los chatbots pueden responder rápidamente a preguntas frecuentes proporcionando respuestas precisas y rápidas. Esto mejora la calidad general del servicio al cliente.
  3. Ahorro de costos: Las empresas pueden ahorrar mucho dinero a largo plazo automatizando las tareas de soporte al cliente y reduciendo la necesidad de un gran equipo de soporte.
  4. Aumento de la eficiencia: Los chatbots pueden gestionar varias conversaciones al mismo tiempo, garantizando respuestas rápidas y reduciendo los tiempos de espera de los usuarios.
  5. Recopilación y análisis de datos: Los chatbots pueden recopilar información útil de las interacciones de los usuarios, brindando a las empresas una comprensión de las preferencias, necesidades y puntos problemáticos de los clientes. Utilizando estos datos, se pueden mejorar los productos y servicios.

Una vez que conocemos las ventajas de los chatbots, pasemos a desglosar paso a paso el código necesario para construir un chatbot personalizado utilizando OpenAI.

Pasos

Paso 1: Importar las bibliotecas necesarias

Necesitamos importar las bibliotecas necesarias. En el código proporcionado, podemos ver las siguientes declaraciones de importación:

!pip install langchain
!pip install faiss-cpu
!pip install openai
!pip install llama_index

# o puedes usar

%pip install langchain
%pip install faiss-cpu
%pip install openai
%pip install llama_index

Asegúrate de tener estas bibliotecas instaladas antes de continuar.

Paso 2: Configurar la clave de la API

Para interactuar con la API de OpenAI, necesitas una clave de API. En el código proporcionado, hay un marcador de posición que indica dónde agregar tu clave de API:

Para encontrar tu clave de API, ve al sitio web de OpenAI y crea una nueva clave de OpenAI.

import os 
os.environ["OPENAI_API_KEY"] = 'Agrega tu clave de API aquí'

Reemplaza ‘Agrega tu clave de API aquí’ con tu clave de API real obtenida de OpenAI.

Paso 3: Crear e indexar la base de conocimientos

En este paso, crearemos e indexaremos la base de conocimientos a la que el chatbot se referirá para responder las consultas de los usuarios. El código proporcionado demuestra dos enfoques: uno para cargar documentos desde un directorio y otro para cargar un índice existente. Vamos a enfocarnos en el primer enfoque.

from llama_index import GPTVectorStoreIndex, SimpleDirectoryReader
documents = SimpleDirectoryReader('/Users/tarakram/Documents/Chatbot/data').load_data()
print(documents)

Utiliza la clase SimpleDirectoryReader para cargar los documentos desde un directorio específico.

Reemplaza ‘/Users/tarakram/Documents/Chatbot/data’ con la ruta de tu directorio que contiene los documentos de la base de conocimientos. La función load_data() carga los documentos y los devuelve.

Después de cargar los documentos, necesitamos crear un índice utilizando la clase GPTVectorStoreIndex:

index = GPTVectorStoreIndex.from_documents(documents)

Este paso crea el índice utilizando los documentos cargados.

Paso 4: Persistir el índice

Para evitar la necesidad de reconstruir el índice cada vez que se ejecuta el código, podemos persistir el índice en el disco. En el código proporcionado, se utiliza la siguiente línea para guardar el índice:

# Guardar el índice
index.storage_context.persist('/Users/tarakram/Documents/Chatbot')

Asegúrate de reemplazar ‘/Users/tarakram/Documents/Chatbot’ con la ruta del directorio deseado donde deseas guardar el índice.

Al persistir el índice, podemos cargarlo en ejecuciones posteriores sin incurrir en costos adicionales de tokens.

Paso 5: Cargar el índice

En caso de que desees cargar el índice previamente guardado, puedes utilizar el siguiente código:

from llama_index import StorageContext, load_index_from_storage

# reconstruir el contexto de almacenamiento
storage_context = StorageContext.from_defaults
                  (persist_dir='/Users/tarakram/Documents/Chatbot/index')
# cargar el índice
index = load_index_from_storage(storage_context)

Asegúrate de actualizar ‘/Users/tarakram/Documents/Chatbot/index’ con la ruta correcta del directorio donde guardaste el índice.

Paso 6: Crear la clase Chatbot

Ahora, pasemos a crear la clase de chatbot real que interactúa con el usuario y genera respuestas. Aquí está el código proporcionado:

# Chat Bot

import openai
import json

class Chatbot:
    def __init__(self, api_key, index):
        self.index = index
        openai.api_key = api_key
        self.chat_history = []

    def generate_response(self, user_input):
        prompt = "\n".join([f"{message['role']}: {message['content']}" 
                           for message in self.chat_history[-5:]])
        prompt += f"\nUser: {user_input}"
        query_engine = index.as_query_engine()
        response = query_engine.query(user_input)

        message = {"role": "assistant", "content": response.response}
        self.chat_history.append({"role": "user", "content": user_input})
        self.chat_history.append(message)
        return message

    def load_chat_history(self, filename):
        try:
            with open(filename, 'r') as f:
                self.chat_history = json.load(f)
        except FileNotFoundError:
            pass

    def save_chat_history(self, filename):
        with open(filename, 'w') as f:
            json.dump(self.chat_history, f)

La clase Chatbot tiene un método __init__ para inicializar la instancia del chatbot con la clave de API y el índice proporcionados.

El método generate_response recibe la entrada del usuario, genera una respuesta utilizando el índice y la API de OpenAI, y actualiza el historial del chat.

Los métodos load_chat_history y save_chat_history se utilizan para cargar y guardar el historial del chat, respectivamente.

Paso 7: Interactuar con el Chatbot

El último paso es interactuar con el chatbot. Aquí está el fragmento de código proporcionado que muestra cómo utilizar el chatbot:

bot = Chatbot("Agrega aquí tu clave de API", index=index)
bot.load_chat_history("chat_history.json")

while True:
    user_input = input("Tú: ")
    if user_input.lower() in ["adiós", "chao"]:
        print("Bot: ¡Adiós!")
        bot.save_chat_history("chat_history.json")
        break
    response = bot.generate_response(user_input)
    print(f"Bot: {response['content']}")

Para utilizar el chatbot, crea una instancia de la clase Chatbot pasando tu clave de API de OpenAI y el índice cargado.

Reemplaza “Agrega aquí tu clave de API” por tu clave de API real. El método load_chat_history se utiliza para cargar el historial de chat desde un archivo (reemplaza “chat_history.json” con la ruta real del archivo).

Luego, se utiliza un bucle while para obtener repetidamente la entrada del usuario y generar respuestas hasta que el usuario ingrese “adiós” o “chao”.

El método save_chat_history se utiliza para guardar el historial de chat en un archivo.

Paso 8: Crear una aplicación web utilizando Streamlit

El código proporcionado también incluye una aplicación web construida utilizando Streamlit, que permite a los usuarios interactuar con el chatbot a través de una interfaz de usuario. Aquí está el código proporcionado:

import streamlit as st
import json
import os

from llama_index import StorageContext, load_index_from_storage

os.environ["OPENAI_API_KEY"] = 'Agrega aquí tu clave de API'

# reconstruir el contexto de almacenamiento
storage_context = StorageContext.from_defaults
                 (persist_dir='/Users/tarakram/Documents/Chatbot/index')
# cargar el índice
index = load_index_from_storage(storage_context)

# Crear el chatbot
# Chat Bot 

import openai
import json

class Chatbot:
    def __init__(self, api_key, index, user_id):
        self.index = index
        openai.api_key = api_key
        self.user_id = user_id
        self.chat_history = []
        self.filename = f"{self.user_id}_chat_history.json"

    def generate_response(self, user_input):
        prompt = "\n".join([f"{message['role']}: {message['content']}" 
                           for message in self.chat_history[-5:]])
        prompt += f"\nUser: {user_input}"
        query_engine = index.as_query_engine()
        response = query_engine.query(user_input)

        message = {"role": "assistant", "content": response.response}
        self.chat_history.append({"role": "user", "content": user_input})
        self.chat_history.append(message)
        return message
    
    def load_chat_history(self):
        try:
            with open(self.filename, 'r') as f:
                self.chat_history = json.load(f)
        except FileNotFoundError:
            pass

    def save_chat_history(self):
        with open(self.filename, 'w') as f:
            json.dump(self.chat_history, f)
            
# Aplicación Streamlit
def main():
    st.title("Chatbot")

    # ID de usuario
    user_id = st.text_input("Tu nombre:")
    
    # Comprobar si se proporciona el ID de usuario
    if user_id:
        # Crear instancia del chatbot para el usuario
        bot = Chatbot("Agrega aquí tu clave de API", index, user_id)

        # Cargar historial de chat
        bot.load_chat_history()

        # Mostrar historial de chat
        for message in bot.chat_history[-6:]:
            st.write(f"{message['role']}: {message['content']}")

        # Entrada del usuario
        user_input = st.text_input("Escribe tus preguntas aquí :) - ")

        # Generar respuesta
        if user_input:
            if user_input.lower() in ["adiós", "chao"]:
                bot_response = "¡Adiós!"
            else:
                bot_response = bot.generate_response(user_input)
                bot_response_content = bot_response['content']
                st.write(f"{user_id}: {user_input}")
                st.write(f"Bot: {bot_response_content}")
                bot.save_chat_history()
                bot.chat_history.append 
                         ({"role": "user", "content": user_input})
                bot.chat_history.append
                       ({"role": "assistant", "content": bot_response_content})

if __name__ == "__main__":
    main()

Para ejecutar la aplicación web, asegúrate de tener Streamlit instalado (pip install streamlit).

Sustituye “Agrega tu clave de API aquí” con tu clave de API de OpenAI actual.

Luego, puedes ejecutar la aplicación usando el comando streamlit run app.py.

La aplicación web se abrirá en tu navegador y podrás interactuar con el chatbot a través de la interfaz de usuario proporcionada.

Mejorando el rendimiento de los chatbots

Considera las siguientes formas de mejorar el rendimiento del chatbot:

  • Ajuste fino: Mejora continuamente la comprensión del modelo del chatbot y sus habilidades para generar respuestas ajustándolo con más datos.
  • Integración de comentarios de los usuarios: Integra bucles de retroalimentación de los usuarios para recopilar información y mejorar el rendimiento del chatbot basado en interacciones reales de los usuarios.
  • Técnicas híbridas: Investiga técnicas híbridas que combinen sistemas basados en reglas con modelos de IA para manejar de manera más efectiva circunstancias complicadas.
  • Información específica del dominio: Incluye información y datos específicos del dominio para aumentar la experiencia y precisión del chatbot en ciertas áreas temáticas.

Conclusión

¡Felicitaciones! Ahora has aprendido cómo crear un chatbot personalizado usando OpenAI. En esta guía, vimos cómo usar OpenAI para crear un chatbot a medida. Cubrimos los pasos involucrados en la configuración de las bibliotecas necesarias, la obtención de una clave de API, la creación e indexación de una base de conocimientos, la creación de la clase del chatbot y la interacción con él.

También exploraste la opción de crear una aplicación web usando Streamlit para una interfaz de usuario amigable. La creación de un chatbot es un proceso iterativo y la refinación constante es esencial para mejorar su funcionalidad. Puedes diseñar chatbots que brinden experiencias de usuario sobresalientes y soporte significativo aprovechando el poder de OpenAI y manteniéndote actualizado sobre los últimos avances en IA. Experimenta con diferentes indicaciones, datos de entrenamiento y técnicas de ajuste fino para crear un chatbot adaptado a tus necesidades específicas. Las posibilidades son infinitas y OpenAI ofrece una plataforma potente para explorar y aprovechar el potencial de la tecnología de chatbots.

Puntos clave

  • Configurar las bibliotecas necesarias, obtener una clave de API, generar e indexar una base de conocimientos e implementar la clase del chatbot son todos pasos en el proceso de construcción de un chatbot personalizado utilizando OpenAI.
  • Los chatbots son programas de computadora que imitan las interacciones humanas al proporcionar ayuda y responder preguntas en lenguaje natural.
  • La recopilación de datos es esencial para entrenar un chatbot eficiente y implica adquirir conjuntos de datos relevantes y variados de fuentes confiables.
  • Las aplicaciones de IA conversacional utilizando el modelo de lenguaje GPT-3.5 de OpenAI, una herramienta potente para el procesamiento de lenguaje natural.
  • El uso de herramientas como la biblioteca Llamas para indexar y buscar una base de conocimientos puede mejorar considerablemente la capacidad del chatbot para recuperar datos pertinentes.
  • Streamlit ofrece un marco práctico para crear aplicaciones web que permiten a los usuarios comunicarse con el chatbot a través de una interfaz de usuario intuitiva.

Puedes acceder al código en Github: Enlace

Conéctate conmigo en LinkedIn: Enlace

Preguntas frecuentes

Los medios mostrados en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor.

Las 10 mejores herramientas de Aprendizaje ...
Aprovechando las funciones analíticas en SQ...
Construye un detector de correo no deseado ...
Cómo creé una animación de las incrustacion...
La huella de carbono de GPT-4
La narrativa de datos – el arte de co...
IA

IA

Explora el mundo de la Inteligencia Artificial y su potencial transformador