Il mio Bot Python: Configurazione Rapida con l’API di Telegram

Va bene, gente, Marcus Rivera qui, di nuovo su ai7bot.com, e oggi ci tufferemo a capofitto in qualcosa che ha attirato la mia attenzione nei miei circoli di sviluppo, soprattutto quando voglio far partire un bot rapidamente senza troppi fronzoli. Stiamo parlando dell’spesso sottovalutato, a volte trascurato, ma sempre presente, Telegram Bot API. In particolare, voglio parlarvi di come realizzare un bot semplice, ma sorprendentemente potente, in pochi minuti utilizzando Python e il Telegram Bot API senza bisogno di un server web completo o di un deployment complesso.

Sì, lo so. “I bot di Telegram” potrebbero sembrare un po’ del 2018 per alcuni di voi, ma ascoltatemi. Mentre i bot di Discord ricevono molte attenzioni (e per buone ragioni, ne ho costruiti molti), c’è un punto dolce per Telegram quando hai bisogno di qualcosa di personale, veloce e altamente interattivo con un overhead minimo. Pensateci: un bot di monitoraggio per il vostro server di casa, un’utility rapida per il gruppo della vostra famiglia, o persino un semplice sistema di notifiche per la vostra strategia di trading. Non sempre avete bisogno di un contenitore Docker e di Kubernetes per questo. A volte, uno script Python in esecuzione su un Raspberry Pi o anche un ambiente di hosting condiviso è tutto ciò di cui avete bisogno, ed è qui che Telegram si distingue davvero.

Il mio percorso personale con questo si è riacceso alcuni mesi fa. Stavo cercando di costruire un piccolo bot per un progetto comunitario locale – essenzialmente, un modo semplice per i membri di richiedere aggiornamenti su specifici traguardi del progetto. Ho iniziato a guardare a Discord, ma l’overhead per impostare intenti, permessi e gestire interazioni potenzialmente complesse con il server sembrava eccessivo per quello che era essenzialmente un push informativo unidirezionale con una semplice query. Mi è tornato in mente un vecchio bot di Telegram che avevo costruito anni fa per tracciare gli ordini di caffè (non chiedete), e ho pensato, “Perché no?” La semplicità dell’API, specialmente il suo meccanismo di long-polling, mi ha colpito di nuovo. Significava che non dovevo esporre un server web a Internet, il che rappresenta un enorme vantaggio in termini di sicurezza e deployment per piccoli progetti personali.

Quindi, oggi, costruiremo un bot Telegram “Quick-Query”. Questo bot permetterà sostanzialmente agli utenti di richiedere informazioni predefinite, agendo come una super semplice FAQ o recuperatore di dati. Useremo Python e la libreria python-telegram-bot, che, secondo me, rende interagire con il Telegram Bot API un piacere.

Perché il Long-Polling di Telegram è ancora fantastico per i piccoli bot

Siamo chiari: Telegram offre due modi principali per ricevere aggiornamenti dal tuo bot: Webhook e Long Polling. I webhook sono fantastici quando hai un server pubblico in grado di ricevere richieste HTTP POST da Telegram. Sono efficienti perché Telegram invia aggiornamenti in tempo reale. Tuttavia, se non hai un IP pubblico o non vuoi gestire reverse proxy, certificati SSL e porte in esposizione, i webhook diventano un mal di testa.

Entra in gioco il Long Polling. Con il long polling, il tuo script bot fa una richiesta ai server di Telegram e fondamentalmente dice: “Ehi, hai messaggi nuovi per me?” Telegram tiene quella connessione aperta per un po’ (fino a 60 secondi per impostazione predefinita). Se nel frattempo arriva un nuovo messaggio, Telegram lo invia immediatamente. Se no, la connessione alla fine scade e il tuo script fa semplicemente un’altra richiesta. È come bussare ripetutamente a una porta e aspettare, ma la persona dentro è super veloce a rispondere se ti sente. La bellezza qui è che il tuo script avvia la connessione, il che significa che può funzionare quasi ovunque con accesso a Internet – il tuo laptop, un VPS economico, persino un Raspberry Pi nascosto nel tuo armadio. Non c’è bisogno di port forwarding o di esporre nulla a Internet aperto.

Impostare il tuo bot Telegram: le basi

Prima di scrivere codice, hai bisogno di un token per il bot. Questa è l’identità del tuo bot e la sua chiave per interagire con il Telegram API.

1. Apri Telegram e cerca @BotFather.
2. Inizia una chat con BotFather e invia il comando /newbot.
3. BotFather chiederà un nome per il tuo bot (ad esempio, “AI7Bot Helper”).
4. Poi, chiederà un username (deve terminare con “bot”, ad esempio, “AI7BotHelper_bot”).
5. Una volta forniti questi dati, BotFather ti darà un token API HTTP. Sembra qualcosa del tipo 1234567890:ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghij. Conserva questo token segreto! Se qualcuno lo ottiene, può controllare il tuo bot.

Questo è tutto per il lato Telegram! Semplice, giusto?

Codifica il nostro bot Quick-Query

Utilizzeremo Python e la libreria python-telegram-bot. Prima di tutto, assicurati di averla installata:

pip install python-telegram-bot==20.X # Usa l'ultima versione stabile principale

Sto usando la versione 20.x per questo esempio, che ha alcune belle funzionalità async moderne. Se sei su una versione più vecchia, alcune sintassi potrebbero differire leggermente, quindi consiglio di aggiornare.

Passo 1: La struttura di base e gli import

Iniziamo con il boilerplate base per un’applicazione python-telegram-bot.

import asyncio
import logging
import os # Per le variabili d'ambiente

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

# Configura il logging
logging.basicConfig(
 format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 level=logging.INFO
)
logger = logging.getLogger(__name__)

# --- Configurazione ---
# È una buona pratica tenere il token del tuo bot fuori dal codice stesso.
# Useremo una variabile d'ambiente.
BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")

if not BOT_TOKEN:
 logger.error("Variabile d'ambiente TELEGRAM_BOT_TOKEN non impostata. Uscita.")
 exit(1)

# --- Definisci i nostri dati di query ---
# Qui risiede la conoscenza del nostro bot.
QUERY_DATA = {
 "hello": "Ciao! Sono il tuo aiuto Quick-Query di AI7Bot.",
 "status": "Tutti i sistemi nominali per AI7Bot.com!",
 "features": "Posso parlarti di 'hello', 'status' e 'features'. Prova a chiedermi qualcosa di specifico!",
 "marcus": "Marcus è la mente dietro ai7bot.com, sempre intento a sperimentare nuove idee per bot.",
 "date": f"La data di oggi è 2026-03-12. (Codificato per questo esempio, ma potrebbe essere dinamico!)"
}

# --- Funzioni Handler ---

async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Invia un messaggio di saluto quando viene emesso il comando /start."""
 user = update.effective_user
 await update.message.reply_html(
 f"Ehi, {user.mention_html()}! 👋 Sono il tuo bot Quick-Query. "
 "Chiedimi di 'hello', 'status', 'features', 'marcus' o 'date'."
 )

async def query_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Risponde alle query degli utenti in base ai dati predefiniti."""
 user_message = update.message.text.lower().strip()
 logger.info(f"Richiesta ricevuta da {update.effective_user.username}: {user_message}")

 response = QUERY_DATA.get(user_message, "Mi dispiace, non ho informazioni su questo. Prova 'features' per vedere cosa so!")
 await update.message.reply_text(response)

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Invia un messaggio di aiuto quando viene emesso il comando /help."""
 await update.message.reply_text(
 "Sono un semplice bot Quick-Query! "
 "Puoi chiedermi di argomenti predefiniti come 'hello', 'status', 'features', 'marcus' o 'date'.\n"
 "Scrivi direttamente la tua query."
 )

async def echo_unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Risponde ai messaggi sconosciuti e richiama aiuto."""
 await update.message.reply_text("Non ho capito. Prova con '/help' per vedere cosa posso fare.")

async def main() -> None:
 """Avvia il bot."""
 application = Application.builder().token(BOT_TOKEN).build()

 # Registra gli handler
 application.add_handler(CommandHandler("start", start_command))
 application.add_handler(CommandHandler("help", help_command))
 
 # Gestore messaggi per le nostre query - corrisponderà a qualsiasi messaggio di testo
 # che non è un comando.
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, query_handler))

 # Cattura tutti i messaggi sconosciuti (non-comandi, non gestiti da query_handler)
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo_unknown)) # Questo potrebbe necessitare di un ordinamento attento
 # Per ora, se query_handler non corrisponde, arriverà qui.
 # Un approccio migliore per messaggi sconosciuti generali potrebbe essere metterlo DOPO query_handler
 # e garantire che query_handler abbia un filtro più specifico se necessario.
 # Per questo semplice esempio, lasciamo che query_handler gestisca tutto il testo non comando e risponda.

 logger.info("Bot in avvio in modalità long polling...")
 application.run_polling(allowed_updates=Update.ALL_TYPES) # Inizia a interrogare gli aggiornamenti

if __name__ == "__main__":
 asyncio.run(main())

Una nota veloce sull’ordinamento del MessageHandler: la libreria python-telegram-bot elabora gli handler nell’ordine in cui vengono aggiunti. Nel nostro esempio, query_handler è progettato per catturare qualsiasi messaggio di testo che non sia un comando. Se una query corrisponde, risponde. Se non corrisponde ai nostri QUERY_DATA, risponde comunque con un messaggio di “Mi dispiace, non ho informazioni…”. Pertanto, l’handler echo_unknown che cattura `filters.TEXT & ~filters.COMMAND` potrebbe non essere strettamente necessario come handler separato se `query_handler` gestisce già tutti tali casi con una risposta di fallback. L’ho lasciato con un commento per evidenziare come potresti usarlo per un routing più complesso in seguito, ma per questo specifico esempio, il `query_handler` è abbastanza completo per i messaggi di testo.

Passo 2: Esecuzione del tuo bot

Prima di eseguirlo, devi impostare il tuo token del bot come variabile d’ambiente. Su Linux/macOS:

export TELEGRAM_BOT_TOKEN="YOUR_BOT_TOKEN_HERE"
python your_bot_script.py

Su Windows (Prompt dei comandi):

set TELEGRAM_BOT_TOKEN="YOUR_BOT_TOKEN_HERE"
python your_bot_script.py

Sostituisci YOUR_BOT_TOKEN_HERE con il token reale che hai ottenuto da BotFather. Poi, esegui semplicemente il tuo script Python.

Apri Telegram, cerca il nome utente del tuo bot e inizia una chat. Prova a inviare /start, poi hello, status, o qualsiasi delle parole chiave definite in QUERY_DATA. Vedrai il tuo bot rispondere quasi immediatamente!

Espandere il tuo Bot di Richiesta Veloce: Idee Pratiche

Questo semplice framework è incredibilmente flessibile. Ecco alcuni modi in cui l’ho usato o considerato di utilizzare questo esatto schema:

1. Monitoraggio dello Stato del Server

Invece di hardcodificare "Tutti i sistemi nominali...", potresti far eseguire al bot un controllo rapido. Ad esempio, se stai monitorando un server locale:

# All'interno di query_handler, se user_message == "server_status":
import subprocess

async def get_server_status():
 try:
 # Esempio: controlla se un servizio è in esecuzione (es. Nginx)
 result = subprocess.run(['systemctl', 'is-active', 'nginx'], capture_output=True, text=True, check=True)
 if "active" in result.stdout:
 return "Nginx è in esecuzione! ✅"
 else:
 return "Nginx non è attivo. ❌"
 except subprocess.CalledProcessError:
 return "Impossibile controllare lo stato di Nginx. 'systemctl' è disponibile?"
 except Exception as e:
 return f"È occorso un errore: {e}"

# Poi, nel tuo query_handler:
if user_message == "server_status":
 response = await get_server_status()
 await update.message.reply_text(response)

Questo ti permetterebbe di interrogare direttamente lo stato attuale di un servizio da Telegram. Immagina di configurarlo su un Raspberry Pi a casa!

2. Bot Semplice per Promemoria

Potresti aggiungere un comando come /remind me to [task] in [X] minutes. Questo comporterebbe il parsing del tempo e del compito, quindi usare asyncio.sleep di Python per aspettare e inviare un messaggio all’ID chat dell’utente.

# (Esempio semplificato, gestione errori e parsing corretto necessari)
import re
import asyncio

async def remind_me_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 args = context.args # Ottieni gli argomenti dopo il comando
 if not args or len(args) < 4 or args[0] != "me" or args[1] != "to" or args[-2] != "in":
 await update.message.reply_text("Uso: /remind me to [task] in [X] minutes")
 return

 try:
 delay_minutes = int(args[-1])
 task_parts = args[2:-2]
 task = " ".join(task_parts)

 await update.message.reply_text(f"Va bene, ti ricorderò di '{task}' tra {delay_minutes} minuti.")
 
 # Ottieni l'ID chat per inviare il promemoria dopo
 chat_id = update.effective_chat.id 

 # Pianifica il promemoria
 await asyncio.sleep(delay_minutes * 60) # Converti minuti in secondi
 await context.bot.send_message(chat_id=chat_id, text=f"Promemoria: {task}!")

 except ValueError:
 await update.message.reply_text("Per favore specifica un numero valido di minuti.")
 except Exception as e:
 logger.error(f"Errore in remind_me_command: {e}")
 await update.message.reply_text("Qualcosa è andato storto con il tuo promemoria.")

# In main():
# application.add_handler(CommandHandler("remind", remind_me_command))

Questo utilizza context.bot.send_message che consente al tuo bot di inviare un messaggio a un ID chat specifico, anche se non è in risposta a un messaggio immediato dell'utente.

Considerazioni Pratiche per il Tuo Prossimo Progetto Bot

Se stai cercando di costruire qualcosa di veloce, personale, o semplicemente non vuoi il fastidio della configurazione del server, ecco cosa ti consiglio:

1. Adotta il Long Polling per Semplicità: Per strumenti interni, assistenti personali o piccoli bot per comunità, il long polling è un modo fantastico per evitare di esporre porte o affrontare distribuzioni complesse. Il tuo bot può funzionare su quasi qualsiasi dispositivo con accesso a Internet.
2. Comincia in Piccolo con python-telegram-bot: Questa libreria è incredibilmente ben documentata e rende l'interazione con l'API di Telegram semplice. Non cercare di costruire tutto in una volta; inizia con un singolo comando o una semplice richiesta.
3. Usa Variabili d'Ambiente per i Token: Non hardcodare mai il token del tuo bot. Usare os.getenv() è una pratica standard e sicura.
4. Pensa al Tuo Caso d'Uso: I bot di Telegram eccellono nelle interazioni rapide, nelle notifiche e nel recupero semplice dei dati. Se hai bisogno di elementi UI complessi, condivisione di media ricchi o integrazione profonda con altri servizi web che richiedono endpoint pubblici costanti, allora i webhooks o altre piattaforme potrebbero adattarsi meglio. Ma per molti bot utilitari, Telegram è perfetto.
5. Rimani Asincrono: La libreria python-telegram-bot è costruita su asyncio. Familiarizza con async def e await, soprattutto se il tuo bot deve eseguire operazioni che richiedono tempo (come fare una richiesta web, controllare un database, o, come nel nostro esempio di promemoria, attendere un ritardo).

Ecco fatto. Un nuovo sguardo alla costruzione di un pratico bot di Telegram che salta i problemi legati alla distribuzione e si concentra direttamente sulla fornitura di valore. Ho personalmente trovato questo approccio inestimabile per prototipare idee e creare utility utili senza lasciarmi sopraffare dall'infrastruttura. Provalo e fammi sapere che tipo di bot di Richiesta Veloce finisci per costruire!

🕒 Published: April 3, 2026