Integración del modelo de OpenAI a Telegram

Curso de Desarrollo de Chatbots con OpenAI

OpenAI API

¿Cómo usar la API de OpenAI en tu producto?

Conociendo la documentación de la API de OpenAI

Chat Completions: modelos de Chat de OpenAI

Parámetros de Chat Completions: temperature, top_p y n

Aplicación de ejemplo utilizando modelos de OpenAI

Buenas prácticas al usar modelos de OpenAI

Modelos de texto disponibles de OpenAI

Quiz: OpenAI API

Fine-tuning de modelos de OpenAI

¿Por qué hacer fine-tuning a modelos de OpenAI?

Modelos disponibles para fine-tuning en OpenAI

Costos de uso de OpenAI: tokenización de texto

Configuración de entorno local de OpenAI con Anaconda

Formato de datos para fine-tuning

Preparar datos para fine-tuning

Fine-tuning de modelo de OpenAI

¿Cómo usar el Playground de OpenAI para probar modelos?

Pruebas al modelo con fine-tuning

Optimizar el modelo: ajuste de parámetros en Playground

Quiz: Fine-tuning de modelos de OpenAI

Integración de modelo a aplicación de chat

¿Cómo crear un chatbot con Telegram?

Procesando la entrada del usuario para el chatbot

Prueba de envío de mensajes del chatbot

Función main() del chatbot

Integración del modelo de OpenAI a Telegram

Manejo de errores y excepciones de la API de OpenAI

Quiz: Integración de modelo a aplicación de chat

Conclusión

Recomendaciones finales y proyectos alternativos con la API de OpenAI

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

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!

Aportes 9

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Paolo Joaquin Pinto Perez

hace un año

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

Joseph Corona

hace 6 meses

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

Sebastian Gaviria

hace un año

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

hace un año

El código completo de cómo iría en con completion.chat que hoy rige para los nuevos modelos: ```js 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()

Pablo Andrés Sánchez Zambrano

hace 2 meses

funciona ![](https://static.platzi.com/media/user_upload/image-f33344da-82a8-468a-a75d-b6a183861e2b.jpg)

Jose Daniel Velasquez H

hace 2 meses

```js 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

hace 2 meses

Esta vivo, esta vivo! ![](https://static.platzi.com/media/user_upload/image-75444429-a3c9-4146-8c1f-20fd24dccad0.jpg)

Manuel Oviedo

hace 3 meses

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

Mauricio Combariza

hace un año

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()