¿Cómo construir e implementar un bot de Telegram?

En este artículo, creará un bot de Telegram con Node.js y el backend como servicio de Back4app. Luego, lo implementará utilizando contenedores de Back4app.

Los bots son software que pueden realizar tareas repetitivas automatizadas en una red o en una plataforma. Los bots de Telegram se crean utilizando la API de bots de Telegram y están diseñados específicamente para funcionar en Telegram.

Puede diseñar bots de Telegram para realizar varias tareas en Telegram, como recuperar información como actualizaciones del clima o titulares de noticias y realizar cuestionarios para entretenimiento.

También pueden automatizar tareas como programar recordatorios y realizar autenticaciones simples de usuarios, entre otras cosas.

Configuración de su entorno de desarrollo

Este artículo presenta un bot de Telegram que permite a los usuarios configurar actualizaciones meteorológicas automáticas para su ciudad favorita cada 6 horas u obtener información meteorológica instantánea para cualquier ciudad que elijan.

Para configurar el directorio de su proyecto, ejecute los siguientes comandos:

# create your project directory
mkdir telegram-weather-bot

# cd into your project directory
cd telegram-weather-bot

# Initialize npm
npm init -y

Los comandos anteriores crean un directorio telegram-weather-bot, se mueven a él e inicializan npm en él.

En su archivo package.json, agregue el siguiente script de inicio para ejecutar su bot:

"start": "node server.js"

A continuación, ejecute el siguiente comando para instalar los paquetes necesarios para este proyecto:

npm install axios node-telegram-bot-api dotenv node-schedule parse

El comando anterior instaló los siguientes paquetes:

• axios: utilizará esta biblioteca para realizar solicitudes HTTP a una API meteorológica.

• node-telegram-bot-api: esta biblioteca simplifica la interacción con la API de Telegram Bot.

• dotenv: este paquete le ayudará a cargar variables de entorno desde un archivo.env.

• node-schedule: necesitará este paquete para programar tareas y automatizar sus actualizaciones meteorológicas.

• parse: Necesitará este paquete para interactuar con el backend Parse de Back4app.

Ahora que ya ha configurado su entorno de desarrollo, debe crear una cuenta de bot en Telegram.

Cómo crear su cuenta de bot de Telegram

Una cuenta de bot de Telegram servirá como identidad de su bot en la plataforma de Telegram. Los usuarios podrán interactuar con el bot a través de esta cuenta.

Para crear su bot de Telegram, inicia la aplicación Telegram, ingrese “BotFather” en la barra de búsqueda y haga clic en el resultado superior verificado.

BotFather es un bot de Telegram que le permite desarrollar otros bots rápidamente. Escriba el comando /newbot para iniciar el proceso de creación de su bot. Deberá proporcionar un nombre y un nombre de usuario único para su bot.

Una vez que proporcione el nombre y el nombre de usuario de su bot, BotFather le proporcionará un token único que le permitirá interactuar con la cuenta del bot y administrarla.

Guarde el token de su bot en su proyecto creando un archivo .env en el directorio raíz y pegando el token de bot en el archivo. De la siguiente manera:

TELEGRAM_BOT_TOKEN = <YOUR_BOT_TOKEN>

Ahora que tiene su token de bot y lo ha almacenado en su proyecto, puede construir su bot de Telegram.

Construyendo el Bot de Telegram

Esta sección lo guiará a través de la creación de su bot meteorológico de Telegram y la integración de las bibliotecas que instaló para realizar funciones como manejar comandos, administrar el estado del usuario y recuperar datos de la API meteorológica.

Estructura el directorio de su bot de manera similar al siguiente para comenzar el proceso de compilación:

telegram-weather-bot/
├── node_modules/          
├── src/                        
|   ├── bot.js                    # Archivo para gestionar la interacción del bot con el usuario
|   ├── weather.js                # Módulo para obtener datos meteorológicos  
|   ├── stateManager.js           # Módulo para gestionar el estado del usuario con Back4App
|   └── cityManager.js            # Administra la configuración de la ciudad del usuario y envía actualizaciones meteorológicas
├── .env                        
├── package.json                  
├── server.js                     # Punto de entrada para su aplicación
└── package-lock.json            

Obtener información meteorológica

Para obtener información meteorológica, utilizará la API de OpenWeatherMap.

Para realizar solicitudes a esta API, se necesita una clave API. Para obtenerla, inicie sesión en su cuenta (o cree una si no tiene una).

Luego, navegue a la sección “Mis claves API” en su perfil y copia su clave API.

Guarde la clave API de OpenWeatherMap en su archivo.env:

OPENWEATHERMAP_TOKEN = <YOUR_OPEN_WEATHER_MAP_APIKEY>

Dado que la funcionalidad del bot gira en torno a la obtención de información meteorológica, defina una función que realizará una solicitud GET a la API de OpenWeatherMap para recuperar información meteorológica con el método axios.get.

Agregue el bloque de código a continuación a su archivo weather.js para realizar una solicitud GET de información meteorológica desde la API OpenWeatherMap:

const axios = require('axios');
const apiKey = process.env.OPENWEATHERMAP_TOKEN;

async function getWeather(city) {
  try {
    const url = `https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey}&units=metric`;
    const response = await axios.get(url);
    const temp = response.data.main.temp;  
    const description = response.data.weather[0].description;  
    return `The weather in ${city} is ${temp}°C with ${description}.`;
  } catch (error) {
    console.error('Error fetching weather:', error);
    throw error;
  }
}

module.exports = { getWeather } 

El bloque de código anterior define una función getWeather que toma el nombre de una ciudad como argumento y devuelve la temperatura y la descripción del clima de la respuesta de la API.

Para proporcionar a los usuarios actualizaciones meteorológicas periódicas cada 6 horas, deberá implementar una función de programación que ejecutará la función getWeather para devolver actualizaciones meteorológicas para una ciudad preferida.

Programación de actualizaciones meteorológicas

Para programar la tarea de devolver las actualizaciones meteorológicas de una ciudad preferida, agregue el bloque de código a continuación en su cityManager.js:

const schedule = require('node-schedule');
const weather = require('./weather');

let userCities = {};

function setCity(chatId, city) {
  userCities[chatId] = city;
}

function init(bot) {
  schedule.scheduleJob('0 */6 * * *', function() {
    for (let chatId in userCities) {
      const city = userCities[chatId];
      weather.getWeather(city).then(response => {
        bot.sendMessage(chatId, response);
      }).catch(error => {
        bot.sendMessage(chatId, "Failed to retrieve weather.");
      });
    }
  });
}

module.exports = { setCity, init };

El bloque de código anterior crea dos funciones: setCity e init.

El bloque de código declara un objeto userCities para rastrear las ciudades que interesan a los usuarios del bot asignando sus ID de chat de Telegram a los nombres de las ciudades mediante la función setCity.

Esta función permite que su bot mantenga la preferencia del usuario sobre la ciudad en la que desea recibir actualizaciones meteorológicas.

La función init del bloque de código configura una tarea programada cada 6 horas que itera sobre todos los identificadores de chat almacenados en userCities. La función init utiliza el módulo meteorológico para obtener el clima actual de esa ciudad.

Su bot debe conservar el estado del usuario para realizar un seguimiento de los diferentes usuarios y sus ciudades preferidas. Puede lograrlo utilizando el backend de Back4app como servicio.

Para que su bot realice un seguimiento de diferentes usuarios y sus ciudades preferidas, almacene la ciudad preferida de un usuario bot utilizando el backend de Back4app como servicio.

Creación de un backend de Back4app

Para utilizar el backend de Back4app como servicio, necesita una cuenta de Back4app. Si no tiene una, puede registrarse de forma gratuita.

Inicie sesión en su cuenta y haga clic en el botón “NUEVA APLICACIÓN” en la esquina superior derecha. Asigne un nombre a su aplicación y haga clic en el botón “CREAR”.

Después de hacer clic en el botón “CREAR”, Back4app generará su aplicación y lo dirigirá al panel de la aplicación.

Para conectarse a la instancia de su aplicación en Back4App desde su proyecto Node.js, debe inicializar el SDK de análisis que instaló con las credenciales de la aplicación Back4app: ID de aplicación y CLAVE de JavaScript.

Obtenga el ID de la aplicación y la clave JavaScript de Back4app navegando a la sección “Seguridad y claves” haciendo clic en “Configuración de la aplicación” en la barra lateral.

Guárdelos en su archivo .env. Su archivo .env actual debería ser similar al que se muestra a continuación:

TELEGRAM_BOT_TOKEN= "<YOUR_TELEGRAM_BOT_TOKEN_HERE>"
OPENWEATHERMAP_TOKEN= "<YOUR_OPENWEATHERMAP_TOKEN_HERE>"
BACK4APP_APP_ID= "<YOUR_BACK4APP_APP_ID_HERE>"
BACK4APP_JAVASCRIPT_KEY= "<YOUR_BACK4APP_JAVASCRIPT_KEY_HERE>"

A continuación, debe crear una nueva clase “UserState” con dos campos: userId (cadena) y state (objeto). Para realizar esta tarea, utilizará el agente de inteligencia artificial de Back4app.

Para crear esta clase con los campos respectivos, navegue a la pestaña “AI Agent” en su pantalla y bríndele al agente el siguiente mensaje:

Cree una nueva clase, "UserState", en mi aplicación Back4app con el ID de la aplicación "<YOUR_BACK4APP_APP_ID_HERE>". La clase "UserState" tendrá dos campos: userId (cadena) y estado (objeto).

Versión en inglés

Create a new class, "UserState," in my Back4app application with the APP ID “<YOUR_BACK4APP_APP_ID_HERE>”. The "UserState" class will have two fields: userId (string) and state (object).

Debería obtener una respuesta similar a la imagen a continuación:

Si revisa el panel de Back4app, debería ver que la clase UserState se creó correctamente.

Cómo administrar el estado del usuario en su bot de Telegram

Para gestionar el flujo de interacción entre el usuario del bot y el bot, es necesario definir un estado de usuario que indique qué comando espera el bot del usuario.

Además del comando /start, el bot comprende dos comandos principales. Cada interacción del usuario (incluidos los comandos) activa una actualización del estado del usuario, que se almacena junto con su ID de chat en la clase UserState.

Esta gestión de estados permite al bot recordar detalles particulares de cada usuario dentro de una conversación, como su ciudad preferida para recibir actualizaciones meteorológicas.

Para comenzar a rastrear los estados de los usuarios con la clase UserState que creó en su base de datos Back4App, debe inicializar el Parse SDK con sus credenciales.

Agregue el bloque de código a continuación a stateManager.js para inicializar el SDK de Parse con las credenciales necesarias para conectarse al backend de Parse de Back4app:

// stateManager.js
const Parse = require('parse/node');

Parse.initialize(
  process.env.BACK4APP_APP_ID,
  process.env.BACK4APP_JAVASCRIPT_KEY
);

Parse.serverURL = '<https://parseapi.back4app.com/>';

A continuación, defina un objeto Parse en su archivo stateManager.js para representar el esquema de la clase UserState en el backend Parse de Back4app, lo que permite que su bot interactúe con el estado del usuario almacenado en la base de datos.

Así:

// stateManager.js
const UserState = Parse.Object.extend('UserState');

A continuación, deberá habilitar su bot para recuperar el estado de conversación actual de un usuario en particular en función de su ID de usuario almacenada en la base de datos.

Para recuperar el estado de un usuario, deberá ejecutar una consulta en la clase UserState con el ID del usuario para encontrar el estado guardado en la base de datos.

Así:

// stateManager.js
async function getUserState(userId) {
  const query = new Parse.Query(UserState);
  query.equalTo('userId', userId.toString());
  const userState = await query.first();
  return userState ? userState.get('state') : null;
}

El bloque de código anterior define una función getUserState que obtiene de forma asincrónica los datos del estado del usuario.

La función construye una consulta para encontrar el objeto de estado del usuario según el argumento (userId) y recupera el estado del usuario si lo encuentra.

Después de recuperar el estado de un usuario, deberá habilitar su bot para actualizar el estado de la conversación asociada con ese usuario en función de su ID de usuario y la información de estado proporcionada.

Por ejemplo, actualizar el estado de la conversación permitirá que el bot actualice la ciudad preferida para recibir actualizaciones meteorológicas periódicas.

Así:

// stateManager.js
async function setUserState(userId, state) {
  const query = new Parse.Query(UserState);
  query.equalTo('userId', userId.toString());
  let userState = await query.first();

  if (!userState) {
    userState = new UserState();
    userState.set('userId', userId.toString());
  }

  userState.set('state', state);
  await userState.save();
}

La función en el bloque de código anterior construye una consulta para encontrar el objeto de estado del usuario según el userId, crea un nuevo objeto UserState si no existe ninguno, establece el atributo de estado y guarda el objeto en la base de datos.

A continuación, defina una función para restablecer el estado de un usuario agregando el siguiente bloque de código a su archivo stateManager.js:

// stateManager.js
async function resetUserState(userId) {
  await setUserState(userId, {});
}

La función resetUserState establece de forma asincrónica el estado de un usuario en un objeto vacío {} para restablecer el estado del usuario en la base de datos.

Asegúrese de que siempre haya un objeto de estado presente para realizar un seguimiento de las acciones de los usuarios de bot antiguos y nuevos. Agregue el siguiente bloque de código al archivo stateManager.js:

// stateManager.js
async function ensureUserState(userId) {
  let state = await getUserState(userId);
  if (!state) {
    await setUserState(userId, {});
  }
}

El bloque de código define una función ensureUserState que recupera el objeto de estado en función del ID de usuario, asegurándose de que existan datos de estado de usuario para el ID de usuario proporcionado en la clase UserState en el backend de Back4app Parse.

Obtiene el estado del usuario con la función getUserState y, si no existe ningún estado, establece el estado en un objeto vacío {} utilizando la función setUserState.

Exporta todas las funciones para poder utilizarlas en otros archivos fuente de Javascript:

// stateManager.js
module.exports = {
  getUserState,
  setUserState,
  resetUserState,
  ensureUserState,
};

Manejo de la interacción del usuario con el bot

Para permitir que su bot escuche los comandos start, getWeather y setCity, definirá oyentes de eventos para hacer coincidir el texto con los tres comandos para ejecutar funciones de devolución de llamada.

Esto permitirá que el bot realice tareas relacionadas con los comandos.

Para interactuar con la API de Telegram Bot y poder definir el comportamiento de su bot, importe la clase TelegramBot desde la biblioteca node-telegram-bot-api y cree una nueva instancia de la clase:

// bot.js
const TelegramBot = require('node-telegram-bot-api');
const token = process.env.TELEGRAM_BOT_TOKEN;
const bot = new TelegramBot(token, { polling: true });

El bloque de código anterior crea una nueva instancia de la clase TelegramBot con dos argumentos: el token del bot y un objeto.

El objeto establece el valor de sondeo en verdadero para permitir que el bot verifique continuamente los mensajes y las actualizaciones de los servidores de Telegram.

A continuación, importe los módulos que creó en este proyecto. Los usará para implementar las funciones del bot, como obtener actualizaciones meteorológicas, establecer una ciudad preferida y administrar el estado de un usuario.

Agregue el siguiente código a continuación para importar los módulos necesarios:

// bot.js
const weather = require('./weather');
const cityManager = require('./cityManager');
const stateManager = require('./stateManager');

El bloque de código anterior importa las funciones que creaste en todos los archivos fuente, lo que le permite llamar a estas funciones en su archivo bot.js.

Para configurar un comando, se utiliza el método onText disponible en la clase TelegramBot. Este método configura un receptor para implementar una función de devolución de llamada para ejecutar cierta lógica.

Agregue el bloque de código a continuación a su archivo bot.js para configurar un controlador de comando /start que el bot escuchará activamente con el método onText:

// bot.js

bot.onText(/\\/start/, async (msg) => {
    const welcomeMessage = "Welcome to the Weather Bot! Use the commands below to interact:\\n" +
    "/setCity - Set your preferred city for weather updates.\\n" +
    "/getWeather - Get instant weather information for any city.\\n";
    await bot.sendMessage(msg.chat.id, welcomeMessage);
    stateManager.ensureUserState(msg.chat.id);
});

El bloque de código anterior permitirá que el bot ejecute una función de devolución de llamada, enviando un mensaje de bienvenida al usuario que detalla cómo funciona el bot.

El bot establece el estado inicial del usuario con la función ensureUserState, lo que garantiza un borrón y cuenta nueva para cada interacción del usuario.

A continuación, agregue el bloque de código a continuación a su archivo bot.js para configurar un controlador de comando /setCity que el bot escuchará activamente con el método onText:

// bot.js

bot.onText(/\\/setCity$/, async (msg) => {
    stateManager.setUserState(msg.chat.id, { expect: 'SET_CITY' });
    bot.sendMessage(msg.chat.id, "Which city do you want to set as your preferred city for weather updates?");
});

El bloque de código anterior permite a los usuarios especificar su ciudad preferida para las actualizaciones meteorológicas con el comando “/setCity”.

Al recibir este comando, el bot actualiza el estado del usuario a “SET_CITY” usando la función setUserState y le solicita al usuario que ingrese la ciudad deseada.

Agregue el bloque de código a continuación a su archivo bot.js para configurar un controlador de comando /getWeather que el bot escuchará activamente con el método onText:

// bot.js
bot.onText(/\\/getWeather$/, async (msg) => {
    stateManager.setUserState(msg.chat.id, { expect: 'GET_WEATHER' });
    bot.sendMessage(msg.chat.id, "Which city do you want to get weather information for?");
});

El comando “/getWeather” hace que el bot actualice el estado del usuario a “GET_WEATHER” y le solicita que proporcione una ciudad para la que desea información meteorológica instantánea.

Manejo de mensajes entrantes

Para manejar los mensajes entrantes de su bot de Telegram, necesitará configurar un detector de eventos que active una función de devolución de llamada cada vez que el bot reciba un mensaje nuevo.

Agregue el bloque de código a continuación a su archivo bot.js para configurar un controlador de mensajes para escuchar comandos y respuestas del usuario:

// bot.js

// Handle incoming messages
bot.on('message', async (msg) => {
    if (msg.text.startsWith('/')) {
        // If the message is a command, reset the user state
        stateManager.resetUserState(msg.chat.id);
    } else {
        // If it's not a command, check user state
        const state = await stateManager.getUserState(msg.chat.id);
        if (state && state.expect === 'SET_CITY') {
            // If expecting SET_CITY, set city and reset state
            const city = msg.text;
            cityManager.setCity(msg.chat.id, city);
            bot.sendMessage(msg.chat.id, `City set to ${city}. You will receive weather updates every 2 minutes.`);
            stateManager.resetUserState(msg.chat.id);
        } else if (state && state.expect === 'GET_WEATHER') {
            // If expecting GET_WEATHER, get weather and reset state
            const city = msg.text;
            weather.getWeather(city).then(response => {
                bot.sendMessage(msg.chat.id, response);
            }).catch(error => {
                bot.sendMessage(msg.chat.id, "Failed to retrieve weather.");
            });
            stateManager.resetUserState(msg.chat.id);
        }
    }
});

// Initialize the init function from cityManager.js for regular weather updates
cityManager.init(bot);

El bloque de código configura un controlador de mensajes general que escucha los mensajes de texto que se le envían y actúa como el núcleo de la lógica de interacción.

Si un mensaje comienza con una barra diagonal (“/”), se considera un comando. En este caso, el controlador restablece el estado del usuario para garantizar un nuevo comienzo para el nuevo comando.

De lo contrario, el controlador verifica el estado actual del usuario (stateManager.getUserState) para comprender su intención.

Si el usuario pasa el comando “/setCity”, el controlador del bot utiliza cityManager.setCity para almacenar la ciudad elegida y confirma la actualización.

Si el usuario pasa el comando “/getWeather”, el controlador recupera la información meteorológica de la ciudad proporcionada utilizando la función weather.getWeather y envía la respuesta al usuario.

Luego, el bloque de código anterior ejecuta cityManager.init(bot) para ejecutar la tarea programada de recuperar actualizaciones meteorológicas para una ciudad preferida.

Ahora que ha terminado de manejar la lógica de su bot, configure un servidor para permitir que se ejecute cuando lo implemente en un contenedor Back4app.

Creación de un archivo de entrada

Creará un archivo de entrada que inicializará toda la aplicación del bot. Este archivo tendrá dos funciones.

• El archivo de entrada ejecutará la lógica del bot al requerir el archivo JavaScript que maneja cómo su bot interactúa con la API de Telegram y responde a los mensajes del usuario.

• El archivo de entrada también configurará un servidor para permitir que su bot se ejecute en un contenedor Back4app. Los contenedores Back4app requieren puertos expuestos para que la implementación de su aplicación sea exitosa.

Navegue hasta el archivo server.js dentro del directorio de su proyecto. Este archivo se encargará de la creación del servidor. Agregue el siguiente bloque de código en el archivo server.js:

const http = require('http');
require('./src/bot'); // Import bot logic
const port = 3000;

http
  .createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('My Telegram bot is running\\n');
  })
  .listen(port, () => {
    console.log(`Server running on port ${port}`);
  });

El bloque de código anterior configura un bot de Telegram para que se ejecute mediante la creación de un servidor HTTP simple. Este servidor actúa como un punto de entrada, lo que permite que el bot funcione dentro del entorno del contenedor.

El script importa la lógica central de su bot y especifica un puerto Back4app para permitir que su bot se implemente en un contenedor Back4app.

Después de crear el archivo de entrada, puede probar el bot de Telegram localmente antes de implementarlo en un contenedor Back4app.

Probando el bot de Telegram

Inicie su bot de Telegram ejecutando el siguiente comando:

node server.js

Para interactuar con su bot, abre la aplicación Telegram y busca el nombre de su bot en la barra de búsqueda. Ingrese al chat con su bot y envíe el comando /start.

El bot debería responder con un mensaje de bienvenida y una lista de comandos. Envíele un comando al bot.

El bot le permite configurar su ciudad preferida y recibir actualizaciones meteorológicas periódicas con el comando /setCity.

El comando /getWeather, como se muestra en la imagen de arriba, puede obtener instantáneamente información meteorológica para una ciudad en particular.

El bot debería comportarse de manera similar a lo que se muestra en la imagen de arriba, respondiendo a sus comandos e interactuando con usted según lo previsto.

Implementación del bot de Telegram en los contenedores de Back4App

Después de probar el bot y asegurarse de que funciona correctamente, puede implementarlo en los contenedores de Back4app. Para ello, primero deberá crear un Dockerfile para su proyecto.

En el directorio raíz de su proyecto, cree un archivo Dockerfile y agréguele el siguiente bloque de código:

# Specify base image
FROM node:18-alpine

# Specify the working directory
WORKDIR /app

# Copy package.json and package-lock.json
COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

# Run the app
CMD ["npm", "start"]

Después de crear el Dockerfile, envíe su repositorio local a GitHub para que sea accesible para su implementación en los contenedores de Back4app.

A continuación, instale la aplicación GitHub Back4App Containers en su cuenta de GitHub y otórguele a la aplicación los permisos necesarios para acceder al repositorio de código de su aplicación.

Una vez que haya terminado con la configuración de GitHub, navegue a la página de inicio de Back4app y haga clic en el botón “Nueva aplicación” en la esquina superior derecha de su pantalla.

Esto le llevará a una pantalla de inicialización, donde tendrás que elegir el tipo de aplicación que quieres crear. Selecciona la opción de agente Back4app, como se muestra en la imagen a continuación.

Cuando seleccione la opción Agente de Back4app, será redirigido a la página del agente de IA de Back4app.

Ingrese el mensaje a continuación para implementar su aplicación en los contenedores Back4app:

Deploy my "YOUR_REPOSITORY_URL" repository on GitHub to Back4App Containers.
Here are the required environmental variables:
TELEGRAM_BOT_TOKEN = "TELEGRAM_BOT_TOKEN"
OPENWEATHERMAP_TOKEN = "WEATHER_API_TOKEN"
BACK4APP_APP_ID = "BACK4APP_APP_ID"
BACK4APP_JAVASCRIPT_KEY = "BACK4APP_JAVASCRIPT_KEY"

Reemplace los marcadores de posición con sus valores reales. El mensaje anterior iniciará el proceso de implementación. Cuando finalice, el agente de IA responderá indicando que la implementación se realizó correctamente o que está pendiente.

Debería obtener una respuesta similar a la siguiente:

Si recibe una implementación pendiente, puede supervisar el estado de implementación de su aplicación en el panel de control del contenedor Back4app. De manera alternativa, puede implementar su aplicación manualmente en los contenedores Back4app.

Conclusión

En este artículo, aprendió a crear un bot de Telegram con Node.js. Descubrió cómo crear una cuenta de bot de Telegram, manejar comandos de bot y manejar interacciones de usuarios.

También creó un backend para su bot con la ayuda del agente de inteligencia artificial Back4app, que le permitió administrar el estado del usuario de manera efectiva y almacenar información en conversaciones, como la ciudad preferida del usuario para recibir actualizaciones meteorológicas periódicamente.

Puede encontrar el código completo en este repositorio de GitHub.