# Rasa: creare chatbot AI open source in Python

> Cos'è Rasa e come usarlo per costruire chatbot open source in Python che vanno oltre le risposte predefinite: requisiti, training data, configurazione YAML, sicurezza e scaling.

- URL: https://mautoblog.com/posts/rasa-chatbot-intelligenza-artificiale/
- Lingua: it
- Pubblicato: 2024-11-15
- Aggiornato: 2026-10-16
- Autore: Mauto
- Categorie: Intelligenza Artificiale, Sviluppo Software
- Tags: LLM, Machine Learning, Python, Open Source

---
Vi è mai capitato di interagire con un chatbot e pensare "questo non ha capito nulla di quello che ho scritto"? Beh, non siete soli. La maggior parte dei chatbot tradizionali sono poco più che sistemi di if-else mascherati, che crollano miseramente appena si esce dal loro script predefinito. È qui che entra in gioco Rasa, un framework che promette (e mantiene) di portare l'intelligenza artificiale nel mondo dei chatbot.

### Cosa è rasa
Rasa è un framework open source per lo sviluppo di chatbot e assistenti virtuali basato su Python e machine learning.

### Perché Rasa è Diverso?
La vera magia di Rasa sta nel suo approccio basato sul machine learning. Invece di affidarsi a regole rigide e risposte predefinite, Rasa impara dai dati. È come la differenza tra memorizzare le risposte di un test e capire veramente la materia: Rasa fa la seconda.

### La Storia Dietro il Framework
Rasa nasce dalla frustrazione dei suoi creatori con i tradizionali strumenti per chatbot. Nel 2016, quando tutti parlavano di AI ma i chatbot erano ancora incredibilmente stupidi, un gruppo di sviluppatori e ricercatori ha deciso che era ora di cambiare le cose. Il risultato? Un framework open source che ha rivoluzionato il modo in cui pensiamo agli assistenti conversazionali.

## L'Architettura: Come Funziona Veramente
Rasa non è un semplice strumento, è un'orchestra ben orchestrata di componenti che lavorano insieme. Immaginate di avere un team di esperti linguisti, ciascuno specializzato in un aspetto diverso della conversazione:

### 1. Natural Language Understanding (NLU)
L'NLU è come l'orecchio e il cervello del vostro chatbot. Quando un utente scrive qualcosa, l'NLU deve:
- Capire l'intento (cosa vuole l'utente)
- Estrarre le entità (i dettagli importanti)
- Interpretare il contesto

```yaml
# Esempio di training data per NLU
nlu:
- intent: richiesta_prenotazione
  examples: |
    - Vorrei prenotare un tavolo per [domani sera](data)
    - Ho bisogno di un tavolo per [4 persone](num_persone) [questo venerdì](data)
    - Posso prenotare per [sabato](data) per [due](num_persone)?
    - Mi serve una prenotazione [stasera](data) per [6](num_persone)
```

Questo non è un semplice pattern matching. Rasa usa tecniche avanzate di machine learning per capire le sfumature del linguaggio naturale. Se avete mai provato a prenotare un tavolo scrivendo "siamo in 4+1 bambino per domani", sapete quanto può essere complesso interpretare correttamente questa richiesta.
### 2. Dialogue Management

Il Dialogue Management è il "cervello sociale" del vostro chatbot. Non si limita a rispondere alle domande, ma mantiene una vera e propria conversazione:

```yaml
stories:
- story: flow_prenotazione_completo
  steps:
  - intent: saluto
  - action: utter_saluto
  - intent: richiesta_prenotazione
    entities:
      - data: "domani sera"
      - num_persone: "4"
  - action: action_check_disponibilita
  - slot_was_set:
      - disponibilita: true
  - action: action_conferma_prenotazione
  - intent: ringraziamento
  - action: utter_prego
```

Questo esempio mostra come Rasa gestisce una conversazione completa, mantenendo il contesto e reagendo in modo appropriato a ogni svolta del dialogo.

### Custom Actions: Dove la Magia Incontra il Mondo Reale

Le custom actions sono dove il vostro chatbot si connette con il mondo esterno. Ecco un esempio pratico:

```python
class ActionCheckDisponibilita(Action):
    def name(self) -> Text:
        return "action_check_disponibilita"

    def run(self, dispatcher: CollectingDispatcher,
            tracker: Tracker,
            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
        
        data = tracker.get_slot("data")
        num_persone = tracker.get_slot("num_persone")
        
        # Integrazione con il vostro sistema di prenotazioni
        disponibilita = self.check_sistema_prenotazioni(data, num_persone)
        
        if disponibilita:
            dispatcher.utter_message(
                f"Perfetto! Ho trovato un tavolo per {num_persone} persone per {data}."
            )
            return [SlotSet("disponibilita", True)]
        else:
            alternative = self.trova_alternative(data, num_persone)
            dispatcher.utter_message(
                f"Mi dispiace, siamo al completo per {data}. "
                f"Potrei suggerirti questi orari alternativi: {alternative}"
            )
            return [SlotSet("disponibilita", False)]
```

## Forms: Gestire Conversazioni Strutturate

I forms sono uno strumento potente per raccogliere informazioni in modo strutturato ma naturale:

```yaml
forms:
  prenotazione_form:
    required_slots:
      - data
      - num_persone
      - nome_cliente
      - telefono

    responses:
      utter_ask_data:
        - text: "Per quale giorno vorresti prenotare?"
      utter_ask_num_persone:
        - text: "Per quante persone?"
      utter_ask_nome_cliente:
        - text: "A che nome devo fare la prenotazione?"
      utter_ask_telefono:
        - text: "Mi lasci un numero di telefono per conferma?"
```

## Pipeline: Il Cuore dell'Elaborazione
La pipeline di Rasa è completamente personalizzabile. Ecco un esempio di configurazione avanzata:

```yaml
pipeline:
  - name: WhitespaceTokenizer
  - name: RegexFeaturizer
  - name: LexicalSyntacticFeaturizer
  - name: CountVectorsFeaturizer
  - name: CountVectorsFeaturizer
    analyzer: "char_wb"
    min_ngram: 1
    max_ngram: 4
  - name: DIETClassifier
    epochs: 100
    constrain_similarities: true
  - name: EntitySynonymMapper
  - name: ResponseSelector
    epochs: 100
    constrain_similarities: true
  - name: FallbackClassifier
    threshold: 0.7
```

Ogni componente della pipeline ha un ruolo specifico:
- WhitespaceTokenizer divide il testo in token
- RegexFeaturizer cattura pattern specifici
- DIETClassifier è il cervello dell'operazione, che impara a classificare gli intenti
- FallbackClassifier gestisce i casi in cui il bot non è sicuro della risposta

## Deployment in Produzione
Quando si passa alla produzione, Rasa offre diverse opzioni. Ecco un esempio di configurazione Docker:

```yaml
version: '3.0'
services:
  rasa:
    image: rasa/rasa:3.6.2-full
    ports:
      - 5005:5005
    volumes:
      - ./:/app
    command: run --enable-api --cors "*"
    
  action-server:
    image: rasa/rasa-sdk:3.6.2
    ports:
      - 5055:5055
    volumes:
      - ./actions:/app/actions
```

## Monitoraggio e Analytics
Una delle parti più interessanti di Rasa è la possibilità di monitorare e migliorare il vostro bot nel tempo. Potete tracciare:

1. **Metriche di Conversazione**
    - Tasso di completamento dei dialoghi
    - Punti di abbandono comuni
    - Intenti non riconosciuti

2. **Performance del Modello**
    - Precisione nella classificazione degli intenti
    - Accuratezza nell'estrazione delle entità
    - Confidence scores

```python
from rasa.core.tracker_store import TrackerStore

class CustomTrackerStore(TrackerStore):
    def save(self, tracker):
        conversation_id = tracker.sender_id
        events = tracker.current_state()['events']
        
        # Analizza gli eventi e salva le metriche
        for event in events:
            if event['event'] == 'user':
                self.log_user_message(event['text'])
            elif event['event'] == 'action':
                self.log_bot_action(event['name'])
```

## Best Practices e Lezioni Apprese
Dopo anni di esperienza con Rasa, ecco alcuni consigli d'oro:

### 1. Training Data è Re
Non lesinate sui dati di training. Più esempi diversificati avete, migliore sarà il vostro bot. Ma attenzione: la qualità è importante quanto la quantità.

### 2. Test, Test e Ancora Test
Create test conversazionali completi:

```yaml
test_stories:
- story: test_prenotazione_happy_path
  steps:
  - user: |
      ciao
    intent: saluto
  - action: utter_saluto
  - user: |
      vorrei prenotare un tavolo per domani sera
    intent: richiesta_prenotazione
    entities:
    - data: domani sera
  - action: action_check_disponibilita
  # ... continua ...
```

### 3. Gestite i Fallback con Grazia
Non c'è niente di peggio di un bot che non capisce e continua a ripetere la stessa cosa. Create strategie di fallback intelligenti:

```python
class ActionSmartFallback(Action):
    def name(self) -> Text:
        return "action_smart_fallback"

    def run(self, dispatcher: CollectingDispatcher,
            tracker: Tracker,
            domain: Dict[Text, Any]) -> List[Dict[Text, Any]]:
        
        # Controlla il contesto precedente
        last_intent = tracker.get_intent_of_latest_message()
        
        if last_intent == "richiesta_prenotazione":
            dispatcher.utter_message(
                "Scusa, non ho capito bene. Stai cercando di prenotare un tavolo? "
                "Potresti dirmi per quale giorno e per quante persone?"
            )
        else:
            dispatcher.utter_message(
                "Mi dispiace, non ho capito. Posso aiutarti con prenotazioni, "
                "orari di apertura o il menu del giorno. Di cosa hai bisogno?"
            )
```

## Ma passiamo alla ciccia..
(la parte noiosa la facciamo scrivere all'IA)

### Requisiti Hardware
- CPU: minimo 2 core (raccomandati 4+ per training)
- RAM: minimo 4GB (raccomandati 8GB+ per dataset medio-grandi)
- Storage: minimo 10GB liberi
- GPU: opzionale ma raccomandato per training veloce su dataset grandi

### Requisiti Software
- Python 3.8 - 3.10 (3.11+ non ancora supportato)
- Sistema Operativo:
   - Linux (Ubuntu 18.04+, CentOS 7+)
   - macOS 10.15+
   - Windows 10 (con WSL2 raccomandato)
- Docker (opzionale ma raccomandato)

### Dipendenze Python
```bash
# Dipendenze di sistema (Ubuntu)
sudo apt update
sudo apt install python3-dev python3-pip python3-venv

# Dipendenze per training spaCy
sudo apt install libpq-dev python3-dev
```

## Installazione Completa

### 1. Preparazione Ambiente
```bash
# Crea ambiente virtuale
python3 -m venv ./rasa-env

# Attiva ambiente
source ./rasa-env/bin/activate  # Linux/macOS
.\rasa-env\Scripts\activate     # Windows

# Aggiorna pip
pip install --upgrade pip
```

### 2. Installazione Rasa
```bash
# Installazione base
pip install rasa

# Con dipendenze complete
pip install rasa[full]

# Con supporto spaCy
pip install rasa[spacy]
python -m spacy download it_core_news_lg
```

### 3. Setup Docker
```bash
# Dockerfile
FROM rasa/rasa:3.6.2-full

# Aggiungi dipendenze custom
COPY requirements.txt /app/
RUN pip install -r requirements.txt

# Copia progetto
COPY . /app/

# Permessi
RUN chown -R 1001:1001 /app
USER 1001
```

### 4. Verifica Installazione
```bash
# Verifica versione
rasa --version

# Inizializza progetto
rasa init

# avvia il train ed inizia a chattare
rasa train

rasa run actions  # avvia l'actions server se necessario

rasa shell        # inizia una chat da shell

rasa interactive  # avvia una chat interattiva, 
                  # dove potrete verificare il 
                  # riconoscimento di intents ed entities
```

## Linguaggio e Struttura
Rasa utilizza principalmente:

### YAML per Configurazione
- `config.yml`: Pipeline NLU e policy
- `domain.yml`: Intenti, azioni, risposte
- `endpoints.yml`: Configurazione endpoint
- `credentials.yml`: Credenziali messenger

### Python per Logica Custom
```
from rasa_sdk import Action
from rasa_sdk.events import SlotSet

class ActionCheckDatabase(Action):
    def name(self) -> str:
        return "action_check_database"

    def run(self, dispatcher, tracker, domain):
        # Logica custom
        return [SlotSet("result", value)]
```

### Training Data
```yaml
# nlu.yml
nlu:
- intent: inform
  examples: |
    - Sono a [Milano](city)
    - Vorrei prenotare per [domani](date)
    - [Due persone](guests)

# stories.yml
stories:
- story: prenotazione
  steps:
    - intent: greet
    - action: utter_greet
    - intent: inform
    - action: action_check_availability
```

## Architettura Raccomandata
- Server dedicato o cloud (AWS, GCP, Azure)
- 4+ CPU cores
- 16GB+ RAM
- Load balancer per scaling
- Monitoring (Grafana, Prometheus)
- Database per storage (PostgreSQL)

## Considerazioni per Deployment

### Scaling
```yaml
# docker-compose.yml
services:
  rasa:
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '1'
          memory: 2G
```

### Monitoring
```
import logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s %(levelname)s: %(message)s'
)
```

### Security
```yaml
# endpoints.yml
rest:
  token: "your_secure_token"
  ssl_certificate: "cert.pem"
  ssl_keyfile: "key.pem"
```

Rasa offre un approccio professionale e scalabile allo sviluppo di chatbot, richiedendo una buona conoscenza di Python e machine learning per sfruttarne appieno il potenziale.

## Il Futuro di Rasa
Rasa continua a evolversi. Le ultime versioni hanno introdotto:
- Supporto per modelli di linguaggio più avanzati
- Migliore gestione del contesto
- Strumenti di analisi più sofisticati

Ma la vera forza di Rasa rimane la sua comunità open source. Ogni giorno, sviluppatori da tutto il mondo contribuiscono a migliorare il framework, condividendo codice, idee e best practices.

## Conclusione
Rasa non è solo un framework per chatbot, è un cambio di paradigma nel modo in cui pensiamo all'interazione uomo-macchina. Con le giuste conoscenze e un po' di creatività, potete creare assistenti conversazionali che non solo funzionano, ma sorprendono positivamente i vostri utenti.
Ricordate: un buon chatbot non è quello che ha tutte le risposte, ma quello che sa come trovare la risposta giusta insieme all'utente. Con Rasa, avete tutti gli strumenti per creare esattamente questo tipo di esperienza.
E voi, che tipo di assistente conversazionale costruirete?