# Collega una fonte dati

Le connessioni sono il primo pezzo di stato della piattaforma da cui dipendono le tue dashboard, e l'illustrazione più chiara della divisione: la dashboard è codice che il tuo agente scrive e può riscrivere in un minuto; la connessione è una credenziale, un percorso di rete e uno schema introspezionato che qualcuno ha configurato una volta e che deve continuare a funzionare per un anno.

Configuri una connessione una volta sola. Da quel momento ogni superficie interroga attraverso di essa — il tuo agente via MCP, il tuo codice via gli SDK, l'assistente integrato nell'app, e ogni dashboard pubblicata.

## Cosa puoi collegare[​](#cosa-puoi-collegare "Link diretto a Cosa puoi collegare")

Vibedasher ha **20 tipi di connessione**. Diciannove hanno un'implementazione del servizio funzionante, e **diciannove sono offerti oggi nel selettore di connettori dell'app**. La differenza conta se stai valutando il prodotto rispetto a una fonte specifica, quindi ecco l'elenco completo invece di un numero da marketing.

### Database e data warehouse[​](#database-e-data-warehouse "Link diretto a Database e data warehouse")

| Fonte              | Nel selettore | Caricamenti incrementali |
| ------------------ | ------------- | ------------------------ |
| PostgreSQL         | sì            | sì                       |
| MySQL              | sì            | sì                       |
| SQL Server (MSSQL) | sì            | sì                       |
| Oracle             | sì            | sì                       |
| Redshift           | sì            | sì                       |
| Snowflake          | sì            | sì                       |
| BigQuery           | sì            | sì                       |
| Athena             | sì            | sì                       |
| MongoDB            | sì            | no                       |
| Cassandra          | sì            | no                       |
| DynamoDB           | sì            | no                       |

### SaaS e archivi di file[​](#saas-e-archivi-di-file "Link diretto a SaaS e archivi di file")

| Fonte                | Nel selettore | Caricamenti incrementali |
| -------------------- | ------------- | ------------------------ |
| Salesforce           | sì            | no                       |
| HubSpot              | sì            | no                       |
| Marketo              | sì            | no                       |
| Mailchimp            | sì            | no                       |
| Google Sheets        | sì            | no                       |
| Google Analytics     | sì            | no                       |
| Azure Data Lake      | sì            | no                       |
| Google Cloud Storage | sì            | no                       |
| SAP                  | **no**        | no                       |

**SAP** richiede `pyrfc`, l'SDK RFC NetWeaver proprietario di SAP, che non è su PyPI — quindi il connettore non è distribuito. Su alcuni account esiste ancora una riga di connessione `sap`, e l'introspezione dello schema su di essa risponde `404`.

### Caricamento di file flat[​](#caricamento-di-file-flat "Link diretto a Caricamento di file flat")

Il caricamento accetta **CSV** (`.csv`) ed **Excel** (`.xlsx`, `.xls`).

**Parquet non è un formato di caricamento.** Vibedasher memorizza i tuoi dati internamente come Parquet, ma non è qualcosa che puoi caricare. Se i tuoi dati sono già in Parquet, portali in uno storage che Vibedasher può interrogare, oppure convertili in CSV.

## I caricamenti incrementali richiedono un dialetto SQL[​](#i-caricamenti-incrementali-richiedono-un-dialetto-sql "Link diretto a I caricamenti incrementali richiedono un dialetto SQL")

La colonna **Caricamenti incrementali** sopra non è una decisione di prodotto, è una decisione meccanica. Un caricamento incrementale funziona riscrivendo la tua query di estrazione per aggiungere un predicato watermark, e quella riscrittura richiede un dialetto SQL che la piattaforma possa analizzare. Otto connettori ne hanno uno — PostgreSQL, MySQL, SQL Server, Oracle, Redshift, Snowflake, BigQuery e Athena.

Ogni altro connettore, incluso MongoDB, DynamoDB e tutte le fonti SaaS, si aggiorna tramite **ricaricamento completo**. È corretto, solo più costoso: mettilo in conto su una fonte di grandi dimensioni, e vedi [Mantieni i tuoi dati aggiornati](/it/guides/keep-your-data-fresh.md) per cosa riporta `effectiveMode`.

## Aggiungi una connessione[​](#aggiungi-una-connessione "Link diretto a Aggiungi una connessione")

1. Apri l'app su [cloud.vibedasher.com](https://cloud.vibedasher.com) e vai su **Connessioni**.
2. Scegli il tipo di fonte e compila i dettagli della connessione — oppure carica il tuo file.
3. Esegui **Test connessione**. Questo apre effettivamente la connessione; non è un controllo del formato dei campi.
4. Salva. Vibedasher introspeziona lo schema in modo che agenti e motore di query sappiano quali tabelle e colonne esistono.

Modificare una connessione in seguito

Le credenziali salvate sono mascherate nell'interfaccia. Quando modifichi una connessione, **lascia intatto un campo mascherato per mantenere il valore esistente** — la piattaforma rileva la mascheratura al momento del rientro e preserva ciò che già ha, invece di sovrascrivere la tua password con una riga di puntini.

Puoi anche fare tutto questo da codice:

```
schema = client.connections.get_schema(connection_type, connection_id)

tables = client.connections.get_tables(connection_type, connection_id)
```

```
const schema = await client.connections.getSchema(connectionType, connectionId);

const tables = await client.connections.getTables(connectionType, connectionId);
```

L'insieme completo — `create`, `list`, `get`, `update`, `updateMetadata`, `delete`, `test`, `getSchema`, `getTables`, `getTableSchema`, `validateQuery` — si trova nel **[Riferimento API](/it/reference/vibedasher-sdk-api.md)**.

## Chi può gestire una connessione[​](#chi-può-gestire-una-connessione "Link diretto a Chi può gestire una connessione")

Le connessioni **non** sono coperte dal modello dei diritti di accesso sulle cartelle — non esiste un grant per singola connessione. Le regole sono più semplici e vale la pena enunciarle chiaramente:

* Qualsiasi **creator** o **admin** può creare una connessione. Un **viewer** non può.
* Solo il **proprietario** della connessione o un **admin** può modificarla o eliminarla.
* Una connessione non è visibile al resto dell'account nel modo in cui lo è una cartella condivisa.

Se hai bisogno di una connessione che più persone possano gestire, un admin dovrebbe esserne il proprietario. Vedi [Chi può vedere cosa](/it/guides/who-can-see-what.md) per il resto del modello dei permessi.

## Dataset[​](#dataset "Link diretto a Dataset")

Una connessione è un percorso verso i tuoi dati; un **dataset** è ciò che le dashboard leggono effettivamente. Crei i dataset a partire da una connessione — una tabella, o il risultato di una query.

Ogni dataset ottiene un alias `cleanSQLName`, che è il nome della tabella su cui il tuo agente scrive SQL. Un dataset passa attraverso `PENDING → DOWNLOADING → PROCESSING → READY`, e una dashboard costruita su uno che non ha ancora raggiunto **READY** non avrà nulla da disegnare. Attendi `READY`.

I dataset sono stato vivo, non importazioni una tantum: attiva un **aggiornamento** per farne avanzare uno, ed esegui **progetti dbt** a valle di esso. Le dashboard recepiscono i dati aggiornati attraverso lo stesso motore di query, senza ricostruzione — che è l'intera ragione per cui la metà dati vive qui e non nella sessione del tuo agente.

## Passo successivo[​](#passo-successivo "Link diretto a Passo successivo")

Punta il tuo agente sul dataset — **[Crea con il tuo agente (MCP)](/it/guides/build-with-your-agent.md)** — oppure **[punta il tuo agente su di esso](/it/guides/build-with-your-agent.md)**. Poi configura gli **[aggiornamenti](/it/guides/keep-your-data-fresh.md)** in modo che rimanga veritiera.