Integración de OpenAI y Telegram en PlatziBot con Python

Clase 22 de 24 • Curso de Desarrollo de Chatbots con OpenAI

Resumen

ACTUALIZACIÓN FUNCIÓN get_openai_response()

def get_openai_response(prompt):
    system = '''
        Eres un asistente de atención a clientes 
        y estudiantes de la plataforma de educación online en tecnología,  
        inglés y liderazgo llamada Platzi
        '''     
    response = openai.chat.completions.create(
		model='INGRESA EL NOMBRE DE TU MODELO CON FINE-TUNING',
		messages=[
            {"role": "system", "content" :f'{system}'},
            {"role": "user", "content" : f'{prompt}'}],
		max_tokens=150,
		n=1,
		temperature=0.2)    
    return response.choices[0].message.content.strip()

En el mundo de la programación y la interacción con inteligencias artificiales, la creación de un bot que se conecte con modelos de procesamiento de lenguaje natural es una tarea que despierta gran interés y posibilidades. En este viaje tecnológico, es fascinante ver cómo podemos enlazar estas herramientas para crear soluciones innovadoras.

Integrando OpenAI con PlatziBot

Al trabajar en proyectos de esta magnitud, es esencial tener claridad en cada uno de los pasos a seguir. Así, logramos configurar con éxito la conexión entre nuestro bot de Telegram y el modelo de OpenAI personalizado.

¿Cómo configuramos las claves API y los tokens?

El primer paso fundamental es la configuración segura de las claves que permitirán la comunicación entre las plataformas:

API Key de OpenAI: Esta nos permite interactuar con los servicios de OpenAI.
Token de Telegram: Es el identificador que nos da acceso al bot creado en esta plataforma.

Es crucial que actualices estos valores con los correspondientes a tu propio bot y conexión a OpenAI.

¿Qué funciones necesitamos para el bot?

La funcionalidad de un bot residirá en las operaciones que pueda realizar a través de su código. Aquí están las esenciales:

GetUpdate: Esta función obtiene la información de los mensajes que recibimos en Telegram utilizando una URL específica y el token asignado.
- Establece un timeout para las respuestas, con el objetivo de optimizar la interacción.
- Recibe un parámetro offset para continuar la actualización desde la última acción conocida.
sendMessages: Después de procesar la información recibida, usamos esta función para responder al usuario. Necesitarás:
- El chat ID del usuario para devolver la respuesta.
- El texto (text) que deseamos enviar.
getOpenAIResponse: Esta función activa a PlatziBot para que responda preguntas con el modelo de IA.
- Selecciona el modelo personalizado (modelEngine) previamente configurado.
- Define el ‘prompt’, ‘maxTokens’, y otros parámetros para ajustar la respuesta deseada.
- Estructura la respuesta para que sea legible y pertinente a la pregunta realizada.

Estas funciones son cruciales para facilitar una conversación fluida con el usuario y para asegurar que nuestro bot sea interactivo y útil.

¿Cómo depuramos y ejecutamos nuestro bot?

Después de implementar las funciones principales, es hora de corregir errores tipográficos y de sintaxis. Asimismo, nombrar correctamente las funciones y parámetros mejora la legibilidad y el mantenimiento del código.

Una vez todo esté en orden, es momento de ejecutar nuestro bot y realizar pruebas reales, como enviar una pregunta relacionada con cursos de HTML al modelo de OpenAI personalizado y recibir una respuesta adecuada. Este es un proceso de prueba y error donde ajustamos y mejoramos continuamente.

¿Qué hacemos con las respuestas redundantes de Telegram?

Al interactuar con el bot, puede ocurrir que Telegram envíe respuestas repetidas a la última pregunta realizada. El próximo reto es implementar una solución para este inconveniente, ajustando el manejo de los offsets y la secuencia de mensajes recibidos.

¿Cómo continuar al toparse con desafíos?

A lo largo del proceso de desarrollo, es común toparse con errores y desafíos técnicos. Ante estas situaciones, es importante:

Mantener una actitud de aprendizaje y experimentación.
Buscar apoyo y consejos en comunidades y foros de desarrolladores.
Documentar los problemas y las soluciones encontradas.

Recuerda que cada problema es una oportunidad para mejorar y aprender más sobre estas fascinantes tecnologías. La próxima clase estará repleta de más consejos y prácticas para seguir puliendo nuestro PlatziBot. ¡Continúa tu aventura de aprendizaje con entusiasmo y dedicación!

Paolo Joaquin Pinto Perez

student•

Reemplaza tus valores de forma más profesional con dotenv

instala pip install python-dotenv importa y obten las variables

from dotenv import load_dotenv
import os

# Carga las variables de entorno desde el archivo .env
load_dotenv()

# Accede a las variables de entorno cargadas
variable1 = os.getenv("NOMBRE_VARIABLE1")
variable2 = os.getenv("NOMBRE_VARIABLE2")

# Utiliza las variables de entorno en tu código
print(variable1)
print(variable2)

Crea un archivo .env en la raiz de tu proyecto y quedaria asi(ejemplo):

NOMBRE_VARIABLE1=valor1
NOMBRE_VARIABLE2=valor2
API_KEY=abcd1234

Endy Bermúdez R

student•

Gracia por tu aporte, Paolo. ¿Sabes cómo puedo subir ese archivo a mi repositorio? Para usarlos en Github actions.

Nahuel Brandan

student•

@endy-bermudez-r no se debe subir el archivo de variables de entorno al repositorio, dado que por lo general contiene valores sensibles, como el token de openai.

Para definir variables de entorno en Github Actions, podés ver en su documentación como hacerlo.

Manuel Oviedo

student•

La clase es muy buena pero deberia llamarse crea un chatbot en Telegram.

Joseph Corona

student•

Ese codigo no funciona, es asqueroso... Deberian subir el codigo CORRECTO

Jose Daniel Velasquez H

company_admin•

Hola, este me funcionoimport openaiimport requestsimport time openai.api_key = ""TOKEN = "" def get_updates(offset): url = f"https://api.telegram.org/bot{TOKEN}/getUpdates" params = {"timeout": 100, "offset": offset} response = requests.get(url, params=params) return response.json()["result"] def send_messages(chat_id, text): url = f"https://api.telegram.org/bot{TOKEN}/sendMessage" params = {"chat_id": chat_id, "text": text} response = requests.post(url, params=params) return response def get_openai_response(prompt): response = openai.ChatCompletion.create( model="gpt-4", # Cambia a 'gpt-3.5-turbo' si no tienes acceso a gpt-4 messages=[ {"role": "system", "content": "Eres un asistente útil y profesional."}, {"role": "user", "content": prompt} ], max_tokens=100, # Ajusta el límite de tokens para controlar el tamaño de la respuesta temperature=0.7 # Ajusta la creatividad de las respuestas ) return response['choices'][0]['message']['content'].strip()

def main(): print("Starting bot...") offset = 0 while True: updates = get_updates(offset) if updates: for update in updates: offset = update["update_id"] +1 chat_id = update["message"]["chat"]['id'] user_message = update["message"]["text"] print(f"Received message: {user_message}") GPT = get_openai_response(user_message) send_messages(chat_id, GPT) else: time.sleep(1)if __name__ == '__main__': main()

import openai
import requests
import time

openai.api_key = ""
TOKEN = ""

def get_updates(offset):
    url = f"https://api.telegram.org/bot{TOKEN}/getUpdates"
    params = {"timeout": 100, "offset": offset}
    response = requests.get(url, params=params)
    return response.json()["result"]

def send_messages(chat_id, text):
    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
    params = {"chat_id": chat_id, "text": text}
    response = requests.post(url, params=params)
    return response

def get_openai_response(prompt):
    response = openai.ChatCompletion.create(
            model="gpt-4",  # Cambia a 'gpt-3.5-turbo' si no tienes acceso a gpt-4
            messages=[
                {"role": "system", "content": "Eres un asistente útil y profesional."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=100,  # Ajusta el límite de tokens para controlar el tamaño de la respuesta
            temperature=0.7  # Ajusta la creatividad de las respuestas
        )
    return response['choices'][0]['message']['content'].strip()



def main():
    print("Starting bot...")
    offset = 0
    while True:
        updates = get_updates(offset)
        if updates:
            for update in updates:
                offset = update["update_id"] +1
                chat_id = update["message"]["chat"]['id']
                user_message = update["message"]["text"]
                print(f"Received message: {user_message}")
                GPT = get_openai_response(user_message)
                send_messages(chat_id, GPT)
        else:
            time.sleep(1)
if __name__ == '__main__':
    main()

Sebastian Gaviria

student•

Noviembre 26, 2023.

Para quienes estén haciendo este curso recientemente, deben cambiar la manera a la que acceden a OpenAI. Deben cambiar algunos parámetros en la forma en que se envían los mensajes como se muestra a continuación:

from  openai import OpenAI
import requests
import time

client = OpenAI(api_key='OPENAI_KEY')

def get_openai_response(prompt):
    response = client.completions.create(
    model="TRAINED_MODEL",
        max_tokens=200,
        prompt = prompt,
        n = 1,
        stop = " END",
        temperature=0.5,
    )
    return response.choices[0].text.strip()

Espero sea de ayuda.

Facundo Salade

student•

El código completo de cómo iría en con completion.chat que hoy rige para los nuevos modelos:

import openai
from openai import OpenAI
import requests
import time
import os

TOKEN = os.environ.get('API_KEY_TELEGRAM_BOT')
client = OpenAI(api_key= "OPENAI_API_KEY")

def get_updates(offset):
    url = f"https://api.telegram.org/bot{TOKEN}/getUpdates"
    params = {"timeout": 100, "offset": offset}
    response = requests.get(url, params=params)
    return response.json()["result"]

def send_messages(chat_id, text):
    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
    params = {"chat_id": chat_id, "text": text}
    response = requests.post(url, params=params)
    return response

def get_openai_response(messages, model):
    response = openai.chat.completions.create(
            model=model,
            messages= [
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": messages}
            ],
            max_tokens = 200,
            n = 1,
            stop = " END",
            temperature = 0.5
    )
    return response.choices[0].message.content

def main():
    print("Starting bot...")
    offset = 0
    while True:
        updates = get_updates(offset)
        if updates:
            for update in updates:
                offset = update["update_id"] +1
                chat_id = update["message"]["chat"]['id']
                user_message = update["message"]["text"]
                print(f"Received message: {user_message}")
                GPT = get_openai_response(user_message, model="gpt-3.5-turbo")
                send_messages(chat_id, GPT)
        else:
            time.sleep(100000)

if __name__ == '__main__':
    main()
```import openaifrom openai import OpenAIimport requestsimport timeimport os
TOKEN = os.environ.get('API\_KEY\_TELEGRAM\_BOT')client = OpenAI(api\_key= "OPENAI\_API\_KEY")
def get\_updates(offset):    url = f"https://api.telegram.org/bot{TOKEN}/getUpdates"    params = {"timeout": 100, "offset": offset}    response = requests.get(url, params=params)    return response.json()\["result"]
def send\_messages(chat\_id, text):    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"    params = {"chat\_id": chat\_id, "text": text}    response = requests.post(url, params=params)    return response
def get\_openai\_response(messages, model):    response = openai.chat.completions.create(            model=model,            messages= \[                {"role": "system", "content": "You are a helpful assistant."},                {"role": "user", "content": messages}            ],            max\_tokens = 200,            n = 1,            stop = " END",            temperature = 0.5    )    return response.choices\[0].message.content
def main():    print("Starting bot...")    offset = 0    while True:        updates = get\_updates(offset)        if updates:            for update in updates:                offset = update\["update\_id"] +1                chat\_id = update\["message"]\["chat"]\['id']                user\_message = update\["message"]\["text"]                print(f"Received message: {user\_message}")                GPT = get\_openai\_response(user\_message, model="gpt-3.5-turbo")                send\_messages(chat\_id, GPT)        else:            time.sleep(100000)
if \_\_name\_\_ == '\_\_main\_\_':    main()

Rommer Batista

student•

Para mejorar la interacción, se podría usar un sistema de persistencia como Redis para recordar el contexto de la conversación por usuario así evitamos respuestas repetitivas

Javier Lazaro

student•

Estamos validando con que area de la compañia iniciamos para elaborar el fine tuning.

Johan Nicolás Valderrama Serrato

student•

Voy bien pero sin presupuesto ala, me gusta el tema, quiero poder llevarlo a un proyecto en donde el bot permita al usuario decidir si quiere que le conteste una IA y a partir de una donación, este habilite el uso del modelo entrenado y que esto lleve a que se use y se revise su funcionamiento, pero ya lo veo complejo

Diego Bustos Kehdy

student•

Me da cosa tantos espacios por cada tab de py 😵‍💫

Pablo Andrés Sánchez Zambrano

student•

funciona

Jose Daniel Velasquez H

company_admin•

import openai
import requests
import time

openai.api_key = ""
TOKEN = ""

def get_updates(offset):
    url = f"https://api.telegram.org/bot{TOKEN}/getUpdates"
    params = {"timeout": 100, "offset": offset}
    response = requests.get(url, params=params)
    return response.json()["result"]

def send_messages(chat_id, text):
    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
    params = {"chat_id": chat_id, "text": text}
    response = requests.post(url, params=params)
    return response

def get_openai_response(prompt):
    response = openai.ChatCompletion.create(
            model="gpt-4",  # Cambia a 'gpt-3.5-turbo' si no tienes acceso a gpt-4
            messages=[
                {"role": "system", "content": "Eres un asistente útil y profesional."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=100,  # Ajusta el límite de tokens para controlar el tamaño de la respuesta
            temperature=0.7  # Ajusta la creatividad de las respuestas
        )
    return response['choices'][0]['message']['content'].strip()



def main():
    print("Starting bot...")
    offset = 0
    while True:
        updates = get_updates(offset)
        if updates:
            for update in updates:
                offset = update["update_id"] +1
                chat_id = update["message"]["chat"]['id']
                user_message = update["message"]["text"]
                print(f"Received message: {user_message}")
                GPT = get_openai_response(user_message)
                send_messages(chat_id, GPT)
        else:
            time.sleep(1)
if __name__ == '__main__':
    main()

```*import* openai*import* requests*import* time
openai.api\_key = ""TOKEN = ""
def get\_updates(offset):    url = f"https://api.telegram.org/bot{TOKEN}/getUpdates"    params = {"timeout": 100, "offset": offset}    response = requests.get(url, params=params)    *return* response.json()\["result"]
def send\_messages(chat\_id, text):    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"    params = {"chat\_id": chat\_id, "text": text}    response = requests.post(url, params=params)    *return* response
def get\_openai\_response(prompt):    response = openai.ChatCompletion.create(            model="gpt-4",  *# Cambia a 'gpt-3.5-turbo' si no tienes acceso a gpt-4*            messages=\[                {"role": "system", "content": "Eres un asistente útil y profesional."},                {"role": "user", "content": prompt}            ],            max\_tokens=100,  *# Ajusta el límite de tokens para controlar el tamaño de la respuesta*            temperature=0.7  *# Ajusta la creatividad de las respuestas*        )    *return* response\['choices']\[0]\['message']\['content'].strip()


def main():    print("Starting bot...")    offset = 0    *while* True:        updates = get\_updates(offset)        *if* updates:            *for* update *in* updates:                offset = update\["update\_id"] +1                chat\_id = update\["message"]\["chat"]\['id']                user\_message = update\["message"]\["text"]                print(f"Received message: {user\_message}")                GPT = get\_openai\_response(user\_message)                send\_messages(chat\_id, GPT)        *else*:            time.sleep(1)*if* \_\_name\_\_ == '\_\_main\_\_':    main()

Jose Daniel Velasquez H

company_admin•

Esta vivo, esta vivo!

Mauricio Combariza

student•

Mis apuntes de clase

def get_updates(offset):
    url = f"https://api.telegram.org/bot{token}/getUpdates"
    params = {"timeout": 100, 'offset': offset}
    response = requests.get(url, params=params)
    return response.json()["result"]


def send_messages(chat_id, text):
    url = f"https://api.telegram.org/bot{token}/sendMessage"
    params = {"chat_id": chat_id, "text": text}
    response = requests.post(url, params=params)
    return response


def get_openai_response(prompt):
    model_engine = "MODEL"
    response = openai.Completion.create(
        engine=model_engine,
        prompt=prompt,
        max_tokens=200,
        n=1,
        stop=None,
        temperature=0.5
    )
    return response.choices[0].text.strip()