Ciao, agente in addestramento! Emma qui, tornata da un’altra esplorazione notturna nel affascinante, a volte frustrante, mondo degli agenti AI. Se sei come me, probabilmente hai trascorso gli ultimi mesi a sentire bisbigli (o vere e proprie urla) riguardo agli agenti AI e hai pensato: “Ok, sembra interessante, ma… che cosa è davvero e come faccio a farne uno che faccia qualcosa per me?”
Bene, sei nel posto giusto. Oggi non parleremo solo di cosa *sono* gli agenti AI in teoria. Ci rimboccheremo le maniche e affronteremo una domanda che ha dato fastidio a molti di voi (e a me, fino a poco tempo fa): Come posso costruire un semplice agente AI che possa navigare in internet per me e rispondere a domande specifiche?
Dimentica per un momento il clamore. Puntiamo sul pratico. Puntiamo su “Posso farlo funzionare effettivamente sul mio laptop.” Perché, diciamoci la verità, vedendo si crede, giusto?
I miei errori (e successi) con il Browser Bot
Quando ho iniziato a sperimentare con l’idea di un agente che potesse usare internet, avevo visioni grandiose. Volevo che ricercasse argomenti complessi, comparasse prezzi su una dozzina di siti e fosse fondamentalmente il mio assistente digitale personale. Quello che ho ottenuto, inizialmente, sono stati molti errori, alcuni web scraper rotti e un profondo senso di inadeguatezza. I miei primi tentativi erano come cercare di insegnare a un bambino a manovrare una macchina complessa: tanto entusiasmo, zero comprensione delle meccaniche sottostanti.
Il più grande ostacolo? Far interagire un modello di AI con internet in modo significativo e controllato. È una cosa chiedere a ChatGPT una domanda a cui conosce già la risposta. È un’altra cosa interamente chiedergli di trovare nuove informazioni, interpretarle e poi agire di conseguenza. È qui che entra in gioco davvero la parte “agente”.
Dopo molti tentativi ed errori, ho capito che la chiave non era costruire un’entità super complessa e onnisciente fin dall’inizio. Era iniziare in piccolo, con un compito molto specifico, e costruire da lì. Ed è esattamente quello che faremo oggi. Creeremo un agente browser di base che può andare su un sito web specifico, estrarre alcune informazioni e riportarle.
Che cos’è un Agente AI Browser?
Prima di esplorare il codice, chiarifichiamo rapidamente. Un agente AI, nella sua essenza, è un programma AI progettato per eseguire un compito specifico in modo autonomo. Osserva il suo ambiente (nel nostro caso, internet), prende decisioni in base ai suoi obiettivi e poi intraprende azioni. Un agente AI *browser* utilizza specificamente le capacità di navigazione web come parte del suo toolkit.
Pensa a questo modo: dici al tuo agente, “Trova il meteo attuale a Londra.” Invece di attingere semplicemente dalle sue conoscenze interne, un agente browser (idealmente) aprirebbe un browser web, navigherebbe su un sito di previsioni meteo, troverebbe le informazioni e te le restituirebbe. È la differenza tra chiedere a un bibliotecario una domanda di cui già conosce la risposta e chiedergli di trovare un libro, leggere un capitolo specifico e poi riassumerlo per te.
Per il nostro semplice agente, useremo alcune librerie Python comuni che rendono tutto questo processo molto meno intimidatorio.
Gli Strumenti di Cui Avremo Bisogno
Non hai bisogno di un supercomputer per questo. Solo il tuo normale ambiente di sviluppo. Ecco cosa useremo:
- Python: Il nostro linguaggio di programmazione preferito. (Sto usando 3.9, ma va bene anche 3.8+.)
requests: Una fantastica libreria per effettuare richieste HTTP (cioè, ottenere pagine web).BeautifulSoup(bs4): Questo è il nostro mago del parsing web. Ci aiuta a navigare ed estrarre dati dall’HTML.- Un’API di Modello di Linguaggio Grande (LLM): Avremo bisogno di accesso a un LLM come i modelli GPT di OpenAI o Claude di Anthropic. Per questo tutorial, presumo che tu abbia una chiave API di OpenAI.
Prima di tutto, prepariamo il nostro ambiente. Se non hai ancora questi installati, apri il terminale o il prompt dei comandi e esegui:
pip install requests beautifulsoup4 openai
E assicurati di avere la mano la tua chiave API di OpenAI. Dovrai impostarla come variabile d’ambiente o passarla direttamente nel tuo script. Per semplicità, la mostrerò direttamente, ma per la produzione, le variabili d’ambiente sono sempre migliori.
La Nostra Missione: Trovare un Articolo Specifico su un Blog
Impostiamo un obiettivo concreto e raggiungibile. La missione del nostro agente sarà:
- Andare su un blog specifico (utilizziamo per ora un URL di blog fittizio, o anche agent101.net se ti senti avventuroso!).
- Trovare un titolo di un articolo del blog che contenga una parola chiave specifica (es. “principiante”).
- Estrarre l’URL di quell’articolo del blog.
- Riassumere il contenuto di quell’articolo del blog usando un LLM.
Questo è un ottimo punto di partenza perché combina l’interazione web con la comprensione del LLM. È come chiedere al tuo assistente digitale di “trovami l’ultimo articolo sugli agenti AI per principianti su agent101.net e dimmi di cosa parla.”
Passo 1: Ottenere la Pagina Web
Il primo passo per qualsiasi agente browser è “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() # Solleva un 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 segnaposto per ora.
# Sostituisci con un reale URL di blog che ha articoli se vuoi testare!
blog_url = "https://www.example-blog.com/articles" # Usa qui un URL reale!
html_content = fetch_webpage(blog_url)
if html_content:
print("Contenuto della pagina web recuperato con successo.")
# Elaboreremo questo contenuto nel passo successivo
else:
print("Impossibile recuperare la pagina web.")
Una nota veloce sugli URL: Affinché questo funzioni, avrai bisogno di un reale URL di blog. Se non ne hai uno a portata di mano, puoi usare un sito come `http://quotes.toscrape.com/` per testare scraping semplice, ma per articoli di blog, trova un blog reale. Anche questo stesso sito, agent101.net, potrebbe funzionare se adatti i selettori CSS in seguito!
Passo 2: Parsing dell’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 rispettivi link.
Questa è la parte più complicata perché la struttura HTML di ogni sito web è diversa. Dovrai “ispezionare” l’elemento sul sito web target. Fai clic destro su un titolo di articolo nel blog scelto e seleziona “Ispeziona” (o “Ispeziona elemento”). Cerca modelli comuni come i tag <h2> per i titoli, o i tag <a> per i link, spesso annidati all’interno di un <div> con un nome di classe specifico.
Per dimostrazione, supponiamo una struttura di blog comune dove i titoli degli articoli si trovano nei tag <h2>, e i loro link sono in un tag <a> direttamente all’interno o precedenti.
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 web di destinazione.
# 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 i titoli siano all'interno di tag 'h2', con un link all'interno.
# Esempio: Cerca tutti i tag che potrebbero contenere i titoli degli articoli
# Poi controlla se sono collegati.
# Un approccio più solido potrebbe essere quello di trovare prima i contenitori:
article_containers = soup.find_all('div', class_='article-card') # Adatta questa classe!
if not article_containers:
# Ripristina o prova un altro selettore se il primo 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 all'interno del 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 dei segnaposto. Devi *assolutamente* adattarle in base alla struttura HTML effettiva del blog che stai PUNTANDO. Qui diventa essenziale ispezionare la pagina web. Il mio migliore consiglio è di iniziare in modo ampio (ad esempio, `soup.find_all(‘a’)` per ottenere tutti i link) e poi restringere con classi o ID.
Passo 3: Estrazione del Contenuto dall’Articolo di Destinazione
Una volta che abbiamo l’URL del nostro articolo di destinazione, dobbiamo recuperare il suo contenuto e poi estrarre il testo principale. Questo è spesso più facile che analizzare una pagina indice, poiché la maggior parte del contenuto degli articoli si trova all’interno di un tag di contenuto principale <div> o <article>.
# ... (codice precedente) ...
import openai
import os
# Imposta la tua chiave API OpenAI
# Best practice: 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 molto dalla struttura del sito web.
# Modelli comuni: trova un div con classe 'entry-content', 'article-body', 'main-content'
# O semplicemente i tag all'interno del tag principale dell'articolo.
# Proviamo a trovare 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:
# Come ultima risorsa, prendi semplicemente 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 di contenuto specifico, estrai tutto il testo dei paragrafi da esso
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 contenuto per: {target_article['title']}")
article_text_content = extract_article_text(target_article['url'])
if article_text_content:
# print(article_text_content[:500]) # Stampa i primi 500 caratteri per verificare
print("\nContenuto dell'articolo estratto con successo. Passando alla sintesi.")
else:
print("Impossibile estrarre il contenuto dell'articolo.")
article_text_content = "" # Assicurati che non sia None per il passaggio successivo
else:
article_text_content = ""
Ancora una volta, la riga soup.find('div', class_='entry-content') è il tuo obiettivo principale per la personalizzazione. Usa l’ispettore del tuo browser!
Passo 4: Sintesi con un LLM
Infine, il momento in cui portiamo in gioco l’intelligenza artificiale! Nutriamo il testo estratto a un LLM e gli chiediamo di . Qui è dove l’“intelligenza” del nostro agente brilla davvero.
# ... (codice precedente) ...
def summarize_text_with_llm(text):
if not text:
return "Nessun testo fornito per la sintesi."
# Accorcia il testo se è troppo lungo per la finestra di contesto del modello
# GPT-3.5-turbo ha una finestra di contesto di 16k, ma è buona prassi mantenerla ragionevole.
# Per un principiante, puntare a 4000-8000 token è sicuro.
# All'incirca 1 token = 4 caratteri per il testo in inglese.
max_tokens_for_input = 12000 # Adatta in base alla capacità del tuo modello e alle considerazioni sui costi
if len(text) > max_tokens_for_input * 4: # Stima crudele dei caratteri
text = text[:max_tokens_for_input * 4]
print(f"Attenzione: Testo accorciato a ~{max_tokens_for_input} token per l'elaborazione 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 i blog post in modo conciso."},
{"role": "user", "content": f"Per favore, riassumi il seguente blog post per me:\n\n{text}"}
],
temperature=0.7, # Controlla la casualità. Più basso per riassunti più mirati.
max_tokens=500 # Max token per il riassunto stesso
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Errore API OpenAI: {e}")
return "Fallito a causa di un errore API."
except Exception as e:
print(f"Si è verificato un errore imprevisto durante la sintesi: {e}")
return "Fallito a causa di un errore imprevisto."
if article_text_content:
print("\nRichiesta di sintesi LLM...")
summary = summarize_text_with_llm(article_text_content)
print("\n--- Riassunto dell'Articolo ---")
print(summary)
else:
print("\nImpossibile riassumere: Nessun contenuto dell'articolo disponibile.")
Ed ecco! Un agente AI di base ma funzionale che può navigare, estrarre e riassumere. Non è più solo teoria; è un pezzo concreto di codice che puoi eseguire.
Mettere Tutto Insieme (Script Completo)
Ecco lo script completo per un facile copia-incolla e test. Ricorda 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 reale del tuo blog. Assicurati che abbia 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! Oppure usa os.environ.get("OPENAI_API_KEY")
# Imposta la chiave API di OpenAI
openai.api_key = OPENAI_API_KEY
# --- Funzioni di Supporto ---
def fetch_webpage(url):
"""Recupera il contenuto HTML di un URL specificato."""
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 titoli di articoli e URL corrispondenti a una parola chiave."""
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# --- PUNTO DI PERSONALIZZAZIONE 1: Regola questi selettori per il tuo blog di destinazione ---
# Ispeziona la pagina del blog per trovare i corretti tag HTML e classi per i contenitori, titoli e link degli articoli.
article_containers = soup.find_all('div', class_='article-card') # Comune per le schede/articoli di anteprima
if not article_containers:
article_containers = soup.find_all('article') # Un altro tag comune per articoli singoli
if not article_containers:
print("Attenzione: Impossibile trovare tag contenitore articoli comuni. Provo una ricerca più ampia.")
# Fallback: cerca solo tutti i link che potrebbero essere 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 prima se sono stati trovati solo link generali
for container in article_containers:
# Cerca il titolo e il link all'interno di ciascun contenitore
title_tag = container.find(['h2', 'h3', 'a']) # I titoli si trovano spesso in h2/h3 o collegati direttamente
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 d'articolo ed estrae il suo 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 principale del contenuto dell'articolo (ad es., 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 schema comune
if not content_area:
content_area = soup.find('div', id='content') # 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:
# Fallback: prendi tutti i tag di paragrafo se non viene trovata l'area di contenuto specifica
print(f"Attenzione: Area di contenuto specifica non trovata per {article_url}. Estraendo 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 di riassumere
return "Non abbastanza contenuto per il riassunto."
# Semplice troncamento per rimanere entro i limiti tipici della finestra di contesto
# Considera di usare un contatore di token appropriato per maggiore accuratezza se necessario
max_chars_for_llm = 40000 # Circa 10k token per GPT-3.5-turbo 16k contesto
if len(text) > max_chars_for_llm:
print(f"Attenzione: 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 i post del blog in modo conciso e chiaro."},
{"role": "user", "content": f"Per favore, fornisci un riassunto conciso del seguente post del blog, 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"Fallito a causa di un errore API: {e}"
except Exception as e:
print(f"Si è verificato un errore imprevisto durante il riassunto: {e}")
return f"Fallito a causa di un errore imprevisto: {e}"
# --- Logica Principale dell'Agente ---
def run_browser_agent():
print(f"Inizio agente del browser 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 che corrispondono 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}. Agente completato.")
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, elaboriamo il primo articolo trovato
target_article = found_articles[0]
print(f"\nElaborando il primo articolo trovato: '{target_article['title']}' su {target_article['url']}")
# Passo 3: Estrai contenuto dall'articolo target
article_content = extract_article_text(target_article['url'])
if not article_content:
print(f"L'agente non è riuscito a estrarre contenuto da {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 LLM per l'articolo...")
summary = summarize_text_with_llm(article_content)
print("\n--- Rapporto Finale dell'Agente ---")
print(f"Titolo Articolo: {target_article['title']}")
print(f"URL Articolo: {target_article['url']}")
print("\nRiassunto:")
print(summary)
print("\n--- Compito dell'Agente Completato ---")
if __name__ == "__main__":
run_browser_agent()
Punti Utili per il Tuo Viaggio con l’Agente
Questo piccolo progetto è solo la punta dell’iceberg, ma ti mostra le meccaniche fondamentali. Ecco cosa ho imparato e cosa dovresti tenere a mente:
- Inizia in Piccolo, Pensa Specifico: Non cercare di costruire Skynet sin dal primo giorno. Scegli un compito molto ristretto e realizzabile per il tuo agente. “Trova una ricetta per lasagna vegana” è meglio che “cucina cena per me.”
- Il Web Scraping è il Selvaggio West: Ogni sito web è diverso. Trascorrerai tempo ispezionando elementi nel tuo browser per ottenere i corretti selettori CSS o XPath. Questo è il lavoro duro, ma è essenziale. I siti web cambiano, quindi il tuo agente potrebbe necessitare di occasionali aggiustamenti.
- La Gestione degli Errori è la Tua Amica: Le cose andranno male. I siti web saranno inattivi, la tua connessione internet si interromperà, le chiamate API falliranno. Aggiungi
try-exceptper gestire questi problemi in modo elegante. - Gli LLM sono Intelligenti, ma Necessitano di Guida: La qualità dell’output del tuo LLM dipende fortemente dal tuo prompt. Sii chiaro, conciso e dilli esattamente cosa ti aspetti. Inoltre, fai attenzione ai limiti della finestra di contesto e ai costi.
- Questa è una Fondazione: Abbiamo costruito un agente a turno singolo. Gli agenti reali coinvolgono spesso più passaggi, logica condizionale (ad es., “se trovo questo, allora faccio quello”), e memoria. Ma ora hai i mattoni di base.
Spero che vedere questo semplice agente prendere vita demistifichi un po’ il concetto di “agente AI”. Non è magia; è solo automazione intelligente costruita su strumenti esistenti. Vai avanti, sperimenta e costruisci i tuoi piccoli aiutanti digitali!
Buon coding,
Emma Walsh, agent101.net
Articoli Correlati
- Come gli Agenti AI Gestiscono Più Lingue senza Problemi
- Ho Reso Utile il Mio Agente AI (Ecco Come)
- Ho Costruito un Agente AI nel 2026: La Mia Opinione Onesta
🕒 Published: