🤖 Tutorial: cómo crear su propio chatbot con la API de GPT — guía completa paso a paso para principiantes

¿Alguna vez ha querido crear un asistente virtual capaz de responder preguntas, atender clientes o explicar los productos de su negocio?

Gracias a la API de OpenAI, actualmente es posible construir un chatbot funcional sin entrenar un modelo de Inteligencia Artificial desde cero.

Puede utilizarlo para:

• responder preguntas frecuentes;
• orientar a los visitantes de una página web;
• explicar productos o servicios;
• generar recomendaciones;
• asistir a estudiantes;
• organizar información;
• automatizar parte de la atención al cliente.

En este tutorial crearemos un chatbot básico con Python, utilizando el SDK oficial de OpenAI y la Responses API, que es la interfaz recomendada en la documentación actual para enviar solicitudes directas a los modelos.  

💡 Objetivo del tutorial: construir un chatbot que reciba mensajes desde una página web, los envíe de forma segura a OpenAI y muestre las respuestas al usuario.

🧠 ¿Qué es la API de GPT?

Una API es un mecanismo que permite que dos programas se comuniquen entre sí.

En este caso:

1. El usuario escribe una pregunta.
2. Su aplicación recibe el mensaje.
3. El servidor envía la pregunta a la API de OpenAI.
4. El modelo genera una respuesta.
5. Su aplicación muestra esa respuesta.

El chatbot no ejecuta ChatGPT dentro de su página. En su lugar, su aplicación envía solicitudes a un modelo mediante la API y recibe los resultados.

La API de OpenAI puede utilizarse para generar texto, analizar imágenes, crear agentes y desarrollar otros tipos de aplicaciones inteligentes.  

🔄 ¿Cómo funcionará nuestro chatbot?

La arquitectura básica será la siguiente:

Usuario
   ↓
Página web
   ↓
Servidor en Python
   ↓
API de OpenAI
   ↓
Respuesta del modelo
   ↓
Página web

Es importante que la página web no se conecte directamente a OpenAI usando una clave secreta visible.

El navegador debe enviar el mensaje a su servidor. Después, el servidor utiliza la clave para comunicarse con OpenAI.

Así se evita exponer la credencial privada a cualquier visitante.

🧰 ¿Qué necesita antes de comenzar?

Para seguir este tutorial necesitará:

• una cuenta en la plataforma de OpenAI;
• una clave de API;
• Python instalado;
• un editor de código;
• conexión a Internet;
• conocimientos básicos para crear y guardar archivos.

Puede utilizar editores como Visual Studio Code, PyCharm o cualquier editor de texto que permita trabajar con archivos de código.

🔑 Paso 1. Crear una clave de API

La clave de API funciona como una credencial privada que permite que su aplicación se conecte con OpenAI.

Debe crearla desde el panel de la plataforma y guardarla en un lugar seguro. La documentación recomienda almacenarla como una variable de entorno, en lugar de escribirla directamente dentro del código. Los SDK oficiales pueden leer automáticamente la variable OPENAI_API_KEY.  

Una clave puede verse aproximadamente así:

sk-proj-xxxxxxxxxxxxxxxx

⚠️ Nunca publique su clave de API.

No debe:

• compartirla en redes sociales;
• colocarla en una captura de pantalla;
• subirla a GitHub;
• escribirla en el JavaScript público de su página;
• enviarla dentro de un artículo o tutorial;
• guardarla directamente en un repositorio.

Si sospecha que alguien tuvo acceso a ella, debe revocarla y crear una nueva.

📁 Paso 2. Crear la carpeta del proyecto

Cree una nueva carpeta llamada:

mi-chatbot

Dentro de ella tendremos esta estructura:

mi-chatbot/
│
├── app.py
├── requirements.txt
├── .env
├── .gitignore
│
└── templates/
    └── index.html

Abra una terminal dentro de la carpeta.

En macOS o Linux puede usar:

cd ruta/mi-chatbot

En Windows puede abrir la carpeta en Visual Studio Code y utilizar la terminal integrada.

🐍 Paso 3. Crear un entorno virtual

Un entorno virtual mantiene las dependencias de este proyecto separadas de otros programas instalados en su computadora.

Créelo con:

python -m venv .venv

En algunas computadoras deberá escribir:

python3 -m venv .venv

🍎 Activarlo en macOS o Linux

source .venv/bin/activate

🪟 Activarlo en Windows PowerShell

.venv\Scripts\Activate.ps1

Cuando esté activado, normalmente verá algo parecido a esto al inicio de la terminal:

(.venv)

📦 Paso 4. Instalar las dependencias

Para este proyecto utilizaremos:

• openai: SDK oficial de OpenAI;
• flask: servidor web ligero;
• python-dotenv: lectura de variables desde un archivo .env.

Instálelas con:

pip install openai flask python-dotenv

El SDK oficial para Python se instala mediante pip install openai, según la guía de inicio rápido de OpenAI.  

Después cree el archivo requirements.txt con este contenido:

openai
flask
python-dotenv

🔐 Paso 5. Guardar la clave de forma segura

Cree el archivo:

.env

Añada esta línea:

OPENAI_API_KEY=coloque_aqui_su_clave

Ejemplo:

OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxx

No utilice comillas ni espacios alrededor del signo igual.

Ahora cree un archivo llamado:

.gitignore

Y escriba:

.env
.venv/
__pycache__/

Esto reduce el riesgo de subir accidentalmente su clave o el entorno virtual a un repositorio.

🔒 Regla fundamental: la clave solo debe utilizarse en el servidor. Nunca debe aparecer dentro del archivo HTML o en el JavaScript enviado al navegador.

⚡ Paso 6. Probar su primera solicitud

Antes de construir la interfaz, comprobaremos que la API funciona.

Cree temporalmente un archivo llamado:

prueba.py

Añada este código:

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI()

try:
    response = client.responses.create(
        model="gpt-5.6",
        input="Explique qué es la Inteligencia Artificial en dos oraciones.",
    )

    print(response.output_text)

except Exception as error:
    print(f"Ocurrió un error: {error}")

Ejecútelo:

python prueba.py

La estructura utilizada sigue el patrón actual del SDK: crear un cliente, llamar a client.responses.create() y leer el texto mediante response.output_text.  

Si todo funciona, debería aparecer una explicación en la terminal.

🧩 ¿Qué significa cada parte del código?

📥 Importar las herramientas

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv carga los valores del archivo .env.

OpenAI crea el cliente que se comunicará con la API.

🔑 Cargar la clave

load_dotenv()

Esta instrucción carga la variable:

OPENAI_API_KEY

Después, el SDK puede detectarla automáticamente.

🔌 Crear el cliente

client = OpenAI()

Este objeto se utilizará para enviar solicitudes.

🧠 Elegir el modelo

model="gpt-5.6"

El modelo es el sistema que procesará la solicitud.

Los modelos disponibles, sus capacidades y sus precios pueden cambiar. Por eso, antes de publicar o ejecutar este tutorial, conviene revisar el catálogo oficial y sustituir el nombre si fuera necesario.

💬 Enviar el mensaje

input="Explique qué es la Inteligencia Artificial en dos oraciones."

Este es el contenido que recibirá el modelo.

📤 Obtener la respuesta

print(response.output_text)

output_text reúne el texto generado para facilitar su lectura.

🌐 Paso 7. Crear el servidor del chatbot

Ahora sustituiremos la prueba sencilla por una aplicación web.

Cree el archivo:

app.py

Añada el siguiente código:

import os
from typing import Any

from dotenv import load_dotenv
from flask import Flask, jsonify, render_template, request
from openai import OpenAI

load_dotenv()

app = Flask(__name__)

api_key = os.getenv("OPENAI_API_KEY")

if not api_key:
    raise RuntimeError(
        "No se encontró OPENAI_API_KEY. "
        "Revise que el archivo .env exista y contenga una clave válida."
    )

client = OpenAI(api_key=api_key)

SYSTEM_INSTRUCTIONS = """
Usted es el asistente virtual de Mi Mundo con IA.

Su objetivo es explicar temas de Inteligencia Artificial de forma:
- clara;
- precisa;
- amigable;
- comprensible para principiantes.

Responda en español.
No invente datos.
Cuando no tenga información suficiente, indíquelo claramente.
Utilice respuestas breves, salvo que el usuario pida más detalle.
""".strip()


@app.get("/")
def home() -> str:
    """Muestra la interfaz principal del chatbot."""
    return render_template("index.html")


@app.post("/chat")
def chat() -> tuple[Any, int] | Any:
    """Recibe un mensaje y devuelve la respuesta del modelo."""
    data = request.get_json(silent=True) or {}
    message = str(data.get("message", "")).strip()

    if not message:
        return jsonify({"error": "Debe escribir un mensaje."}), 400

    if len(message) > 2000:
        return jsonify(
            {"error": "El mensaje supera el límite permitido."}
        ), 400

    try:
        response = client.responses.create(
            model="gpt-5.6",
            instructions=SYSTEM_INSTRUCTIONS,
            input=message,
        )

        answer = response.output_text.strip()

        if not answer:
            answer = "No fue posible generar una respuesta."

        return jsonify({"answer": answer})

    except Exception as error:
        app.logger.exception("Error al consultar la API: %s", error)

        return jsonify(
            {
                "error": (
                    "No fue posible procesar la solicitud. "
                    "Inténtelo nuevamente más tarde."
                )
            }
        ), 500


if __name__ == "__main__":
    app.run(debug=True)

🎭 ¿Para qué sirven las instrucciones del sistema?

Esta parte define la función y el comportamiento general del chatbot:

SYSTEM_INSTRUCTIONS = """
Usted es el asistente virtual de Mi Mundo con IA.
...
"""

Puede personalizarla para crear distintos tipos de asistentes.

Por ejemplo:

🛒 Asistente de ventas

Usted es un asesor de ventas de una tienda de tecnología.
Explique los productos con claridad.
No invente precios ni disponibilidad.
Cuando falte información, invite al usuario a contactar a un asesor humano.

🎓 Tutor educativo

Usted es un tutor para estudiantes de secundaria.
Explique cada tema paso a paso.
No entregue únicamente la respuesta: ayude al estudiante a comprenderla.

🐾 Asistente veterinario informativo

Usted ofrece información general sobre cuidados de mascotas.
No emita diagnósticos.
Ante síntomas graves, recomiende acudir a un profesional veterinario.

Las instrucciones son esenciales porque establecen:

• el rol;
• el tono;
• los límites;
• el formato;
• el público;
• el comportamiento esperado.

🎨 Paso 8. Crear la interfaz del chatbot

Dentro de la carpeta templates, cree:

index.html

Añada este código:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">

    <meta
        name="viewport"
        content="width=device-width, initial-scale=1.0"
    >

    <title>Mi Chatbot con IA</title>

    <style>
        * {
            box-sizing: border-box;
        }

        body {
            margin: 0;
            min-height: 100vh;
            font-family: Arial, Helvetica, sans-serif;
            background: #f3f5f9;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }

        .chat-container {
            width: 100%;
            max-width: 720px;
            height: 80vh;
            min-height: 520px;
            background: #ffffff;
            border-radius: 18px;
            box-shadow: 0 12px 35px rgba(0, 0, 0, 0.12);
            display: flex;
            flex-direction: column;
            overflow: hidden;
        }

        .chat-header {
            padding: 20px;
            background: #172554;
            color: #ffffff;
        }

        .chat-header h1 {
            margin: 0 0 6px;
            font-size: 1.35rem;
        }

        .chat-header p {
            margin: 0;
            opacity: 0.85;
            font-size: 0.92rem;
        }

        .messages {
            flex: 1;
            overflow-y: auto;
            padding: 20px;
            display: flex;
            flex-direction: column;
            gap: 14px;
        }

        .message {
            max-width: 82%;
            padding: 12px 15px;
            border-radius: 16px;
            line-height: 1.5;
            white-space: pre-wrap;
            overflow-wrap: anywhere;
        }

        .assistant {
            align-self: flex-start;
            background: #e9eef8;
            color: #172554;
            border-bottom-left-radius: 5px;
        }

        .user {
            align-self: flex-end;
            background: #172554;
            color: #ffffff;
            border-bottom-right-radius: 5px;
        }

        .error {
            align-self: center;
            background: #fee2e2;
            color: #991b1b;
        }

        .typing {
            opacity: 0.7;
            font-style: italic;
        }

        .chat-form {
            display: flex;
            gap: 10px;
            padding: 16px;
            border-top: 1px solid #e5e7eb;
            background: #ffffff;
        }

        .chat-form input {
            flex: 1;
            min-width: 0;
            padding: 13px 15px;
            border: 1px solid #cbd5e1;
            border-radius: 12px;
            font-size: 1rem;
        }

        .chat-form input:focus {
            outline: 2px solid #93c5fd;
            border-color: #2563eb;
        }

        .chat-form button {
            padding: 12px 20px;
            border: 0;
            border-radius: 12px;
            background: #2563eb;
            color: #ffffff;
            font-weight: 700;
            cursor: pointer;
        }

        .chat-form button:disabled {
            opacity: 0.55;
            cursor: not-allowed;
        }
    </style>
</head>

<body>
    <main class="chat-container">
        <header class="chat-header">
            <h1>🤖 Asistente de Mi Mundo con IA</h1>
            <p>Pregunte sobre Inteligencia Artificial.</p>
        </header>

        <section
            id="messages"
            class="messages"
            aria-live="polite"
        >
            <div class="message assistant">
                ¡Hola! ¿Qué desea aprender hoy sobre Inteligencia Artificial?
            </div>
        </section>

        <form id="chat-form" class="chat-form">
            <input
                id="message-input"
                type="text"
                placeholder="Escriba su mensaje..."
                maxlength="2000"
                autocomplete="off"
                required
            >

            <button id="send-button" type="submit">
                Enviar
            </button>
        </form>
    </main>

    <script>
        const form = document.getElementById("chat-form");
        const input = document.getElementById("message-input");
        const messages = document.getElementById("messages");
        const button = document.getElementById("send-button");

        function addMessage(text, type) {
            const element = document.createElement("div");
            element.className = `message ${type}`;
            element.textContent = text;
            messages.appendChild(element);
            messages.scrollTop = messages.scrollHeight;
            return element;
        }

        form.addEventListener("submit", async (event) => {
            event.preventDefault();

            const message = input.value.trim();

            if (!message) {
                return;
            }

            addMessage(message, "user");
            input.value = "";
            button.disabled = true;

            const typing = addMessage(
                "El asistente está escribiendo...",
                "assistant typing"
            );

            try {
                const response = await fetch("/chat", {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json"
                    },
                    body: JSON.stringify({ message })
                });

                const data = await response.json();
                typing.remove();

                if (!response.ok) {
                    throw new Error(
                        data.error || "La solicitud no pudo completarse."
                    );
                }

                addMessage(data.answer, "assistant");

            } catch (error) {
                typing.remove();
                addMessage(
                    error.message || "Se produjo un error inesperado.",
                    "error"
                );

            } finally {
                button.disabled = false;
                input.focus();
            }
        });
    </script>
</body>
</html>

▶️ Paso 9. Ejecutar el chatbot

Desde la terminal, dentro de la carpeta del proyecto, ejecute:

python app.py

Debería aparecer un mensaje similar a:

Running on http://127.0.0.1:5000

Abra esa dirección en su navegador.

Ya podrá escribir mensajes y recibir respuestas del modelo.

🎉 Ha creado su primer chatbot con la API de GPT.

🧠 Paso 10. Agregar memoria a la conversación

El chatbot anterior responde cada pregunta por separado.

Esto significa que puede ocurrir lo siguiente:

Usuario:

Mi nombre es Alexander.

Chatbot:

Mucho gusto, Alexander.

Usuario:

¿Cómo me llamo?

Si enviamos únicamente la segunda pregunta, el modelo no recibirá la primera y no podrá recordarla.

Cada solicitud de generación es independiente, salvo que su aplicación conserve y vuelva a proporcionar el contexto o utilice un mecanismo de estado conversacional. OpenAI ofrece distintas formas de conservar información entre turnos.  

Para un tutorial inicial, almacenaremos el historial temporalmente en el navegador y lo enviaremos al servidor.

📝 Modificar el JavaScript

Antes del evento submit, agregue:

const conversation = [];

Dentro del evento, después de validar el mensaje, agregue:

conversation.push({
    role: "user",
    content: message
});

Cambie el cuerpo de la solicitud:

body: JSON.stringify({
    messages: conversation
})

Después de recibir la respuesta, agregue:

conversation.push({
    role: "assistant",
    content: data.answer
});

La sección principal quedaría así:

const conversation = [];

form.addEventListener("submit", async (event) => {
    event.preventDefault();

    const message = input.value.trim();

    if (!message) {
        return;
    }

    addMessage(message, "user");

    conversation.push({
        role: "user",
        content: message
    });

    input.value = "";
    button.disabled = true;

    const typing = addMessage(
        "El asistente está escribiendo...",
        "assistant typing"
    );

    try {
        const response = await fetch("/chat", {
            method: "POST",
            headers: {
                "Content-Type": "application/json"
            },
            body: JSON.stringify({
                messages: conversation
            })
        });

        const data = await response.json();
        typing.remove();

        if (!response.ok) {
            throw new Error(
                data.error || "La solicitud no pudo completarse."
            );
        }

        conversation.push({
            role: "assistant",
            content: data.answer
        });

        addMessage(data.answer, "assistant");

    } catch (error) {
        typing.remove();

        addMessage(
            error.message || "Se produjo un error inesperado.",
            "error"
        );

    } finally {
        button.disabled = false;
        input.focus();
    }
});

🐍 Modificar la ruta de Python

Sustituya la función chat() por esta versión:

@app.post("/chat")
def chat() -> tuple[Any, int] | Any:
    """Recibe el historial y devuelve la siguiente respuesta."""
    data = request.get_json(silent=True) or {}
    raw_messages = data.get("messages", [])

    if not isinstance(raw_messages, list):
        return jsonify({"error": "El historial no es válido."}), 400

    clean_messages: list[dict[str, str]] = []

    for item in raw_messages[-20:]:
        if not isinstance(item, dict):
            continue

        role = item.get("role")
        content = str(item.get("content", "")).strip()

        if role not in {"user", "assistant"}:
            continue

        if not content:
            continue

        clean_messages.append(
            {
                "role": role,
                "content": content[:2000],
            }
        )

    if not clean_messages:
        return jsonify({"error": "Debe escribir un mensaje."}), 400

    try:
        response = client.responses.create(
            model="gpt-5.6",
            instructions=SYSTEM_INSTRUCTIONS,
            input=clean_messages,
        )

        answer = response.output_text.strip()

        if not answer:
            answer = "No fue posible generar una respuesta."

        return jsonify({"answer": answer})

    except Exception as error:
        app.logger.exception("Error al consultar la API: %s", error)

        return jsonify(
            {
                "error": (
                    "No fue posible procesar la solicitud. "
                    "Inténtelo nuevamente más tarde."
                )
            }
        ), 500

Ahora el modelo recibirá los mensajes recientes y podrá mantener una conversación coherente.

⚠️ Este sistema guarda el historial únicamente en la pestaña del navegador. Al actualizar la página, la memoria desaparece. Para conservar conversaciones permanentemente necesitará una base de datos.

📏 ¿Por qué limitamos el historial?

Cada mensaje enviado al modelo ocupa tokens.

Mientras más extensa sea la conversación:

• mayor será la cantidad de información procesada;
• más crecerá el costo;
• más tiempo podría tardar la respuesta;
• más difícil será mantener información relevante.

En el ejemplo utilizamos:

raw_messages[-20:]

Esto conserva solamente los últimos 20 mensajes.

En una aplicación real también puede:

• resumir conversaciones antiguas;
• guardar únicamente datos importantes;
• eliminar saludos y mensajes irrelevantes;
• crear una conversación independiente para cada usuario;
• establecer un máximo de caracteres o tokens.

💰 ¿La API de GPT es gratuita?

Una suscripción a ChatGPT y el consumo de la API son servicios diferentes.

La API normalmente se factura según el uso del modelo, principalmente por la cantidad de tokens procesados como entrada y generados como salida. Los precios varían según el modelo y pueden cambiar con el tiempo; la página oficial expresa las tarifas por cada millón de tokens.  

Por eso no conviene publicar un precio fijo dentro de un tutorial que permanecerá en línea durante mucho tiempo.

La fórmula general es:

Costo total =
costo de tokens de entrada
+
costo de tokens de salida
+
herramientas adicionales utilizadas

💡 Cómo reducir el costo

Puede:

• usar un modelo más económico para preguntas sencillas;
• limitar la longitud de las respuestas;
• reducir el historial enviado;
• rechazar mensajes excesivamente largos;
• establecer límites diarios por usuario;
• utilizar almacenamiento en caché cuando corresponda;
• evitar enviar documentos completos en cada turno;
• supervisar el consumo desde el panel.

🛡️ Seguridad: lo que debe hacer antes de publicarlo

El chatbot de este tutorial funciona bien como demostración local, pero una aplicación pública necesita controles adicionales.

🔑 1. Proteja la clave

Manténgala en variables de entorno del servidor.

Nunca la coloque en:

const apiKey = "sk-proj-...";

Todo JavaScript entregado al navegador puede ser inspeccionado por el visitante.

🚦 2. Limite la cantidad de solicitudes

Sin límites, una persona o un programa automatizado podría enviar cientos de mensajes y consumir su presupuesto.

Puede establecer:

• un máximo por minuto;
• un máximo diario;
• límites por cuenta;
• bloqueo temporal ante abuso;
• verificación CAPTCHA;
• autenticación de usuarios.

📐 3. Limite el tamaño de los mensajes

En nuestro ejemplo utilizamos:

if len(message) > 2000:

Esto evita solicitudes desproporcionadamente largas.

También debe limitar:

• el número de mensajes del historial;
• el tamaño de archivos;
• la duración de audios;
• la longitud de la respuesta;
• el número de solicitudes simultáneas.

🧹 4. Valide toda la información recibida

Nunca confíe automáticamente en los datos enviados desde el navegador.

El servidor debe verificar:

• que el mensaje exista;
• que sea texto;
• que no supere el límite;
• que el historial tenga un formato válido;
• que los roles permitidos sean correctos.

🧑‍⚖️ 5. Añada advertencias apropiadas

Si el chatbot trata temas sensibles, indique claramente sus límites.

Ejemplo:

Este asistente brinda información general y puede cometer errores. No sustituye el criterio de un profesional.

Esto resulta especialmente importante en áreas como:

• salud;
• derecho;
• finanzas;
• educación;
• seguridad;
• atención de emergencias.

🧪 6. Pruebe respuestas problemáticas

Antes de publicar, evalúe cómo responde ante:

• mensajes ambiguos;
• información falsa;
• instrucciones contradictorias;
• solicitudes fuera de tema;
• datos personales;
• intentos de modificar sus instrucciones;
• preguntas que deberían escalarse a una persona.

🧱 Errores frecuentes y cómo corregirlos

❌ Error: no se encontró la clave

Mensaje posible:

No se encontró OPENAI_API_KEY

Revise:

• que el archivo se llame exactamente .env;
• que esté en la carpeta principal;
• que la variable se llame OPENAI_API_KEY;
• que haya reiniciado el servidor;
• que no existan espacios innecesarios.

❌ Error de autenticación

Puede ocurrir cuando:

• la clave fue copiada incorrectamente;
• la clave fue revocada;
• la aplicación utiliza una credencial antigua;
• existe un problema con el proyecto o los permisos.

Cree una nueva clave y actualice la variable.

❌ Error por modelo no disponible

Los nombres y la disponibilidad de modelos pueden evolucionar.

Revise el catálogo oficial y cambie:

model="gpt-5.6"

por un modelo disponible para su proyecto.

❌ Error por cuota o facturación

Puede indicar que:

• no existe saldo o método de facturación;
• se alcanzó un límite de gasto;
• se superó una cuota;
• el proyecto tiene restricciones.

Revise el consumo, los límites y la configuración de facturación en el panel.

❌ El chatbot no recuerda nada

Esto ocurre cuando envía únicamente el último mensaje.

Debe:

• enviar el historial;
• guardar el contexto en una base de datos;
• utilizar las funciones de estado conversacional disponibles;
• asociar cada conversación con un usuario o sesión.

❌ La página funciona, pero cualquiera puede abusar de ella

Una interfaz bonita no es una medida de seguridad.

Antes de publicarla debe implementar:

• rate limiting;
• autenticación cuando corresponda;
• límites de uso;
• registro de errores;
• control de presupuesto;
• validación;
• protección contra solicitudes automatizadas.

🚀 ¿Cómo publicar el chatbot en Internet?

Para publicarlo necesita un servicio capaz de ejecutar Python.

El proceso general es:

1. Subir el proyecto a un repositorio privado o controlado.
2. Elegir un servicio de alojamiento compatible con Python.
3. Crear la variable OPENAI_API_KEY en la configuración del servidor.
4. Instalar las dependencias de requirements.txt.
5. Configurar el comando de inicio.
6. Activar HTTPS.
7. Probar la aplicación pública.
8. Configurar límites y monitoreo.

En producción no debe utilizar:

app.run(debug=True)

El modo de depuración puede mostrar información interna y no está diseñado para una aplicación pública.

Puede dejar el bloque así para desarrollo local:

if __name__ == "__main__":
    app.run(debug=True)

Pero su proveedor de alojamiento debería ejecutar la aplicación con un servidor de producción y con debug desactivado.

🗄️ ¿Cómo agregar una base de conocimientos?

El chatbot construido hasta ahora responde usando:

• sus instrucciones;
• el historial;
• el conocimiento y las capacidades del modelo.

Pero imagine que desea responder basándose en documentos concretos:

• catálogo de productos;
• reglamento interno;
• manual de empleados;
• preguntas frecuentes;
• políticas del negocio;
• artículos del blog;
• documentación técnica.

En ese caso necesitará un sistema de recuperación de información.

El flujo sería:

Pregunta del usuario
        ↓
Búsqueda en los documentos
        ↓
Selección de fragmentos relevantes
        ↓
Envío de esos fragmentos al modelo
        ↓
Respuesta basada en la información encontrada

Este enfoque suele conocerse como RAG, por Retrieval-Augmented Generation.

Su principal beneficio es que el chatbot puede responder utilizando información privada o especializada sin necesidad de entrenar un nuevo modelo desde cero.

🔌 ¿Se puede conectar con WhatsApp?

Sí, pero la API de OpenAI por sí sola no recibe mensajes de WhatsApp.

Necesitará:

• acceso oficial a la plataforma de mensajería;
• un número configurado;
• un webhook;
• un servidor;
• una aplicación que reciba los mensajes;
• lógica para enviarlos a OpenAI;
• un mecanismo para devolver las respuestas.

El flujo sería:

WhatsApp
   ↓
Webhook de su servidor
   ↓
API de OpenAI
   ↓
Respuesta generada
   ↓
API de mensajería
   ↓
Usuario

Además, debe respetar:

• consentimiento;
• protección de datos;
• plantillas autorizadas cuando correspondan;
• horarios y reglas de mensajería;
• posibilidad de atención humana;
• controles contra respuestas incorrectas.

Para una empresa, el chatbot no debería bloquear el acceso a una persona real. Es recomendable incluir opciones como:

Hablar con un asesor
Solicitar una llamada
Dejar mis datos
Finalizar conversación

💼 Ideas para utilizar su chatbot

🛒 Atención comercial

Puede responder:

• características de productos;
• preguntas frecuentes;
• métodos de pago;
• zonas de cobertura;
• políticas de entrega;
• pasos para solicitar una cotización.

🎓 Educación

Puede utilizarse como:

• tutor;
• guía de estudio;
• asistente de lectura;
• generador de cuestionarios;
• explicador de conceptos;
• herramienta de práctica.

🏢 Soporte interno

Una empresa puede conectarlo con:

• manuales;
• procesos;
• reglamentos;
• documentación;
• preguntas del personal;
• procedimientos administrativos.

✍️ Creación de contenido

Puede ayudar a producir:

• ideas para artículos;
• estructuras;
• titulares;
• resúmenes;
• descripciones;
• publicaciones para redes sociales.

🧭 Orientación inicial

Puede recopilar información antes de pasar la conversación a una persona.

Por ejemplo:

• nombre;
• consulta;
• producto de interés;
• horario preferido;
• ubicación general;
• datos necesarios para preparar una cotización.

📈 Cómo convertir el proyecto en una aplicación profesional

Una vez que domine la versión básica, puede agregar:

• cuentas de usuario;
• base de datos;
• historial permanente;
• carga de documentos;
• respuestas con fuentes;
• análisis de imágenes;
• entrada y salida por voz;
• panel administrativo;
• estadísticas;
• evaluación de respuestas;
• integración con CRM;
• derivación a agentes humanos;
• varios asistentes especializados;
• diferentes idiomas.

También puede implementar transmisión progresiva para mostrar la respuesta a medida que se genera, en lugar de esperar a que termine por completo.

✅ Lista de comprobación antes del lanzamiento

Antes de publicar su chatbot, confirme que:

• la clave no está en el código público;
• el archivo .env está excluido del repositorio;
• existen límites de solicitudes;
• los mensajes tienen una longitud máxima;
• el historial está controlado;
• los errores no revelan datos sensibles;
• el modo de depuración está desactivado;
• se supervisa el gasto;
• las instrucciones están claramente definidas;
• existe una opción de atención humana;
• los usuarios conocen las limitaciones de la IA;
• se realizan pruebas periódicas.

🎓 Conclusión

Crear un chatbot con la API de GPT es mucho más accesible de lo que parece.

En este tutorial aprendió a:

• crear una clave de API;
• protegerla mediante variables de entorno;
• instalar el SDK oficial;
• enviar una solicitud desde Python;
• construir un servidor con Flask;
• crear una interfaz web;
• mantener un historial conversacional;
• controlar errores;
• reducir riesgos y costos;
• preparar el proyecto para una futura publicación.

El código es solo el punto de partida.

El verdadero valor aparece cuando combina el modelo con:

• instrucciones bien diseñadas;
• información confiable;
• una experiencia sencilla;
• controles de seguridad;
• supervisión humana;
• un problema real que necesite resolver.

Un chatbot útil no es el que responde más, sino el que ofrece respuestas correctas, relevantes y alineadas con las necesidades del usuario.

❓ Preguntas frecuentes

🔹 ¿Necesito saber programación?

Necesita conocimientos básicos para crear archivos, instalar dependencias y ejecutar comandos. Sin embargo, no necesita ser experto en Inteligencia Artificial ni entrenar un modelo.

🔹 ¿Es lo mismo ChatGPT que la API?

No. ChatGPT es una aplicación para usuarios. La API permite integrar modelos de OpenAI dentro de programas, páginas web y sistemas propios.

🔹 ¿La suscripción de ChatGPT incluye el uso de la API?

Son productos y sistemas de facturación distintos. Debe revisar la configuración y el consumo de la plataforma API por separado.

🔹 ¿Puedo crear un chatbot para mi empresa?

Sí. Puede adaptarlo a ventas, soporte, formación interna, preguntas frecuentes o atención inicial. Debe incorporar protección de datos, límites y atención humana.

🔹 ¿Puedo colocar la clave en el archivo HTML?

No. Cualquier visitante podría inspeccionarla y utilizarla. La clave debe permanecer en el servidor.

🔹 ¿Por qué el chatbot inventa información?

Los modelos pueden generar afirmaciones incorrectas. Reduzca el problema mediante instrucciones claras, documentos confiables, validaciones y revisión humana.

🔹 ¿Cómo hago para que conozca mi negocio?

Puede añadir información en las instrucciones cuando sea breve. Para catálogos o documentos extensos, lo más apropiado es conectar una base de conocimientos o un sistema RAG.

🔹 ¿Puedo cobrar por un chatbot?

Sí, siempre que cumpla las condiciones aplicables, proteja los datos, controle sus costos y ofrezca un servicio real. Puede vender configuración, mantenimiento, integración, personalización o acceso a una aplicación especializada.

🚀 Próximo artículo recomendado

👉 Cómo conectar un chatbot con los documentos de su empresa mediante RAG: guía para principiantes.

También puede explorar las mejores herramientas de inteligencia artificial en 2026 para complementar este proyecto.