Clase 22 de 24 • Curso de Desarrollo de Chatbots con OpenAI
Contenido del curso
Paolo Joaquin Pinto Perez
Endy Bermúdez R
Nahuel Brandan
Joseph Corona
Jose Daniel Velasquez H
Rommer Batista
Johan Nicolás Valderrama Serrato
Manuel Oviedo
Sebastian Gaviria
Facundo Salade
Arístides Pérez Hernández
Arístides Pérez Hernández
Arístides Pérez Hernández
Luis Miguel Rodríguez
Luis Miguel Rodríguez
Javier Lazaro
Diego Bustos Kehdy
Pablo Andrés Sánchez Zambrano
Jose Daniel Velasquez H
Jose Daniel Velasquez H
Mauricio Combariza
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
Gracia por tu aporte, Paolo. ¿Sabes cómo puedo subir ese archivo a mi repositorio? Para usarlos en Github actions.
@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.
Ese codigo no funciona, es asqueroso... Deberian subir el codigo CORRECTO
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()
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
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
La clase es muy buena pero deberia llamarse crea un chatbot en Telegram.
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.
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()
¿Cómo afecta la temperatura a las respuestas?
Modificar la temperatura cambia radicalmente la personalidad de tu bot. Este valor, que va de 0 a 1, controla el nivel de aleatoriedad en la selección de palabras. Si configuras una temperatura baja, el modelo se vuelve muy conservador, analítico y predecible, ideal para respuestas técnicas o datos exactos donde no quieres margen de error. Si la subes, le das libertad creativa; las respuestas serán más variadas, fluidas y conversacionales, pero corres el riesgo de que la IA alucine o se desvíe del tema. Un valor intermedio como 0.5 ofrece un equilibrio perfecto: mantiene la coherencia lógica de tu configuración mientras conserva un tono natural y humano.
¿Por qué el bot responde repetidamente el mensaje?
Este comportamiento de bucle infinito ocurre porque Telegram no sabe que ya procesaste el mensaje. Cuando consultas la API usando el método de actualización, el servidor te envía los últimos mensajes disponibles. Si no actualizas el parámetro offset sumándole 1 al identificador del último mensaje recibido, Telegram asume que la entrega falló o que aún no lo has leído. Como resultado, en la siguiente consulta te volverá a enviar exactamente la misma pregunta del usuario. Para solucionar esto, tu código debe capturar el update_id del mensaje más reciente, incrementarlo en uno y enviarlo en la próxima petición para limpiar la cola.
¿Dónde encaja el modelo personalizado de OpenAI?
El modelo que has entrenado mediante Fine-Tuning actúa como el cerebro principal de tu bot y se integra directamente en la función de generación de respuestas. En lugar de usar modelos genéricos estándar, debes pasar el identificador único de tu modelo personalizado al parámetro engine o model durante la petición a la API de OpenAI. Este identificador especial se genera una vez que el entrenamiento concluye y suele estar disponible en tu panel de control. Al conectarlo en este punto exacto del código, garantizas que el bot responda utilizando el tono, la estructura y el conocimiento específico que le enseñaste previamente.
aumente un poco la temperatura, y lo trate de sacar fuera de recomendaciones de cursos, y lo veo bien
Estamos validando con que area de la compañia iniciamos para elaborar el fine tuning.
Me da cosa tantos espacios por cada tab de py 😵💫
funciona
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()
Esta vivo, esta vivo!
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()
