Ho creato un agente di IA per riassumere le mie notizie

Ciao, agente in formazione! Emma qui, di ritorno su agent101.net. Oggi voglio parlare di qualcosa che sta generando molto interesse sui miei canali Slack e nei miei progetti personali da alcuni mesi: fare in modo che un agente IA possa realmente fare qualcosa di utile per te, in modo coerente, senza bisogno di un dottorato in ingegneria dei prompt o di un allevamento di server nel tuo armadio. Più precisamente, esploreremo come creare un agente IA super semplice, a compito singolo, che recupera e riassume notizie specifiche per te – un piccolo segugio delle notizie, se preferisci.

Lo so, lo so. “Agente IA” suona ancora come qualcosa direttamente uscito da un film di fantascienza, vero? O forse hai già provato ChatGPT e ti sei chiesto: “Va bene, ma come posso far funzionare questa cosa da sola senza dover digitare ogni comando?” È esattamente il divario che colmeremo oggi. Il mio obiettivo per questo articolo è demistificare il processo e mostrarti che costruire un piccolo agente IA mirato non è così spaventoso come sembra. Pensa a questo come insegnare al tuo assistente digitale un trucco molto specifico e ripetibile.

Il mio stesso viaggio nel mondo degli agenti è iniziato, francamente, per pura frustrazione. Passavo troppo tempo a setacciare le notizie tech, cercando di trovare menzioni di aggiornamenti su modelli IA specifici o di nuovi framework per agenti. Avevo impostato avvisi Google, ma spesso erano troppo generici o lenti. Volevo qualcosa che comprendesse il contesto, potesse filtrare il rumore e fornirmi un riassunto conciso. Quindi, come ogni buon programmatore pigro (di cui sono fiero di essere!), ho pensato: “Deve pur esserci un modo per automatizzare tutto questo con un’IA.”

E c’era! Dopo alcuni falsi avvii, alcuni momenti di riflessione sulle chiavi API, e un buon numero di tentativi ed errori con diversi modelli di linguaggio di grandi dimensioni (LLMs), ho trovato uno schema che funziona. Non è un sistema multi-agenti che coordina compiti complessi, né scriverà il tuo prossimo romanzo. Ma è un punto d’ingresso perfetto per comprendere come questi elementi si assemblano per creare qualcosa di realmente utile.

Perché un agente “Segugio delle Notizie”?

Quando inizi, scegliere un progetto troppo ambizioso è un modo sicuro per scoraggiarsi. Ecco perché raccomando di partire con un agente a compito singolo. Il nostro agente “Segugio delle Notizie” è perfetto per diversi motivi:

• Obiettivo chiaro: Trovare notizie specifiche, riassumerle. Semplice.
• Risultato tangibile: Ottieni un riassunto che puoi veramente leggere.
• Si basa su dati esterni: Ti insegna come gli agenti interagiscono con il mondo esterno (recupero di informazioni).
• Utilizza LLMs per l’interpretazione: Il cuore della maggior parte degli agenti è un LLM che comprende e genera testo.
• Ripetibile: Una volta costruito, puoi eseguirlo quotidianamente, settimanalmente, o quando vuoi.

Immagina di svegliarti, e il tuo agente ha già preparato un breve digest delle ultime novità in “etica dell’IA nei grandi modelli di linguaggio” o “nuovi sviluppi nei sensori di guida autonoma.” Niente più bisogno di scorrere all’infinito blog tech generici. Questo è il sogno, ed è assolutamente fattibile.

L’anatomia del nostro agente Segugio delle Notizie

Ogni agente IA, indipendentemente dalla sua semplicità, di solito ha alcuni componenti chiave. Per il nostro Segugio delle Notizie, ecco di cosa avremo bisogno:

1. Il “Cervello” (LLM): Questo è il nostro modello di linguaggio di grandi dimensioni. Comprenderà ciò che cerchiamo e riassumerà le informazioni. Userò i modelli di OpenAI per questo esempio poiché sono ampiamente accessibili e hanno una buona documentazione, ma potresti optare per Claude di Anthropic o anche un modello open-source locale se ti senti avventuroso.
2. Gli “Occhi” (Recuperatore di informazioni): Il nostro agente ha bisogno di un modo per ottenere informazioni su Internet. Per le notizie, un lettore di feed RSS o una semplice libreria di scraping web farà al caso nostro. Terremo tutto semplice con un’API di notizie per coerenza.
3. Le “Istruzioni” (Prompt): È così che diciamo al LLM cosa fare. È cruciale per ottenere buoni risultati.
4. L’“Orchestratore” (Script Python): Un semplice script per collegare tutto, indicando all’agente quando recuperare e quando e dove visualizzare i risultati.

Non preoccuparti se questi termini ti sembrano un po’ complicati in questo momento. Divideremo ogni elemento.

Di cosa avrai bisogno prima di iniziare

• Python: Assicurati di avere Python 3.8+ installato.
• Una chiave API OpenAI: Puoi ottenerne una sulla piattaforma OpenAI. C’è un livello gratuito per i test iniziali, ma dovrai probabilmente aggiungere un metodo di pagamento per un uso prolungato. Tieni segreta questa chiave!
• Una chiave API di notizie (facoltativa ma consigliata): Servizi come NewsAPI.org o GNews API offrono livelli gratuiti perfetti per questo. Rende il recupero dei dati di notizie strutturate molto più facile rispetto a fare scraping web grezzo. Per questo tutorial, presumerò che tu abbia una chiave NewsAPI.org.
• Editor di testo basico: VS Code, Sublime Text, o anche Notepad andrà bene.

Passo 1: Configurazione del tuo ambiente

Prima di tutto, creiamo una nuova cartella per il nostro progetto e installiamo le librerie necessarie. Apri il tuo terminale o il prompt dei comandi:

mkdir news_hound_agent
cd news_hound_agent
python -m venv venv
source venv/bin/activate # Su Windows: venv\Scripts\activate
pip install openai requests python-dotenv

Stiamo installando:

• openai: Per interagire con i modelli di OpenAI.
• requests: Per effettuare richieste HTTP all’API di notizie.
• python-dotenv: Per conservare le nostre chiavi API in modo sicuro.

Successivamente, crea un file chiamato .env nella tua cartella news_hound_agent e aggiungi le tue chiavi API:

OPENAI_API_KEY="your_openai_api_key_here"
NEWS_API_KEY="your_newsapi_key_here"

Sostituisci i segnaposto con le tue reali chiavi. Assicurati di aggiungere .env al tuo file .gitignore se mai metterai questo progetto in un repository Git!

Passo 2: Costruzione del Recuperatore di Informazioni (Gli “Occhi”)

Creiamo un file Python chiamato news_fetcher.py. Questo modulo sarà responsabile del recupero degli articoli di notizie.

# news_fetcher.py
import requests
import os
from dotenv import load_dotenv

load_dotenv() # Carica le variabili d'ambiente dal file .env

NEWS_API_KEY = os.getenv("NEWS_API_KEY")
NEWS_API_URL = "https://newsapi.org/v2/everything"

def fetch_news(query, language='en', sort_by='relevancy', page_size=10):
 """
 Recupera articoli di notizie da NewsAPI.org basati su una query.
 """
 if not NEWS_API_KEY:
 print("Errore: chiave NEWS_API_KEY non trovata nel file .env.")
 return []

 params = {
 'q': query,
 'language': language,
 'sortBy': sort_by,
 'pageSize': page_size,
 'apiKey': NEWS_API_KEY
 }

 try:
 response = requests.get(NEWS_API_URL, params=params)
 response.raise_for_status() # Solleva un'eccezione per errori HTTP (4xx o 5xx)
 data = response.json()
 articles = data.get('articles', [])
 return articles
 except requests.exceptions.RequestException as e:
 print(f"Errore durante il recupero delle notizie: {e}")
 return []

if __name__ == "__main__":
 # Esempio di utilizzo quando esegui questo script direttamente
 search_term = "AI agents for personal productivity"
 articles = fetch_news(search_term, page_size=5)
 if articles:
 print(f"Trovati {len(articles)} articoli per '{search_term}':")
 for i, article in enumerate(articles):
 print(f"{i+1}. {article.get('title', 'Nessun titolo')} - {article.get('url', 'Nessun URL')}")
 else:
 print(f"Nessun articolo trovato per '{search_term}'.")

Questo script definisce una funzione fetch_news che prende una query (ad esempio, “etica dell’IA”) e restituisce una lista di dizionari di articoli. Ogni dizionario contiene informazioni come il titolo, la descrizione e l’URL. Il blocco if __name__ == "__main__": è solo per testare questo modulo in modo isolato.

Passo 3: Elaborazione del Prompt (Le “Istruzioni”)

È qui che entra in gioco la magia del LLM. Più il tuo prompt è buono, migliore sarà il tuo riassunto. Creiamo un file chiamato summarizer.py.

# summarizer.py
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def summarize_articles(articles, specific_focus="general overview"):
 """
 Riassume una lista di articoli di attualità utilizzando un LLM di OpenAI.
 Il parametro specific_focus aiuta a guidare il riassunto.
 """
 if not articles:
 return "Nessun articolo fornito."

 # Preparare gli articoli per il LLM
 article_texts = []
 for i, article in enumerate(articles):
 title = article.get('title', 'Nessun titolo')
 description = article.get('description', 'Nessuna descrizione')
 url = article.get('url', 'Nessun URL')
 article_texts.append(f"Articolo {i+1}:\nTitolo: {title}\nDescrizione: {description}\nURL: {url}\n---")

 combined_text = "\n\n".join(article_texts)

 # L'invito per il nostro LLM
 prompt = f"""
 Sei un analista di notizie esperto. Il tuo compito è rivedere i seguenti articoli di attualità e fornire un riassunto conciso.
 Il riassunto deve concentrarsi specificamente su "{specific_focus}".
 Estrai gli sviluppi chiave, le tendenze e gli annunci importanti legati a questo focus.
 Mantieni il riassunto sotto le 300 parole, usando un linguaggio chiaro e professionale.
 Se un articolo non è pertinente per il focus specifico, puoi menzionarlo brevemente o ometterlo.

 Articoli di attualità:
 {combined_text}

 Riassunto focalizzato su "{specific_focus}":
 """

 try:
 response = client.chat.completions.create(
 model="gpt-3.5-turbo", # Puoi usare "gpt-4" per una qualità migliore, ma è più costoso
 messages=[
 {"role": "system", "content": "Sei un riassuntore di notizie utile e conciso."},
 {"role": "user", "content": prompt}
 ],
 max_tokens=500, # Regola se necessario
 temperature=0.7 # Un po' creativo, ma sempre fattuale
 )
 summary = response.choices[0].message.content.strip()
 return summary
 except Exception as e:
 print(f"Errore durante il riassunto degli articoli: {e}")
 return "Impossibile generare il riassunto a causa di un errore."

if __name__ == "__main__":
 # Articoli fittizi di esempio per i test
 dummy_articles = [
 {"title": "L'IA nella sanità riceve un nuovo finanziamento", "description": "Gli investimenti aumentano nelle startup che utilizzano l'IA per la diagnosi.", "url": "http://example.com/ai-health"},
 {"title": "Nuovo modello di auto elettrica lanciato", "description": "Il marchio di lusso EV svela il suo ultimo veicolo con un'autonomia migliorata.", "url": "http://example.com/ev-car"},
 {"title": "Linee guida etiche sull'IA proposte dall'UE", "description": "L'Unione Europea redige regole rigorose per lo sviluppo responsabile dell'IA.", "url": "http://example.com/eu-ai"},
 ]
 focus = "etica e regolamentazione dell'IA"
 summary_result = summarize_articles(dummy_articles, focus)
 print(f"\n--- Riassunto per '{focus}' ---\n{summary_result}")

In questo script:

• Carichiamo la chiave API di OpenAI.
• summarize_articles prende una lista di articoli e una stringa specific_focus. Questo specific_focus è fondamentale! Indica al LLM quale angolo utilizzare durante il riassunto, evitando così output generici.
• L’invito è costruito con attenzione per dare al LLM un ruolo (“analista di notizie esperto”), istruzioni chiare (riassunto conciso, focus specifico, limite di parole) e il contenuto da elaborare.
• Utilizziamo gpt-3.5-turbo perché è un buon equilibrio tra costo e performance per questo compito. Sentitevi liberi di sperimentare con gpt-4 se volete riassunti più sfumati.

Passo 4: L’Organizzatore (Collegare Tutto)

Infine, creiamo il nostro script principale, main_agent.py, che chiamerà il nostro recuperatore e il nostro riassuntore.

# main_agent.py
from news_fetcher import fetch_news
from summarizer import summarize_articles
import datetime

def run_news_hound_agent(search_query, summary_focus):
 """
 Coordina il processo di recupero e riassunto delle notizie.
 """
 print(f"[{datetime.datetime.now()}] Avvio dell'agente News Hound...")
 print(f"Ricerca di: '{search_query}' con un focus su '{summary_focus}'")

 # Passo 1: Recuperare gli articoli di attualità
 print("Recupero degli articoli di attualità...")
 articles = fetch_news(search_query, page_size=10) # Recuperare 10 articoli

 if not articles:
 print("Nessun articolo trovato o si è verificato un errore durante il recupero. Uscita.")
 return

 print(f"Trovati {len(articles)} articoli pertinenti.")

 # Passo 2: Riassumere gli articoli
 print("Riassumendo gli articoli con il LLM...")
 summary = summarize_articles(articles, summary_focus)

 # Passo 3: Visualizzare i risultati
 print("\n--- Digest Quotidiano delle Notizie ---")
 print(f"Data: {datetime.date.today()}")
 print(f"Ricerca: {search_query}")
 print(f"Focus: {summary_focus}")
 print("\nRiassunto:")
 print(summary)
 print("\n--- Fine del Digest ---")

 # Facoltativo: Salvare in un file
 output_filename = f"digest_attualita_{datetime.date.today().isoformat()}.txt"
 with open(output_filename, "w", encoding="utf-8") as f:
 f.write(f"Digest Quotidiano delle Notizie per {datetime.date.today()}\n")
 f.write(f"Ricerca: {search_query}\n")
 f.write(f"Focus: {summary_focus}\n\n")
 f.write("Riassunto:\n")
 f.write(summary)
 f.write("\n\nTitoli degli articoli originali (per riferimento):\n")
 for article in articles:
 f.write(f"- {article.get('title', 'Nessun titolo')}\n")
 print(f"\nDigest salvato in {output_filename}")


if __name__ == "__main__":
 # Definire cosa il tuo agente deve cercare e su cosa concentrarsi
 my_search_query = "frameworks di agenti IA O orchestrazione LLM"
 my_summary_focus = "nuovi strumenti e metodi per costruire agenti IA"

 run_news_hound_agent(my_search_query, my_summary_focus)

Questo script orchestra l’intero processo:

• Definisce una funzione run_news_hound_agent che prende una search_query (cosa cercare nei titoli e nelle descrizioni delle notizie) e un summary_focus (su cosa il LLM deve mettere l’accento specificamente).
• Chiama fetch_news per ottenere gli articoli grezzi.
• Passa poi questi articoli e il focus a summarize_articles.
• Infine, stampa il riassunto nella console e lo salva in un file di testo per facilitare la lettura successiva.

Esecuzione del tuo agente News Hound!

Ora, apri il tuo terminale, assicurati che il tuo ambiente virtuale sia attivo e esegui:

python main_agent.py

Vedrai un output che indica che l’agente sta recuperando le notizie, poi riassume e infine, il tuo digest di notizie personalizzato stampato nella console e salvato come file! La prima esecuzione potrebbe richiedere qualche secondo poiché il LLM elabora la richiesta.

Ciò che mi piace di questo è la rapidità del ritorno delle informazioni. Immetti una richiesta, specifichi un focus, e bum – ottieni un riassunto personalizzato. Addio agli articoli generici. Per me, è stato un enorme momento di “eureka”. Non si trattava solo di conversare con un’IA; si trattava di far fare a un’IA un compito specifico e prezioso a mio nome.

Personalizzare ed Espandere il Tuo Agente

Questo è solo l’inizio! Ecco alcune idee per migliorare ulteriormente il tuo News Hound:

• Richieste/Focus multipli: Modifica main_agent.py per eseguire più richieste o focus diversi e generare più digest.
• Pianificazione: Usa strumenti come cron (Linux/macOS) o il Pianificatore di attività di Windows per eseguire main_agent.py automaticamente ogni mattina.
• Diversi LLMs: Sperimenta con altri LLMs. Forse Claude 3 Opus di Anthropic per contesti più lunghi o Llama 3 per un’elaborazione locale.
• Formati di output: Invece di un file di testo, salva l’output in formato HTML, file Markdown, o persino invialo tramite e-mail o su un canale Slack (in tal caso dovresti integrarti con queste API).
• Filtraggio contestuale: Prima di riassumere, potresti aggiungere un passaggio intermedio in cui il LLM (o un classificatore di testo più semplice) determina se ogni articolo recuperato è realmente pertinente per il tuo focus specifico, filtrando ulteriormente il rumore.
• Fonti di notizie avanzate: Esplora altre API di notizie o anche il web scraping di siti specifici (anche se dovresti stare attento ai termini di utilizzo!).

Il mio stesso News Hound si è evoluto a partire da questa configurazione di base. Ora l’ho programmato per funzionare ogni notte, scansionando gli aggiornamenti su framework di agenti specifici che monitoro, e mi invia un riassunto ogni mattina. Questo mi ha fatto risparmiare ore a filtrare i feed RSS e Twitter. È davvero diventato il mio assistente di ricerca digitale.

Punti da Ricordare

Allora, cosa dovresti ricordare di tutto questo?

1. Iniziare in piccolo, pensare in grande: Non cercate di costruire il prossimo AGI al primo tentativo. Un agente a obiettivo unico è un ottimo strumento di apprendimento.
2. Le richieste sono potenti: La qualità della vostra output è direttamente collegata alla chiarezza e alla specificità delle vostre richieste. Prendetevi il tempo per perfezionarle.
3. Le API sono vostre amiche: Gli LLM sono potenti, ma hanno bisogno di dati. Imparare a interagire con API esterne (come NewsAPI) è fondamentale.
4. Il codice è il legante: Python (o qualsiasi linguaggio di scripting) è ciò che trasforma una raccolta di componenti potenti in un agente funzionante.
5. Iterare e sperimentare: Non abbiate paura di cambiare modelli, modificare richieste o provare diverse fonti di dati. È così che scoprirete cosa funziona meglio per le vostre esigenze specifiche.

Costruire questo agente News Hound è un modo pratico e concreto per comprendere i concetti fondamentali dietro gli agenti IA. Vi mostra come collegare un LLM a strumenti esterni e automatizzare un compito utile. Questa conoscenza fondamentale è su cui costruirete mentre esplorerete sistemi multi-agente più complessi o integrerete agenti in applicazioni più ampie.

Fateci un tentativo! Potreste rimanere sorpresi da quanto velocemente potete creare il vostro piccolo assistente digitale. E come sempre, se incontrate un problema o scoprite un nuovo modo interessante per espandere questa idea, lasciate un commento qui sotto o trovatemi sui social media. Buon sviluppo di agenti!

Articoli Correlati

• Imparate l’IA: Il vostro percorso completo per principianti in IA 2026
• Agenti IA per principianti: La vostra guida amichevole
• Tutorial sugli agenti IA con esempi concreti

🕒 Published: April 4, 2026