Una guida pratica per chi vuole capire l’ecosistema AI — non solo usarlo.
La parola “intelligenza artificiale” viene usata per tutto: chatbot, raccomandazioni di Netflix, auto a guida autonoma, generatori di immagini. Ma dietro c’è uno stack tecnologico ben preciso, fatto di livelli che si costruiscono l’uno sopra l’altro. Capire questa struttura fa la differenza tra chi usa gli strumenti AI e chi li progetta.
Partiamo dal basso.
1. Artificial Intelligence (AI) — il campo generale
L’AI è il dominio che raccoglie tutto: qualsiasi sistema progettato per simulare capacità cognitive umane come ragionamento, apprendimento, percezione o decision-making.
I primi sistemi AI erano rule-based: logica esplicita scritta a mano da un programmatore.
def approva_prestito(reddito, credit_score):
if reddito > 50000 and credit_score > 700:
return "Approvato"
return "Rifiutato"
Code language: JavaScript (javascript)Semplice, trasparente, ma fragile. Non si adatta. Non impara. Per ogni nuovo caso, qualcuno deve aggiornare le regole a mano. Da questa limitazione nasce il livello successivo.
2. Machine Learning (ML) — imparare dai dati
Con il ML si inverte il paradigma: invece di scrivere regole, si forniscono dati e il modello impara da solo i pattern.
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = RandomForestClassifier()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(predictions[:5])
Code language: JavaScript (javascript)Dove funziona bene: rilevamento frodi, previsione della domanda, sistemi di raccomandazione, churn prediction.
Dove mostra i limiti: dati ad alta dimensionalità, immagini, testo, audio. Per questi casi servono architetture più potenti.
3. Neural Networks (NN) — il cervello artificiale
Le reti neurali si ispirano alla struttura del cervello: nodi interconnessi che elaborano informazioni in parallelo. Ogni neurone calcola:
output = activation(peso · input + bias)
L’addestramento avviene con la backpropagation: si calcola l’errore sull’output, si propaga all’indietro e si aggiornano i pesi per minimizzarlo.
import torch
import torch.nn as nn
class NeuralNetwork(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(4, 8)
self.layer2 = nn.Linear(8, 3)
def forward(self, x):
x = torch.relu(self.layer1(x))
return self.layer2(x)
model = NeuralNetwork()
output = model(torch.rand(1, 4))
print(output)
Le reti neurali funzionano bene su problemi strutturati. Ma per task davvero complessi — riconoscimento vocale, comprensione del linguaggio — servono reti molto più profonde.
4. Deep Learning (DL) — più strati, più potenza
Il Deep Learning è ML con reti neurali a molti strati. Più strati = capacità di estrarre feature sempre più astratte dai dati.
Questo ha reso possibile: visione artificiale, NLP, sintesi vocale, guida autonoma.
Le architetture principali che un developer incontra oggi:
| Architettura | Use case tipico |
|---|---|
| CNN | Computer vision, classificazione immagini |
| RNN / LSTM | Sequenze temporali, testo |
| Transformer | NLP, LLM, generazione |
| Autoencoder | Compressione, anomaly detection |
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential([
layers.Dense(128, activation="relu"),
layers.Dense(64, activation="relu"),
layers.Dense(10, activation="softmax")
])
model.compile(
optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"]
)
model.summary()
Code language: JavaScript (javascript)Il Deep Learning ha aperto la strada alla generazione di contenuti nuovi — ed è qui che le cose diventano interessanti.
5. Generative AI — creare, non solo classificare
Un classificatore dice “questa immagine è un gatto”. Un modello generativo crea una nuova immagine di un gatto. È un cambio di paradigma fondamentale.
Le principali famiglie di modelli generativi:
- GAN (Generative Adversarial Networks): due reti in competizione — generatore vs. discriminatore
- VAE (Variational Autoencoder): encoding probabilistico dello spazio latente
- Diffusion Models: aggiungono e poi rimuovono rumore iterativamente (es. Stable Diffusion)
- LLM: transformer autoregressivi per il linguaggio
Esempio concettuale di GAN in PyTorch:
import torch
import torch.nn as nn
class Generator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(100, 256),
nn.ReLU(),
nn.Linear(256, 784),
nn.Tanh()
)
def forward(self, x):
return self.net(x)
generator = Generator()
noise = torch.randn(1, 100)
fake_image = generator(noise)
print(fake_image.shape) # torch.Size([1, 784])
I prodotti che conosci — ChatGPT, Claude, Gemini, Midjourney, Copilot — sono tutti costruiti su questi fondamenti.
6. LLM e SLM — scala e trade-off
Large Language Models (LLM)
Architettura base: Transformer. Miliardi (o trilioni) di parametri. Addestrati su corpus enormi con self-supervised learning.
Punti di forza: ragionamento complesso, generazione estesa, comprensione contestuale profonda.
from transformers import pipeline
generator = pipeline("text-generation", model="gpt2")
output = generator("L'intelligenza artificiale trasformerà", max_length=40)
print(output)
Code language: JavaScript (javascript)Small Language Models (SLM)
Versioni compatte ottimizzate per: latenza bassa, consumo energetico ridotto, esecuzione on-device o on-premise.
Esempi: Phi-3 (Microsoft), Gemma (Google), LLaMA 3 in versioni small.
Il pattern che sta emergendo nei sistemi produzione:
SLM → task veloci, ripetitivi, classificazione, routing
LLM → ragionamento complesso, sintesi, generazione creativa
Architetture ibride SLM+LLM sono già la norma in produzione.
7. AI Agents e Agentic AI — dall’output all’azione
Qui il paradigma cambia di nuovo. Un LLM risponde a una domanda. Un agente pianifica un obiettivo, seleziona gli strumenti giusti, li esegue in sequenza e gestisce lo stato.
Architettura tipica di un agente
Input utente
↓
LLM reasoning (pianificazione)
↓
Tool selection (quale API usare?)
↓
Execution (chiamata reale)
↓
Memory update (salva il contesto)
↓
Output / prossima azione
Esempio pratico
import requests
def get_weather(city: str) -> dict:
url = f"https://api.weatherapi.com/v1/current.json?key=API_KEY&q={city}"
return requests.get(url).json()
def agent(city: str) -> str:
data = get_weather(city)
temp = data.get("current", {}).get("temp_c")
if temp is None:
return "Impossibile recuperare la temperatura."
return "Porta una giacca, fa freddo." if temp < 15 else "Clima ok, niente giacca."
print(agent("Milano"))
Code language: JavaScript (javascript)In sistemi reali l’agente gestisce anche: memoria persistente (es. vector store), tool calling strutturato, retry logic, handoff tra agenti.
Framework principali
| Framework | Caratteristica |
|---|---|
| LangChain | Ecosistema completo, chains e agents |
| LangGraph | Agenti stateful come grafi |
| CrewAI | Multi-agent con ruoli espliciti |
| AutoGen (Microsoft) | Conversazioni tra agenti |
| Semantic Kernel | Integrazione enterprise (.NET/Python) |
Il quadro completo
Agentic AI ← autonomia, pianificazione, esecuzione
↑
Generative AI ← LLM, diffusion, generazione di contenuti
↑
LLM / SLM ← transformer, miliardi di parametri
↑
Deep Learning ← reti profonde, CNN, RNN
↑
Neural Networks ← backpropagation, attivazioni
↑
Machine Learning ← apprendimento da dati, feature engineering
↑
AI (regole) ← logica esplicita, sistemi esperti
Un sistema reale combina più livelli. Un assistente e-commerce potrebbe usare:
- CNN per analizzare immagini di prodotti
- LLM per rispondere a domande in linguaggio naturale
- RAG per recuperare info da un catalogo aggiornato
- Agent per avviare resi, aggiornare ordini, notificare utenti
Dove va il settore
Tre tendenze concrete su cui vale la pena stare attenti:
1. Multi-agent systems — più agenti specializzati che collaborano. Uno fa il planning, uno esegue, uno verifica. Migliore separazione delle responsabilità, più robustezza.
2. Architetture ibride SLM+LLM — il modello grande per il ragionamento, il modello piccolo per l’esecuzione. Riduzione di costi e latenza senza rinunciare a qualità.
3. Autonomia progressiva — agenti che eseguono flussi di lavoro completi senza intervento umano, con escalation solo per i casi ambigui. Il “human in the loop” diventa opzionale, non obbligatorio.
Si parla già di Agentic Web: reti di agenti che collaborano su internet come layer distribuito di intelligenza.
Takeaway per developer
La distinzione che conta davvero non è tra tecnologie, ma tra chi usa l’AI e chi la progetta.
Usarla è facile: basta una API key. Progettarla significa capire quali livelli dello stack coinvolgere, dove si trovano i colli di bottiglia, come combinare LLM e agenti in modo affidabile, e come gestire stato, errori e sicurezza in produzione.
Questo stack non è statico — ogni anno aggiunge un livello. Ma i fondamentali rimangono: dati, modelli, architetture, agenti. Chi li capisce in profondità avrà un vantaggio duraturo.
