🤖 Come trasformare una semplice frase in una azione reale con i LLM “Agentic AI”
- texservice13
- 13 ore fa
- Tempo di lettura: 5 min
📚 Il contesto: perché è importante “compressare” il testo
Quando parliamo con un assistente virtuale (tipo ChatGPT o Siri) il modello deve capire cosa vuoi davvero e, soprattutto, qual è l’azione principale (es. prenotare, cancellare).I vecchi modelli di NLP spesso perdono questa informazione cruciale, finendo per dare risposte vaghe o inutili.
Con le Agentic AI (gli “agent‑like” LLM di ultima generazione) possiamo andare oltre: il bot non solo capisce, ma esegue l’azione corretta, consumando meno token e facendo risparmiare tempo.
TL;DR – Se riusciamo a estrarre verbo, oggetto e data/ora da una frase, possiamo mandare subito il comando giusto al “tool” (es. API di prenotazione) senza sprecare parole.
Con le Agentic AI (gli “agent‑like” LLM di ultima generazione) possiamo andare oltre: il bot non solo capisce, ma esegue l’azione corretta, consumando meno token e facendo risparmiare tempo.
TL;DR – Se riusciamo a estrarre verbo, oggetto e data/ora da una frase, possiamo mandare subito il comando giusto al “tool” (es. API di prenotazione) senza sprecare parole.
🚀 I tre ingredienti della ACON – Adaptive Context Optimization and Navigation
🍕 Elemento | 📖 Che cosa rappresenta | 📌 Perché serve |
Verbo principale (e sinonimi) | L’azione che l’utente vuole compiere (prenotare, cancellare, acquistare…) | È il “cervello” della richiesta; senza di lui il bot non sa cosa fare. |
Sostantivi / entità | Su cosa agisce l’azione (volo, hotel, prodotto, luogo…) | Definisce cosa viene manipolato. |
Date & orari | Vincoli temporali (15 luglio, alle 16:30…) | Necessari per fare prenotazioni, cancellazioni o promemoria. |
Una volta raccolti questi tre tasselli, otteniamo una rappresentazione semantica compatta pronta per il prossimo step: il router di intenzione.
🛣️Il “Router di Intento” (stile React Prompt)
Il router deve decidere che cosa fare:
1️⃣ Prenotare oppure
2️⃣ Cancellare
Per riconoscere i sinonimi di prenotare e cancellare usiamo il modello linguistico italiano it_core_news_lg di spaCy , che contiene i vettori semantici necessari al calcolo della similarità.
```
import spacy
def calcola_intenzione(verbo_estratto: str) -> str:
nlp = spacy.load("it_core_news_lg") # modello con vettori
prenotare = nlp("prenotare")
cancellare = nlp("cancellare")
verbo = nlp(verbo_estratto)
sim_prenotare = verbo.similarity(prenotare)
sim_cancellare = verbo.similarity(cancellare)
print(f"Similarità con 'prenotare': {sim_prenotare:.2f}")
print(f"Similarità con 'cancellare': {sim_cancellare:.2f}")
return "prenotazione" if sim_prenotare > sim_cancellare else "cancellazione"**Curiosità:** `similarity()` restituisce un valore fra 0 e 1; più è alto, più i due termini sono “vicini” nello spazio vettoriale.
🧠 Passo 1 – L’**estrattore semantico**: da frase a dati strutturati
Il codice qui sotto è una versione “friendly” per chi si avvicina alla programmazione. Serve a:
- trovare il verbo principale,
- raccogliere sostantivi (escludendo mesi e orari),
- estrarre **entity** (luoghi, date, orari) usando sia spaCy sia espressioni regolari.
```python
import spacy, re
class SemanticExtractor:
def __init__(self, model="it_core_news_lg"):
self.nlp = spacy.load(model)
self.mesi = ["gennaio","febbraio","marzo","aprile","maggio","giugno",
"luglio","agosto","settembre","ottobre","novembre","dicembre"]
# ----- METODI PRIVATI -------------------------------------------------
def _estrarre_verbo_principale(self, doc):
for tok in doc:
if tok.dep_ == "ROOT" and tok.pos_ == "VERB":
return tok.lemma_
return None
def _estrarre_sostantivi(self, doc):
return [tok.lemma_ for tok in doc if tok.pos_ == "NOUN"]
def _estrarre_entita(self, doc):
return [(ent.text, ent.label_) for ent in doc.ents]
def _aggiungere_date_con_pattern(self, txt, ent):
pattern = r"\b\d{1,2}\s(" + "|".join(self.mesi) + r")\b"
for m in re.findall(pattern, txt, flags=re.I):
data = re.search(r"\b\d{1,2}\s"+m, txt, flags=re.I).group()
if not any(data in e[0] for e in ent):
ent.append((data, "DATE"))
def _aggiungere_orari_con_pattern(self, txt, ent):
ore = re.findall(r"\balle\s\d{1,2}[:.]\d{2}\b", txt)
for o in ore:
if not any(o in e[0] for e in ent):
ent.append((o, "TIME"))
def _filtrare_sostantivi(self, sost, ent):
fil = []
for s in sost:
if s.lower() in self.mesi: continue
if any(s in e[0] for e in ent): continue
fil.append(s)
return fil
# ----- METODO PUBLICO -------------------------------------------------
def analizza(self, testo):
doc = self.nlp(testo)
ent = self._estrarre_entita(doc)
# aggiunta manuale di date/orari
self._aggiungere_date_con_pattern(testo, ent)
self._aggiungere_orari_con_pattern(testo, ent)
verbo = self._estrarre_verbo_principale(doc)
sost = self._filtrare_sostantivi(self._estrarre_sostantivi(doc), ent)
luoghi = [e[0] for e in ent if e[1] == "LOC"]
date = [e[0] for e in ent if e[1] == "DATE"]
ore = [e[0] for e in ent if e[1] == "TIME"]
return {
"azione": verbo,
"oggetti": ", ".join(sost),
"da": luoghi[0] if luoghi else None,
"a": luoghi[1] if len(luoghi)>1 else None,
"data": date[0] if date else None,
"ora": ore[0] if ore else None
}
🛠️ Passo 2 – I **tools**: la “logica di business”
Per dimostrare il funzionamento, simuliamo un piccolo “database” in memoria e creiamo due funzioni:
Tool | Scopo | Messaggio di ritorno |
tool_prenota | Crea una nuova prenotazione | ✅ Prenotazione confermata! Codice: P003 |
tool_cancella | Annulla una prenotazione esistente | ✅ Prenotazione P001 annullata. |
# ---- Simulazione DB -------------------------------------------------
prenotazioni_db = {
"P001": {"data": "15 luglio", "ora": "alle 16:30", "stato": "attiva"},
"P002": {"data": "10 agosto", "ora": "alle 10:00", "stato": "attiva"},
}
def cerca_prenotazione(data, ora):
for cod, rec in prenotazioni_db.items():
if rec["data"] == data and rec["ora"] == ora and rec["stato"] == "attiva":
return cod
return None
def tool_prenota(params):
data, ora = params["data"], params["ora"]
if not data or not ora:
return "❌ Errore: data o ora mancanti per la prenotazione."
nuovo_cod = f"P{len(prenotazioni_db)+1:03d}"
prenotazioni_db[nuovo_cod] = {"data": data, "ora": ora, "stato": "attiva"}
return f"✅ Prenotazione confermata! Codice: {nuovo_cod}"
def tool_cancella(params):
data, ora = params["data"], params["ora"]
if not data or not ora:
return "❌ Errore: data o ora mancanti per la cancellazione."
cod = cerca_prenotazione(data, ora)
if not cod:
return "❌ Nessuna prenotazione trovata per quei parametri."
prenotazioni_db[cod]["stato"] = "cancellata"
return f"✅ Prenotazione {cod} annullata."
🤖 Il **motore principale** – mettiamo tutto insieme!
def processa_frase(testo):
# 1️⃣ Analisi semantica
estr = SemanticExtractor()
rep = estr.analizza(testo)
# 2️⃣ Calcolo intenzione (prenotazione vs cancellazione)
intento = calcola_intenzione(rep["azione"])
# 3️⃣ Dispatch al tool corretto
if intento == "prenotazione":
return tool_prenota(rep)
elif intento == "cancellazione":
return tool_cancella(rep)
else:
return "🤔 Non ho capito l'azione. Puoi riformulare?"Esempi di utilizzo
print(processa_frase("Vorrei prenotare un volo da Milano a Roma il 15 luglio alle 16:30."))
# ✅ Prenotazione confermata! Codice: P003
print(processa_frase("Voglio cancellare la mia prenotazione del 15 luglio alle 16:30."))
# ✅ Prenotazione P001 annullata.
print(processa_frase("Voglio cancellare la mia prenotazione."))
# ❌ Errore: data o ora mancanti per la cancellazione.🎉 Cosa abbiamo realizzato?
Fase | Cosa fa | Perché è importante |
SemanticExtractor | Raccoglie verbo, oggetti, date, orari e luoghi | Trasforma il linguaggio naturale in dati strutturati, riducendo il contesto. |
Mappatura Intenti | Confronta il verbo con le radici *prenotare* / *cancellare* | Normalizza sinonimi e abbreviazioni, evitando fraintendimenti. |
Tools (API mock) | Esegue la logica di business (crea o annulla) | Il bot non solo “capisce”, ma agisce. |
Dispatcher | Sceglie il tool giusto in base all’intento | Cuore del flusso “React Prompt‑style”: decisione rapida e precisa. |
🚀 Come portare il tutto al livello successivo
Numero | Descrizione |
1 | Modello più grande – Passa a it_core_news_lg per ottenere vettori più ricchi. |
2 | Persistenza vera – Collega i tools a un database reale (PostgreSQL, MongoDB…). |
3 | Multilingua – Aggiungi altri modelli spaCy (es. en_core_web_lg) per gestire richieste in inglese o altre lingue. |
4 | Interfaccia grafica – Usa Streamlit o Flask per creare una web‑app dove testare il bot in tempo reale. |
📢 Conclusioni: perché questo è cool per:
**Imparare a programmare** con Python e spaCy è un ottimo modo per capire le basi del NLP.
Il concetto di *compressare il contesto* ti insegna a pensare “come un computer”: meno dati, più efficienza.
Puoi **creare il tuo assistente personale** (per prenotare film, tour, giochi…) e sperimentare con le **Agentic AI**, il futuro delle interfacce vocali e testuali.
**Sfida per te:** modifica il codice in modo che il bot gestisca anche *modificare* una prenotazione (es. cambiare data/ora). Vedrai quanto sia potente una rappresentazione semantica ben fatta!