Conectar Platzi Bot a tu modelo fine-tuned

Cursos Empresas Blog Live Conf Precios

Contenido del curso

OpenAI API

Fine-tuning de modelos de OpenAI

Integración de modelo a aplicación de chat

Conclusión

24
Proyectos de Fine Tuning y Procesamiento de Lenguaje Natural
02:58 min

Tomar examen

Conectar Platzi Bot a tu modelo fine-tuned

Resumen

Conectar un modelo personalizado de OpenAI con Telegram te permite crear un bot conversacional que responde con el conocimiento que tú elegiste durante el fine tuning. Aquí verás cómo estructurar las funciones en Python para que Platzi Bot consulte tu modelo y responda en chat.

Cómo configurar la API key de OpenAI y el token de Telegram

Antes de escribir las funciones del bot, necesitas dos credenciales: la API key de OpenAI y el token del bot de Telegram. Sin estos datos, no hay conexión posible entre Telegram y tu modelo personalizado.

En el código asignas openai.api_key = OPENAI_API_KEY y luego creas la variable token = TELEGRAM_TOKEN. Recuerda reemplazar estos valores con los tuyos, porque son únicos por cuenta y por bot.

¿Dónde encuentro el token de mi bot de Telegram? Lo obtienes al crear el bot con BotFather dentro de Telegram. Te entrega una cadena única que sirve para autenticar cada petición a la API.

Cómo construir la función getUpdates para leer mensajes

La función get_updates se conecta a la API de Telegram para traer los mensajes que los usuarios han enviado al bot. Recibe un parámetro offset que ayuda a controlar qué mensajes ya se procesaron.

La estructura básica es:

URL: https://api.telegram.org/bot{token}/getUpdates.
Parámetros: timeout = 100 y offset = offset.
Petición: requests.get(url, params=params).
Retorno: response.json()['result'].

El timeout de 100 segundos mantiene la conexión abierta esperando nuevos mensajes, lo que reduce peticiones innecesarias [02:00].

Cómo enviar respuestas al usuario con sendMessage

Una vez procesado el mensaje, el bot necesita responder. Para eso creas la función send_messages, que recibe el chat_id del usuario y el text que quieres enviar.

La URL cambia el endpoint a sendMessage y la petición ahora es un POST. Los parámetros incluyen el chat_id para identificar a quién responder y el text con el contenido del mensaje. Al final retornas la respuesta del request para verificar que llegó.

¿Por qué se usa POST en sendMessage y GET en getUpdates? Porque GET sirve para leer información del servidor de Telegram, mientras que POST envía datos nuevos, en este caso el mensaje que el bot publica en el chat.

Cómo conectar el modelo fine-tuned con get_openai_response

Esta es la función que da vida a Platzi Bot. Recibe un prompt (la pregunta del usuario) y devuelve la respuesta generada por tu modelo personalizado en OpenAI.

Dentro de la función defines:

model_engine: el nombre único del modelo después del fine tuning, que aparece en el playground de OpenAI.
engine = model_engine dentro de openai.Completion.create().
prompt = prompt para pasar la pregunta.
max_tokens = 200, valor elegido durante la configuración de hiperparámetros.
n = 1 y stop = None para una sola respuesta sin condición de corte.
temperature = 0.5 para equilibrar creatividad y precisión.

El retorno es response.choices[0].text.strip(), que extrae el texto limpio de la primera opción generada [05:30].

Por qué importan los hiperparámetros en la respuesta

La temperatura controla qué tan determinista o creativa es la respuesta. Un valor de 0.5 entrega resultados balanceados, ni demasiado rígidos ni demasiado aleatorios.

El max_tokens define el largo máximo de la respuesta. Si lo dejas muy bajo, el bot corta frases; si lo subes mucho, gastas más en cada llamada.

Qué pasa al ejecutar Platzi Bot por primera vez

Al correr el código y abrir Telegram, puedes hacer la primera pregunta. Por ejemplo: ¿qué curso me recomiendas para aprender HTML?

El modelo responde algo como Te recomiendo el curso de HTML y CSS básico junto con un enlace. Hasta aquí, la integración funciona.

Sin embargo, aparece un detalle: la respuesta se repite con varios \n al final porque no configuraste un stop claro. Y como el bot consulta Telegram cada cierto tiempo, sigue leyendo la última pregunta una y otra vez, generando respuestas duplicadas [08:15].

Detalles de orden y typos en Python

Durante la programación es común olvidar una s en requests o escribir mal el nombre de una función como send_message cuando en realidad la definiste como send_messages. Python es estricto con la coherencia de nombres, así que revisa cada llamada.

Una coma faltante después del prompt o un strip mal escrito basta para romper la ejecución.

Cuéntame en los comentarios cómo te ha ido configurando tu bot y qué preguntas le estás haciendo a tu modelo.

Comentarios

Paolo Joaquin Pinto Perez

Estudiante

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

Estudiante

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

Nahuel Brandan

Estudiante

@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.

Joseph Corona

Estudiante

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

Rommer Batista

Estudiante

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

Johan Nicolás Valderrama Serrato

Estudiante

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

Manuel Oviedo

Estudiante

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

Sebastian Gaviria

Estudiante

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

Estudiante

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

Arístides Pérez Hernández

Estudiante

¿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.

Arístides Pérez Hernández

Estudiante

¿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.

Arístides Pérez Hernández

Estudiante

¿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.

Luis Miguel Rodríguez

Estudiante

Luis Miguel Rodríguez

Estudiante

•

aumente un poco la temperatura, y lo trate de sacar fuera de recomendaciones de cursos, y lo veo bien

Javier Lazaro

Estudiante

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

Diego Bustos Kehdy

Estudiante

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

Pablo Andrés Sánchez Zambrano

Estudiante

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

Estudiante

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

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)

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

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

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

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

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

OpenAI API

Análisis de sentimiento con la API de OpenAI

Uso de la Documentación de OpenAI para Fine Tuning y Text Completion

Roles en Chat Completions con GPT-3.5

Temperatura y top P en la API de OpenAI

Juego de adivinanza de animales con OpenAI en Python

Soft limit y hard limit en OpenAI

Actualización de Modelos y Funcionalidades de OpenAI

Fine-tuning de modelos de OpenAI

Cuándo hacer fine tuning a modelos OpenAI

Modelos de OpenAI para Fine-Tuning: Guía Completa

Estima costos en la API de OpenAI con tiktoken

Configuración de entorno local de OpenAI con Anaconda

Reglas para formatear datos en fine tuning de OpenAI

Validación y costo del fine-tuning en OpenAI

Fine-tuning de GPT-3.5 con datos propios

Uso del Playground de OpenAI para Probar Modelos sin Programación

Evaluación de Modelos de IA: Técnicas y Aplicaciones Prácticas

Temperatura y alucinaciones en fine tuning

Integración de modelo a aplicación de chat

Creación de Chatbots en Telegram con BotFather

Cómo leer mensajes de Telegram con Python

Cómo capturar mensajes de Telegram en Python

Conexión de PlatziBot con OpenAI usando Python