Crear chatbot con Python: de reglas simples a IA con tus datos

Para crear un chatbot con Python necesitas muy poco: un ciclo que lea lo que escribe el usuario, una función que decida la respuesta y, si quieres que entienda lenguaje natural, una llamada a un modelo de IA. En esta guía vamos en tres niveles: un chatbot de reglas, uno con IA y memoria, y uno que responde con tus documentos, más una interfaz web en pocas líneas.

Preparar el entorno

python3 -m venv .venv
source .venv/bin/activate        # en Windows: .venv\Scripts\activate
pip install openai gradio

Guarda tu llave de API como variable de entorno, nunca escrita en el código:

export OPENAI_API_KEY="sk-..."   # en Windows PowerShell: $env:OPENAI_API_KEY="sk-..."

Nivel 1: chatbot de reglas

Útil para menús y respuestas fijas. No necesita IA ni internet.

# reglas.py
RESPUESTAS = {
    "horario": "Abrimos de lunes a sábado de 9 a 18 h.",
    "ubicacion": "Av. Ejemplo 123, Monterrey.",
    "pago": "Aceptamos tarjeta y transferencia.",
}

def responder(texto: str) -> str:
    t = texto.lower().replace("ó", "o")
    for clave, respuesta in RESPUESTAS.items():
        if clave in t:
            return respuesta
    return "Puedo ayudarte con: horario, ubicación o pago."

if __name__ == "__main__":
    print("Escribe 'salir' para terminar.")
    while (msg := input("Tú: ")) != "salir":
        print("Bot:", responder(msg))

Limitación obvia: si alguien escribe “¿a qué hora cierran?”, no encuentra “horario”. Para eso está la IA.

Nivel 2: chatbot con IA y memoria

El modelo no recuerda nada entre llamadas: tú guardas el historial y lo mandas cada vez.

# ia.py
from openai import OpenAI

client = OpenAI()
historial = [{
    "role": "system",
    "content": (
        "Eres el asistente de una ferretería en Monterrey. "
        "Responde breve, en español de México. "
        "Si no sabes algo de la tienda, dilo; no inventes precios."
    ),
}]

while (msg := input("Tú: ")) != "salir":
    historial.append({"role": "user", "content": msg})
    r = client.chat.completions.create(
        model="gpt-4.1-mini",  # revisa los modelos vigentes en platform.openai.com
        messages=[historial[0]] + historial[1:][-20:],  # sistema + últimos 20
    )
    texto = r.choices[0].message.content
    historial.append({"role": "assistant", "content": texto})
    print("Bot:", texto)

Recortar a los últimos mensajes (conservando siempre el de sistema) evita que el costo crezca sin control.

Con Claude cambias el cliente por anthropic.Anthropic() y la llamada por client.messages.create(model=..., system=..., messages=..., max_tokens=...). Sin pagar API, usa Ollama: tiene un endpoint compatible con OpenAI en http://localhost:11434/v1, así que el mismo código sirve con:

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
# y model="llama3.2" (o el modelo que hayas descargado con `ollama pull`)

Nivel 3: que responda con tus documentos

Para que el chatbot conteste con tu catálogo o tu manual, la forma más simple (si el texto es corto) es meterlo en las instrucciones:

from pathlib import Path

catalogo = Path("catalogo.txt").read_text(encoding="utf-8")
historial[0]["content"] += "\n\nCatálogo vigente:\n" + catalogo

Si tus documentos son muchos o muy largos, se usa RAG (recuperación aumentada): divides los documentos en fragmentos, los indexas con embeddings (representaciones numéricas del significado) y en cada pregunta mandas al modelo solo los fragmentos relevantes. Bibliotecas como chromadb o Postgres con pgvector sirven para el índice. Lo explicamos a nivel conceptual en chatbot interno para empresas.

Interfaz web en 10 líneas con Gradio

# web.py
import gradio as gr
from openai import OpenAI

client = OpenAI()
SISTEMA = "Eres el asistente de una ferretería. Responde breve."

def chat(mensaje, historial):
    msgs = [{"role": "system", "content": SISTEMA}] + historial + [{"role": "user", "content": mensaje}]
    r = client.chat.completions.create(model="gpt-4.1-mini", messages=msgs)
    return r.choices[0].message.content

gr.ChatInterface(chat, type="messages").launch()

Corre python web.py y abre la dirección que aparece. El parámetro type="messages" aplica a versiones recientes de Gradio; si tu versión marca error, revisa la documentación de Gradio.

Llevarlo a un canal real

La función responder es la misma; cambias solo la entrada y salida:

• WhatsApp: recibes el webhook de la Cloud API y respondes con su endpoint. Código en crear bot de WhatsApp con Python.
• Telegram: con python-telegram-bot. Ver cómo crear un bot en Telegram.
• Tu sitio web: expones la función con FastAPI o Flask y un widget de chat la consume.

Memoria por usuario: el salto de la terminal a un canal real

El ejemplo del nivel 2 guarda un solo historial en una variable. En cuanto lo conectas a WhatsApp o a tu sitio, llegan mensajes de muchas personas al mismo tiempo y cada una necesita su propia conversación. La forma básica es un diccionario con el identificador del usuario (su número, su ID de Telegram o una cookie del sitio) como clave:

historiales: dict[str, list] = {}

def responder_a(usuario_id: str, mensaje: str) -> str:
    h = historiales.setdefault(usuario_id, [])
    h.append({"role": "user", "content": mensaje})
    msgs = [{"role": "system", "content": SISTEMA}] + h[-20:]
    texto = client.chat.completions.create(model="gpt-4.1-mini", messages=msgs).choices[0].message.content
    h.append({"role": "assistant", "content": texto})
    return texto

Un diccionario en memoria se borra cada vez que reinicias el programa. Para producción, guarda los mensajes en una base de datos (SQLite para empezar, Postgres o Redis cuando crece) y define cuánto tiempo los conservas: son datos personales y la ley mexicana de protección de datos aplica.

¿Reglas, IA o las dos?

No todo chatbot necesita un modelo de lenguaje. Una guía rápida para decidir:

• Solo reglas cuando las preguntas son pocas y predecibles (horario, ubicación, estado de un pedido con número de folio). Es gratis, rápido y nunca inventa.
• Solo IA cuando la gente pregunta de mil formas distintas y la respuesta sale de un texto que tú controlas (catálogo, políticas, preguntas frecuentes).
• Híbrido, que es lo más común en negocios: reglas para lo que debe ser exacto (precios, saldos, citas, que salen de tu sistema) y la IA solo para entender la intención y redactar la respuesta. Así el modelo no tiene oportunidad de inventar un precio.

Cómo probarlo antes de ponerlo frente a clientes

Arma una lista de 20 a 30 preguntas reales (sácalas de tu WhatsApp o tu correo) que incluya las difíciles: preguntas fuera de tema, groserías, alguien que pide un descuento, alguien que pregunta algo que no está en tu catálogo. Corre el bot con todas cada vez que cambies las instrucciones o el modelo y revisa a mano las respuestas. Si en una sola inventa un dato, ajusta el mensaje de sistema o mueve ese dato a una regla.

También vigila el costo. Los proveedores cobran por tokens (fragmentos de texto) que entran y salen, y el precio cambia según el modelo; consulta las tarifas vigentes en OpenAI o Anthropic y pon un límite de gasto mensual en la consola del proveedor desde el primer día.

Errores comunes

• Llave de API en el código que luego subes a GitHub. Usa variables de entorno y .gitignore.
• Historial infinito: el costo y la lentitud crecen con cada mensaje. Recorta o resume.
• Sin instrucciones de sistema: el bot responde de todo y sin tono de tu negocio.
• “AuthenticationError” o 401: la variable de entorno no está cargada en esa terminal.
• “RateLimitError” o 429: superaste el límite de tu cuenta o no tienes saldo; revisa la consola del proveedor.

Para cerrar

Con Python puedes tener un chatbot funcionando en una tarde. Lo difícil viene después: datos confiables, memoria por usuario, canales reales, costos controlados y seguridad. Si quieres dar el siguiente paso hacia un asistente que ejecute acciones, mira crear agente de IA. En Black Engine llevamos chatbots de Python a producción; escríbenos por WhatsApp.