Ciao, agente in formazione! Emma qui, tornata da un’altra immersione notturna nel mondo affascinante, talvolta frustrante, degli agenti IA. Se sei come me, hai probabilmente trascorso gli ultimi mesi a sentire mormorii (o grida) riguardo agli agenti IA e ti sei detto: “Va bene, sembra interessante, ma… che cos’è davvero e come posso averne uno che faccia qualcosa per me?”
Bene, sei nel posto giusto. Oggi non parleremo semplicemente di ciò che sono gli agenti IA *in teoria*. Ci metteremo all’opera e affronteremo una domanda che preoccupa molti di voi (e me, fino a poco tempo fa): Come costruire un agente IA semplice che possa realmente navigare su Internet per me e rispondere a domande specifiche?
Dimentichiamo l’entusiasmo per un momento. Ci concentreremo sul pratico. Puntiamo a: “Posso davvero farlo funzionare sul mio laptop.” Perché, onestamente, vedere è credere, giusto?
I miei errori (e successi) con il browser
Quando ho iniziato a sperimentare con l’idea di un agente in grado di utilizzare Internet, avevo grandi visioni. Volevo che cercasse argomenti complessi, confrontasse prezzi su una dozzina di siti, e fosse essenzialmente il mio assistente digitale personale. Ciò che ho ottenuto, all’inizio, è stato un sacco di errori, alcuni scraper web rotti e un profondo senso di inadeguatezza. I miei primi tentativi erano come cercare di insegnare a un bambino piccolo a manovrare una macchina complessa: tanto entusiasmo, nessuna comprensione dei meccanismi sottostanti.
Il maggiore ostacolo? Far sì che un modello IA interagisca con Internet in modo significativo e controllato. È una cosa porre una domanda a ChatGPT a cui già conosce la risposta. È un’altra cosa chiedergli di cercare nuove informazioni, interpretarle e poi agire di conseguenza. È qui che la parte “agente” entra davvero in gioco.
Dopo molti tentativi ed errori, ho capito che la chiave non era costruire un’entità super complessa e onnisciente fin dall’inizio. Bisognava partire da piccoli, con un compito molto specifico, e sviluppare da lì. E questo è esattamente ciò che faremo oggi. Creeremo un agent browser di base che può navigare su un sito web specifico, estrarre informazioni e fare un rapporto.
Che cos’è un agente IA di navigazione?
Prima di esplorare il codice, chiarifichiamo rapidamente. Un agente IA, alla sua base, è un programma IA progettato per svolgere un compito specifico in modo autonomo. Osserva il suo ambiente (nel nostro caso, Internet), prende decisioni basate sui suoi obiettivi e poi agisce. Un agente IA *navigatore* utilizza specificamente capacità di navigazione web come strumento.
Pensateci così: dite al vostro agente, “Trova il meteo attuale a Londra.” Invece di attingere semplicemente alle sue conoscenze interne, un agente navigatore aprirebbe (idealmente) un browser web, andrebbe su un sito meteo, troverebbe l’informazione e poi ve la comunicerebbe. È la differenza tra porre una domanda a un bibliotecario che già conosce la risposta, e chiedergli di andare a cercare un libro, leggere un capitolo specifico e poi riassumerlo per voi.
Per il nostro agente semplice, utilizzeremo alcune comuni librerie Python che rendono tutto questo processo molto meno intimidatorio.
Gli strumenti di cui avremo bisogno
Non hai bisogno di un supercomputer per questo. Solo la tua configurazione di sviluppo abituale. Ecco cosa utilizzeremo:
- Python: Il nostro linguaggio di programmazione preferito. (Io uso la versione 3.9, ma la 3.8+ dovrebbe andare bene.)
requests: Una libreria fantastica per effettuare richieste HTTP (cioè recuperare pagine web).BeautifulSoup(bs4): È il nostro mago del parsing web. Ci aiuta a navigare ed estrarre dati da HTML.- Un API di Grande Modello Linguistico (LLM): Avremo bisogno di accesso a un LLM come i modelli GPT di OpenAI o Claude di Anthropic. Per questo tutorial, presupporrò che abbiate una chiave API OpenAI.
Prima di tutto, prepariamo il nostro ambiente. Se non hai queste librerie installate, apri il tuo terminale o il prompt dei comandi ed esegui:
pip install requests beautifulsoup4 openai
Assicurati di avere la tua chiave API OpenAI a portata di mano. Dovresti impostarla come variabile d’ambiente o passarla direttamente nel tuo script. Per semplificare, la mostrerò direttamente, ma in produzione, le variabili d’ambiente sono sempre migliori.
La nostra missione: Trovare un articolo specifico su un blog
Fissiamo un obiettivo concreto e realizzabile. La missione del nostro agente sarà di:
- Andare su un blog specifico (utilizziamo un URL di blog fittizio per ora, o anche agent101.net se ti senti avventuroso!).
- Trovare un titolo di post di blog che contenga una parola chiave specifica (ad esempio, “principiante”).
- Estrarre l’URL di quel post di blog.
- Riassumere il contenuto di quel post di blog utilizzando un LLM.
È un ottimo punto di partenza perché combina l’interazione web con la comprensione del LLM. È come chiedere al tuo assistente digitale di “trovare l’ultimo articolo sugli agenti IA per principianti su agent101.net e dirmi di cosa si tratta.”
Passo 1: Recuperare la pagina web
Il primo passo per qualsiasi agente di navigazione è “vedere” la pagina web. Useremo la libreria requests per questo. Facciamo uno script semplice:
import requests
def fetch_webpage(url):
try:
response = requests.get(url)
response.raise_for_status() # Alza una HTTPError per risposte errate (4xx o 5xx)
return response.text
except requests.exceptions.RequestException as e:
print(f"Errore durante il recupero dell'URL {url}: {e}")
return None
# Utilizziamo un'URL di esempio per ora.
# Sostituisci con un reale URL di blog che ha articoli se vuoi testare!
blog_url = "https://www.example-blog.com/articles" # Usa un reale URL qui!
html_content = fetch_webpage(blog_url)
if html_content:
print("Contenuto della pagina web recuperato con successo.")
# Tratteremo questo contenuto nel passo successivo
else:
print("Recupero della pagina web fallito.")
Una nota rapida sugli URL: Affinché ciò funzioni, avrai bisogno di un reale URL di blog. Se non ne hai a disposizione, puoi usare un sito come `http://quotes.toscrape.com/` per testare lo scraping semplice, ma per post di blog, trova un vero blog. Anche questo sito, agent101.net, potrebbe funzionare se adatti i selettori CSS successivamente!
Passo 2: Analizzare l’HTML e trovare i link degli articoli
Ora che abbiamo l’HTML grezzo, è come avere un enorme libro senza indice. BeautifulSoup è il nostro indicizzatore. Dobbiamo dirgli come trovare i titoli degli articoli e i loro link corrispondenti.
Questa è la parte più delicata perché la struttura HTML di ogni sito web è diversa. Dovrai “ispezionare” l’elemento sul sito target. Fai clic destro su un titolo di articolo del tuo blog scelto e seleziona “Ispeziona” (o “Ispeziona elemento”). Cerca schemi comuni come i tag <h2> per i titoli, o i tag <a> per i link, spesso nidificati in un <div> con un nome di classe specifico.
Per la dimostrazione, supponiamo una struttura di blog comune in cui i titoli degli articoli si trovano nei tag <h2>, e i loro link si trovano in un tag <a> direttamente all’interno o precedendo questo.
from bs4 import BeautifulSoup
def find_article_links(html_content, keyword):
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# Questo è un esempio generico. Dovrai adattare i selettori in base al sito target.
# Modelli comuni: div con classe 'article-item', h2 con classe 'article-title', ecc.
# Supponiamo che gli articoli siano in elementi 'div' con classe 'post'
# e che i titoli siano in tag 'h2' all'interno di questi div, con un link al loro interno.
# Esempio: Cerca tutti i tag che potrebbero contenere titoli di articoli
# Poi controlla se sono collegati.
# Un approccio più solido potrebbe consistere nel trovare prima i contenitori:
article_containers = soup.find_all('div', class_='article-card') # Adatta questa classe!
if not article_containers:
# Torna a un'altra selezione se la prima non funziona
article_containers = soup.find_all('article') # Un altro tag comune
for container in article_containers:
title_tag = container.find('h2') # O 'h3', 'a', ecc.
link_tag = container.find('a', href=True) # Trova il primo link nel contenitore
if title_tag and link_tag:
title = title_tag.get_text(strip=True)
href = link_tag['href']
# Assicurati che l'URL sia assoluto se è relativo
if href.startswith('/'):
full_url = requests.compat.urljoin(blog_url, href)
else:
full_url = href
if keyword.lower() in title.lower():
article_data.append({'title': title, 'url': full_url})
return article_data
# ... (codice precedente per fetch_webpage) ...
if html_content:
search_keyword = "beginner" # Quale articolo stiamo cercando?
found_articles = find_article_links(html_content, search_keyword)
if found_articles:
print(f"\nArticoli trovati contenenti '{search_keyword}':")
for article in found_articles:
print(f"- Titolo : {article['title']}\n URL : {article['url']}")
# Per questo esempio, prendiamo semplicemente il primo trovato
target_article = found_articles[0]
else:
print(f"\nNessun articolo trovato contenente '{search_keyword}'.")
target_article = None
else:
target_article = None
Personalizzazione Cruciale: Le righe come soup.find_all('div', class_='article-card') e container.find('h2') sono segnaposto. Devi adattarle in base alla struttura HTML reale del blog che stai targeting. È qui che ispezionare la pagina web diventa essenziale. Il mio miglior consiglio è di iniziare in modo ampio (ad esempio, `soup.find_all(‘a’)` per ottenere tutti i link) e poi restringere con classi o ID.
Fase 3: Estrarre il Contenuto dell’Articolo Target
Una volta che abbiamo l’URL del nostro articolo target, dobbiamo recuperare il suo contenuto e poi estrarre il testo principale. Questo è spesso più facile che analizzare una pagina di indice, poiché la maggior parte del contenuto degli articoli si trova in un tag di contenuto principale <div> o <article>.
# ... (codice precedente) ...
import openai
import os
# Imposta la tua chiave API OpenAI
# Buona pratica: os.environ.get("OPENAI_API_KEY")
# Per questo esempio, assegnazione diretta:
openai.api_key = "YOUR_OPENAI_API_KEY" # SOSTITUISCI QUESTO CON LA TUA CHIAVE REALE!
def extract_article_text(article_url):
article_html = fetch_webpage(article_url)
if not article_html:
return None
soup = BeautifulSoup(article_html, 'html.parser')
# Questo dipende fortemente dalla struttura del sito web.
# Modelli comuni: trovare un div con classe 'entry-content', 'article-body', 'main-content'
# O solo i tag all'interno del tag principale dell'articolo.
# Proviamo a trovare le aree di contenuto comuni.
content_div = soup.find('div', class_='entry-content') # Comune per WordPress
if not content_div:
content_div = soup.find('article') # Un altro buon tag generale
if not content_div:
# In mancanza di altro, ottieni tutti i tag di paragrafo
paragraphs = soup.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
# Se abbiamo trovato un div/articolo specifico di contenuto, estraiamo tutto il testo dai paragrafi
paragraphs = content_div.find_all('p')
article_text = "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
return article_text
if target_article:
print(f"\nRecupero del contenuto per: {target_article['title']}")
article_text_content = extract_article_text(target_article['url'])
if article_text_content:
# print(article_text_content[:500]) # Mostra i primi 500 caratteri per verificare
print("\nTesto dell'articolo estratto con successo. Passiamo alla sintesi.")
else:
print("Fallimento nell'estrazione del testo dell'articolo.")
article_text_content = "" # Assicurati che non sia None per la fase successiva
else:
article_text_content = ""
Ancora una volta, la riga soup.find('div', class_='entry-content') è il tuo obiettivo principale per la personalizzazione. Usa l’ispezionatore del tuo browser!
Fase 4: Riassumere con un LLM
Infine, è il momento in cui facciamo intervenire l’intelligenza artificiale! Alimenteremo il testo estratto a un LLM e glielo chiederemo. È qui che “l’intelligenza” del nostro agente brilla davvero.
# ... (codice precedente) ...
def summarize_text_with_llm(text):
if not text:
return "Nessun testo fornito per il riassunto."
# Troncatura del testo se è troppo lungo per la finestra di contesto del modello
# GPT-3.5-turbo ha una finestra di contesto di 16k, ma è meglio rimanere ragionevoli.
# Per un principiante, puntare a 4000-8000 token è sicuro.
# Circa 1 token = 4 caratteri per testo in inglese.
max_tokens_for_input = 12000 # Adatta in base alla capacità del tuo modello e considerazioni di costo
if len(text) > max_tokens_for_input * 4: # Stima grossolana dei caratteri
text = text[:max_tokens_for_input * 4]
print(f"Avvertenza: testo troncato a ~{max_tokens_for_input} token per il trattamento LLM.")
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # O "gpt-4", "claude-3-opus-20240229", ecc.
messages=[
{"role": "system", "content": "Sei un assistente utile che riassume articoli di blog in modo conciso."},
{"role": "user", "content": f"Per favore, riassumi il seguente messaggio di blog per me:\n\n{text}"}
],
temperature=0.7, # Controllo della casualità. Più basso per riassunti più mirati.
max_tokens=500 # Token max per il riassunto stesso
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Errore API OpenAI: {e}")
return "Fallimento dovuto a un errore API."
except Exception as e:
print(f"Si è verificato un errore imprevisto durante il riassunto: {e}")
return "Fallimento dovuto a un errore imprevisto."
if article_text_content:
print("\nRichiesta di riassunto LLM...")
summary = summarize_text_with_llm(article_text_content)
print("\n--- Riassunto dell'Articolo ---")
print(summary)
else:
print("\nImpossibile riassumere: nessun contenuto d'articolo disponibile.")
Ecco fatto! Un agente IA basico ma funzionante che può navigare, estrarre e riassumere. Non è più solo teoria; è un pezzo di codice tangibile che puoi eseguire.
Mettere Tutto Insieme (Script Completo)
Ecco lo script completo per un facile copia e incolla e test. Non dimenticare di sostituire gli URL segnaposto e la tua chiave API OpenAI!
import requests
from bs4 import BeautifulSoup
import openai
import os
# --- Configurazione ---
# Sostituisci con l'URL del tuo blog. Assicurati che contenga articoli!
TARGET_BLOG_URL = "https://www.example-blog.com/articles"
SEARCH_KEYWORD = "beginner" # La parola chiave da cercare nei titoli degli articoli
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" # SOSTITUISCI QUESTO! O utilizza os.environ.get("OPENAI_API_KEY")
# Imposta la chiave API OpenAI
openai.api_key = OPENAI_API_KEY
# --- Funzioni di Supporto ---
def fetch_webpage(url):
"""Recupera il contenuto HTML di un'URL data."""
try:
response = requests.get(url, timeout=10) # Aggiunta di un timeout
response.raise_for_status()
return response.text
except requests.exceptions.RequestException as e:
print(f"Errore durante il recupero dell'URL {url} : {e}")
return None
def find_article_links(html_content, base_url, keyword):
"""Analizza l'HTML per trovare i titoli e gli URL degli articoli corrispondenti a una parola chiave."""
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# --- PUNTO DI PERSONALIZZAZIONE 1 : Regola questi selettori per il tuo blog target ---
# Ispeziona la pagina del blog per trovare i tag HTML e le classi corrette per i contenitori degli articoli, titoli e link.
article_containers = soup.find_all('div', class_='article-card') # Comune per le schede/anteprime degli articoli
if not article_containers:
article_containers = soup.find_all('article') # Un altro tag comune per articoli individuali
if not article_containers:
print("Avviso: Impossibile trovare i tag contenitore degli articoli comuni. Provo una ricerca più ampia.")
# Ritorna: controlla solo tutti i link che potrebbero essere link ad articoli
all_links = soup.find_all('a', href=True)
for link in all_links:
title_text = link.get_text(strip=True)
if keyword.lower() in title_text.lower():
href = link['href']
full_url = requests.compat.urljoin(base_url, href)
article_data.append({'title': title_text, 'url': full_url})
return article_data # Ritorna presto se sono stati trovati solo link generali
for container in article_containers:
# Cerca il titolo e il link in ogni contenitore
title_tag = container.find(['h2', 'h3', 'a']) # I titoli sono spesso in h2/h3 o direttamente linkati
link_tag = container.find('a', href=True)
if title_tag and link_tag:
title = title_tag.get_text(strip=True)
href = link_tag['href']
# Costruisci l'URL completo se è relativo
full_url = requests.compat.urljoin(base_url, href)
if keyword.lower() in title.lower():
article_data.append({'title': title, 'url': full_url})
return article_data
def extract_article_text(article_url):
"""Recupera una pagina di articolo ed estrae il contenuto testuale principale."""
article_html = fetch_webpage(article_url)
if not article_html:
return None
soup = BeautifulSoup(article_html, 'html.parser')
# --- PUNTO DI PERSONALIZZAZIONE 2 : Regola questi selettori per il contenuto principale dell'articolo ---
# Cerca l'area di contenuto principale dell'articolo (ad esempio, div con classe 'entry-content', 'article-body')
content_area = soup.find('div', class_='entry-content')
if not content_area:
content_area = soup.find('article', class_='main-article-content') # Un altro modello comune
if not content_area:
content_area = soup.find('div', id='content') # Ancora un altro ID comune
if content_area:
paragraphs = content_area.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
else:
# Ritorna: ottieni tutti i tag di paragrafo se l'area di contenuto specifica non è trovata
print(f"Avviso: Area di contenuto specifica non trovata per {article_url}. Estrazione di tutti i paragrafi.")
paragraphs = soup.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
def summarize_text_with_llm(text):
"""Utilizza un LLM per il testo fornito."""
if not text or len(text.strip()) < 50: # Lunghezza minima del testo per tentare un riassunto
return "Contenuto insufficiente per il riassunto."
# Troncamento semplice per rimanere nei limiti tipici della finestra di contesto
# Considera di utilizzare un vero contatore di token per maggiore precisione se necessario
max_chars_for_llm = 40000 # Circa 10k token per GPT-3.5-turbo 16k context
if len(text) > max_chars_for_llm:
print(f"Avviso: Testo troncato da {len(text)} a {max_chars_for_llm} caratteri per LLM.")
text = text[:max_chars_for_llm]
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # Puoi usare "gpt-4" se hai accesso e desideri una qualità migliore
messages=[
{"role": "system", "content": "Sei un assistente utile che riassume gli articoli di blog in modo conciso e chiaro."},
{"role": "user", "content": f"Per favore fornisci un riassunto conciso dell'articolo di blog seguente, evidenziando i punti chiave :\n\n{text}"}
],
temperature=0.6, # Un po' meno casuale per i riassunti
max_tokens=600 # Max token per il riassunto generato
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Errore API OpenAI : {e}")
return f"Fallimento a causa di un errore API : {e}"
except Exception as e:
print(f"Si è verificato un errore imprevisto durante il riassunto : {e}")
return f"Fallimento a causa di un errore imprevisto : {e}"
# --- Logica Principale dell'Agente ---
def run_browser_agent():
print(f"Avvio dell'agente di navigazione per {TARGET_BLOG_URL} per trovare articoli su '{SEARCH_KEYWORD}'...")
# Passo 1 : Recupera la pagina principale del blog
blog_html = fetch_webpage(TARGET_BLOG_URL)
if not blog_html:
print("L'agente non è riuscito a recuperare la pagina principale del blog. Uscita.")
return
# Passo 2 : Trova articoli corrispondenti alla parola chiave
found_articles = find_article_links(blog_html, TARGET_BLOG_URL, SEARCH_KEYWORD)
if not found_articles:
print(f"Nessun articolo trovato contenente '{SEARCH_KEYWORD}' su {TARGET_BLOG_URL}. L'agente ha terminato.")
return
print(f"\nTrovati {len(found_articles)} articoli potenziali contenenti '{SEARCH_KEYWORD}' :")
for i, article in enumerate(found_articles):
print(f"{i+1}. Titolo : {article['title']}\n URL : {article['url']}")
# Per questo esempio, trattiamo il primo articolo trovato
target_article = found_articles[0]
print(f"\nElaborazione del primo articolo trovato : '{target_article['title']}' a {target_article['url']}")
# Passo 3 : Estrai il contenuto dell'articolo target
article_content = extract_article_text(target_article['url'])
if not article_content:
print(f"L'agente non è riuscito a estrarre il contenuto di {target_article['url']}. Impossibile riassumere.")
return
print(f"\nContenuto dell'articolo estratto (prime 200 caratteri) : {article_content[:200]}...")
# Passo 4 : Riassumi il contenuto utilizzando LLM
print("\nRichiesta a LLM dell'articolo...")
summary = summarize_text_with_llm(article_content)
print("\n--- Rapporto Finale dell'Agente ---")
print(f"Titolo dell'Articolo : {target_article['title']}")
print(f"URL dell'Articolo : {target_article['url']}")
print("\nRiassunto :")
print(summary)
print("\n--- Compito dell'Agente Completato ---")
if __name__ == "__main__":
run_browser_agent()
Punti Chiave Azionabili per il Tuo Percorso di Agente
Questo piccolo progetto è solo la punta dell’iceberg, ma ti mostra i meccanismi di base. Ecco cosa ho imparato e cosa dovresti tenere a mente :
- Inizia Piccolo, Pensa Specifico : Non cercare di costruire Skynet fin dal primo giorno. Scegli un compito molto stretto e realizabile per il tuo agente. “Trovare una ricetta di lasagna vegana” è meglio di “cucina la cena per me.”
- Il Web Scraping è il Far West : Ogni sito web è diverso. PASSERAI tempo a ispezionare gli elementi nel tuo browser per ottenere i giusti selettori CSS o XPath. Questo è il lavoro di base, ma è essenziale. I siti web cambiano, quindi il tuo agente potrebbe richiedere aggiustamenti occasionali.
- La Gestione degli Errori è la Tua Amica : Le cose andranno male. I siti web saranno offline, la tua connessione internet si interromperà, le chiamate API falliranno. Aggiungi
try-exceptper gestire questi problemi in modo elegante. - I LLM sono Intelligenti, ma Hanno Bisogno di Direzione : La qualità del risultato del tuo LLM dipende fortemente dal tuo prompt. Sii chiaro, conciso e digli esattamente cosa ti aspetti. Inoltre, sii consapevole dei limiti della finestra di contesto e dei costi.
- Questa è una Fondazione : Abbiamo costruito un agente in un giro. I veri agenti coinvolgono spesso più passaggi, una logica condizionale (ad esempio, “se trovo questo, allora fai quello”) e memoria. Ma ora hai i mattoni di costruzione.
Spero che vedendo questo agente semplice prendere vita, il concetto intero di “agente IA” diventi un po’ meno misterioso. Non è magia; è solo un’automazione intelligente costruita su strumenti esistenti. Vai avanti, sperimenta e costruisci i tuoi piccoli assistenti digitali!
Buon coding,
Emma Walsh, agent101.net
Articoli Correlati
- Come gli Agenti IA padroneggiano più Lingue senza problemi
- Ho reso il mio Agente IA utile (ecco come)
- Ho costruito un Agente IA nel 2026: La mia opinione onesta
🕒 Published: