Ho creato un agente AI per riassumere le mie notizie.

Ciao, agente in fase di formazione! Emma qui, di nuovo su agent101.net. Oggi voglio parlare di qualcosa che sta ronzando nei miei canali Slack e nei progetti personali negli ultimi mesi: far sì che un agente AI possa effettivamente fare qualcosa di utile per te, in modo coerente, senza bisogno di un dottorato in ingegneria dei prompt o di una server farm nel tuo armadio. In particolare, esploreremo come costruire un agente AI super semplice, a singolo compito, che recupera e riassume notizie specifiche per te – un piccolo segugio delle notizie personale, se vuoi.

Lo so, lo so. “Agente AI” suona ancora come qualcosa uscito da un film di fantascienza, giusto? O forse hai sbirciato ChatGPT e ti sei chiesto, “Va bene, ma come faccio a far funzionare questa cosa da sola senza che io debba digitare ogni singolo comando?” È esattamente questo il divario che vogliamo colmare oggi. Il mio obiettivo per questo articolo è demistificare il processo e mostrarti che costruire un piccolo agente AI focalizzato non è affatto spaventoso come sembra. Pensalo come insegnare al tuo assistente digitale un trucco molto specifico e ripetibile.

Il mio personale viaggio nel mondo degli agenti è iniziato, onestamente, per pura frustrazione. Stavo trascorrendo troppo tempo a setacciare le notizie tecnologiche, cercando di trovare menzioni di aggiornamenti specifici di modelli AI o nuovi framework per agenti. Avevo impostato Google Alerts, ma erano spesso troppo generali o troppo lenti. Volevo qualcosa che comprendesse il contesto, filtrasse il rumore e mi desse un riassunto conciso. Quindi, come qualsiasi buon programmatore pigro (che orgogliosamente affermo di essere!), ho pensato, “Deve pur esserci un modo per automatizzare questo con un AI.”

Ed effettivamente c’era! Dopo alcuni inizi falsi, qualche grattata di testa sugli API key e un bel po’ di tentativi ed errori con diversi modelli di linguaggio di grandi dimensioni (LLMs), ho trovato uno schema che funziona. Non si tratta di un sistema multi-agente che coordina compiti complessi, né scriverà il tuo prossimo romanzo. Ma è un punto di ingresso perfetto per comprendere come questi pezzi si assemblano per creare qualcosa di veramente utile.

Perché un Agente “Segugio delle Notizie”?

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

• Obiettivo Chiaro: Trovare notizie specifiche, riassumerle. Semplice.
• Output Tangibile: Ottieni un riassunto che puoi effettivamente leggere.
• Si basa su Dati Esterni: Ti insegna come gli agenti interagiscono con il mondo esterno (recuperando 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 ogni volta che vuoi.

Immagina di svegliarti, e il tuo agente ha già messo insieme un breve riepilogo di tutti i più recenti sviluppi in “etica AI nei modelli di linguaggio di grandi dimensioni” o “nuovi sviluppi nei sensori per conduzione autonoma.” Niente più scrolling infinito attraverso blog tecnologici generici. Questo è il sogno, ed è totalmente realizzabile.

L’Anatomia del Nostro Semplice Agente Segugio delle Notizie

Ogni agente AI, per quanto semplice, di solito ha alcuni componenti fondamentali. Per il nostro Segugio delle Notizie, ecco cosa ci servirà:

1. Il “Cervello” (LLM): Questo è il nostro modello di linguaggio di grandi dimensioni. Comprenderà cosa stiamo cercando e riassumerà le informazioni. Utilizzerò i modelli di OpenAI per questo esempio perché sono ampiamente accessibili e hanno una buona documentazione, ma potresti usare il Claude di Anthropic o persino 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 da Internet. Per le notizie, un lettore RSS o una semplice libreria di web scraping faranno al caso nostro. Lo terremo semplice utilizzando un’API per le notizie per coerenza.
3. Le “Istruzioni” (Prompt): Questo è il modo in cui diciamo all’LLM cosa fare. È fondamentale per ottenere buoni risultati.
4. L’“Orchestratore” (Script Python): Un semplice script per mettere tutto insieme, che dice all’agente quando recuperare, quando e dove outputtare i risultati.

Non preoccuparti se questi termini sembrano un po’ eccessivi in questo momento. Spiegheremo ogni pezzo.

Cosa Ti Servirà Prima di Iniziare

• Python: Assicurati di avere Python 3.8+ installato.
• Una Chiave API OpenAI: Puoi ottenerne una dalla piattaforma OpenAI. C’è un piano gratuito per i test iniziali, ma probabilmente dovrai aggiungere un metodo di pagamento per un uso sostenuto. Tieni questa chiave segreta!
• Una Chiave API per le Notizie (Opzionale ma Raccomandata): Servizi come NewsAPI.org o GNews API offrono piani gratuiti che sono perfetti per questo. Rende il recupero di dati strutturati sulle notizie molto più semplice rispetto al web scraping grezzo. Per questo tutorial, supporrò che tu abbia una chiave di NewsAPI.org.
• Un Editor di Testo di Base: VS Code, Sublime Text, o anche Notepad andranno bene.

Passo 1: Impostare il Tuo Ambiente

Prima di tutto, creiamo una nuova directory per il nostro progetto e installiamo le librerie necessarie. Apri il tuo terminale o 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 fare richieste HTTP all’API per le notizie.
• python-dotenv: Per salvare in modo sicuro le nostre chiavi API.

Successivamente, crea un file chiamato .env nella tua directory 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 chiavi reali. Assicurati di aggiungere .env al tuo file .gitignore se mai metti questo progetto in un repository Git!

Passo 2: Costruire il Recuperatore di Informazioni (Gli “Occhi”)

Creiamo un file Python chiamato news_fetcher.py. Questo modulo sarà responsabile per il 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 in base a una query.
 """
 if not NEWS_API_KEY:
 print("Errore: NEWS_API_KEY non trovato 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 nel recupero delle notizie: {e}")
 return []

if __name__ == "__main__":
 # Esempio di utilizzo quando si esegue questo script direttamente
 search_term = "Agenti AI per la produttività personale"
 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 AI”) e restituisce un elenco 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 isolamento.

Passo 3: Creare il Prompt (Le “Istruzioni”)

È qui che entra in gioco la magia dell’LLM. Maggiore è la qualità del tuo prompt, 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 un elenco di articoli di notizie 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)

 # Il prompt per il nostro LLM
 prompt = f"""
 Sei un'analista di notizie esperto. Il tuo compito è rivedere i seguenti articoli di notizie e fornire un riassunto conciso.
 Il riassunto dovrebbe concentrarsi specificamente su "{specific_focus}".
 Estrarre i principali sviluppi, tendenze e annunci importanti legati a questo argomento.
 Mantieni il riassunto sotto 300 parole, utilizzando un linguaggio chiaro e professionale.
 Se un articolo non è rilevante per il focus specifico, puoi menzionare brevemente il motivo o ometterlo.

 Articoli di notizie:
 {combined_text}

 Riassunto che si concentra su "{specific_focus}":
 """

 try:
 response = client.chat.completions.create(
 model="gpt-3.5-turbo", # Puoi utilizzare "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 comunque fattuale
 )
 summary = response.choices[0].message.content.strip()
 return summary
 except Exception as e:
 print(f"Errore nel riassumere gli articoli: {e}")
 return "Non è stato possibile generare il riassunto a causa di un errore."

if __name__ == "__main__":
 # Esempio di articoli fittizi per il test
 dummy_articles = [
 {"title": "AI in healthcare sees new funding", "description": "Gli investimenti aumentano nelle start-up che applicano l'AI per la diagnostica.", "url": "http://example.com/ai-health"},
 {"title": "New electric car model released", "description": "Il marchio di auto di lusso svela il suo ultimo veicolo con un'autonomia migliorata.", "url": "http://example.com/ev-car"},
 {"title": "Ethical AI guidelines proposed by EU", "description": "L'Unione Europea sta redigendo regole severe per lo sviluppo responsabile dell'AI.", "url": "http://example.com/eu-ai"},
 ]
 focus = "Etica e regolamentazione dell'AI"
 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 accetta un elenco di articoli e una stringa specific_focus. Questo specific_focus è fondamentale! Indica al LLM quale lente usare quando riassume, evitando output generici.
• Il prompt è attentamente costruito per dare al LLM un ruolo (“analista di notizie esperto”), istruzioni chiare (riassunto conciso, focus specifico, limite di parole) e il contenuto con cui lavorare.
• Usiamo gpt-3.5-turbo in quanto rappresenta un buon equilibrio tra costo e prestazioni per questo compito. Sentiti libero di sperimentare con gpt-4 se desideri riassunti più sfumati.

Passo 4: L’Orchestratore (Collegando tutto)

Infine, creiamo il nostro script principale, main_agent.py, che chiamerà il nostro fetcher e summarizer.

# 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):
 """
 Orchestra il processo di ricerca e riassunto delle notizie.
 """
 print(f"[{datetime.datetime.now()}] Avviando l'Agente News Hound...")
 print(f"Cercando: '{search_query}' con focus su '{summary_focus}'")

 # Passo 1: Recupera gli articoli di notizie
 print("Recuperando articoli di notizie...")
 articles = fetch_news(search_query, page_size=10) # Recupera 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: Riassumi gli articoli
 print("Riassumendo gli articoli con LLM...")
 summary = summarize_articles(articles, summary_focus)

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

 # Opzionale: Salva su un file
 output_filename = f"news_digest_{datetime.date.today().isoformat()}.txt"
 with open(output_filename, "w", encoding="utf-8") as f:
 f.write(f"Digest delle Notizie Giornaliero per {datetime.date.today()}\n")
 f.write(f"Query: {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__":
 # Definisci cosa dovrebbe cercare e su cosa dovrebbe concentrarsi il tuo agente
 my_search_query = "framework per agenti AI OR orchestrazione LLM"
 my_summary_focus = "nuovi strumenti e metodi per costruire agenti AI"

 run_news_hound_agent(my_search_query, my_summary_focus)

Questo script orchestra l’intero processo:

• Definisce una funzione run_news_hound_agent che accetta una search_query (cosa cercare nei titoli/descrizioni delle notizie) e un summary_focus (cosa l’LLM dovrebbe evidenziare specificamente).
• Chiama fetch_news per ottenere gli articoli grezzi.
• Passa quindi quegli articoli e il focus a summarize_articles.
• Infine, stampa il riassunto sulla console e lo salva in un file di testo per una lettura più facile in seguito.

Esegui il Tuo Agente News Hound!

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

python main_agent.py

Dovresti vedere un output che indica che l’agente sta recuperando notizie, poi riassumendo e infine, il tuo digest di notizie personalizzato stampato sulla console e salvato come file! La prima esecuzione potrebbe richiedere alcuni secondi mentre l’LLM elabora la richiesta.

Ciò che mi piace di questo è quanto sia immediato il feedback. Inserisci una query, specifichi un focus, e boom – ottieni un riassunto su misura. Niente più titoli generici. Per me, è stato un grande momento di “aha!”. Non si trattava solo di parlare con un’AI; si trattava di far sì che un’AI eseguisse un compito specifico e prezioso per conto mio.

Modificare e Ampliare il Tuo Agente

Questo è solo l’inizio! Ecco alcune idee per rendere il tuo News Hound ancora migliore:

• Più Query/Foci: Modifica main_agent.py per eseguire diverse query o foci e generare più digest.
• Pianificazione: Usa strumenti come cron (Linux/macOS) o Windows Task Scheduler per eseguire main_agent.py automaticamente ogni mattina.
• Differenti LLM: Sperimenta con altri LLM. 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 come HTML, un file Markdown o anche invialo via email o a un canale Slack (dovresti integrare con quelle API).
• Filtraggio Contestuale: Prima di riassumere, potresti aggiungere un passaggio intermedio in cui l’LLM (o un classificatore testuale più semplice) determina se ogni articolo recuperato è veramente pertinente al tuo specifico focus, filtrando ulteriormente il rumore.
• Fonti di Notizie Avanzate: Esplora altre API di notizie o anche il web scraping di siti specifici (fai attenzione ai termini di servizio!).

Il mio stesso News Hound è evoluto da questo setup di base. Ora lo eseguo ogni notte, controllando aggiornamenti su specifici framework per agenti che sto monitorando e mi invia una sintesi ogni mattina. Mi ha risparmiato ore di ricerca tra feed RSS e thread di Twitter. È davvero diventato il mio assistente di ricerca digitale.

Takeaways Azionabili

Quindi, cosa dovresti trarre da tutto ciò?

1. Inizia in Piccolo, Pensa in Grande: Non cercare di costruire il prossimo AGI al tuo primo tentativo. Un agente a scopo unico è un ottimo strumento di apprendimento.
2. I Prompt sono Potere: La qualità del tuo output è direttamente legata alla chiarezza e specificità dei tuoi prompt. Dedica tempo a perfezionarli.
3. Le API Sono i Tuoi Amici: Gli LLM sono potenti, ma hanno bisogno di dati. Imparare a interagire con API esterne (come NewsAPI) è fondamentale.
4. Il Codice è la Colla: Python (o qualsiasi linguaggio di scripting) è ciò che trasforma una raccolta di componenti potenti in un agente funzionante.
5. Itera e Sperimenta: Non aver paura di cambiare modelli, modificare prompt o provare fonti di dati diverse. È così che impari cosa funziona meglio per le tue specifiche esigenze.

Costruire questo agente News Hound è un modo pratico e diretto per comprendere i concetti fondamentali dietro gli agenti AI. Mostra come collegare un LLM a strumenti esterni e automatizzare un compito utile. Questa conoscenza fondamentale è ciò su cui costruirai mentre esplori sistemi multi-agente più complessi o integri agenti in applicazioni più ampie.

Provalo! Potresti rimanere sorpreso da quanto velocemente puoi mettere in funzione il tuo piccolo assistente digitale. E come sempre, se incontri un problema o scopri un modo interessante per estendere questo, lascia un commento qui sotto o trovalimi sui social media. Buona costruzione di agenti!

Articoli Correlati

• Impara l’AI: Il Tuo Percorso Completo per Principianti nel 2026
• Agenti AI per Principianti: La Tua Guida Amichevole
• Tutorial per Agenti AI con Esempi Reali

🕒 Published: April 4, 2026