# OpenDots di CopilotKit: guida all’installazione e al primo test

> Fonte: https://francescogruner.it/opendots-copilotkit-guida-installazione/

**OpenDots è il progetto open source di CopilotKit per costruire assistenti persistenti che lavorano tra web, Slack e chiamate, ciascuno con il proprio spazio, i propri strumenti e - se configurato - un computer isolato.** Non è un servizio pronto equivalente a OpenAI Dots: è un template MIT da installare, collegare ai servizi necessari e adattare.

 

*Metodo: ho verificato il repository ufficiale [CopilotKit/OpenDots](https://github.com/CopilotKit/OpenDots) al commit `b01ac1f6a903e5e56c119d960901353ac0a3d171`. Ho installato 1.017 pacchetti, controllato l’audit npm - zero vulnerabilità riportate - e completato la build Vite e TypeScript. La build è riuscita anche con Node 22, ma il progetto richiede ufficialmente Node.js 24 o successivo: per un’installazione corretta va rispettato quel requisito.*

   

Indice dei contenuti

 [Toggle](#) 

- [Che cos’è davvero OpenDots](#Che_cose_davvero_OpenDots)
- [OpenDots e OpenAI Dots: cosa cambia](#OpenDots_e_OpenAI_Dots_cosa_cambia)

- [CopilotKit OpenDots](#CopilotKit_OpenDots)
- [OpenAI Dots](#OpenAI_Dots)
- [Ti sta piacendo?](#Ti_sta_piacendo)
- [Guida all’installazione locale](#Guida_allinstallazione_locale)

- [1. Requisiti](#1_Requisiti)
- [2. Clonare e preparare il progetto](#2_Clonare_e_preparare_il_progetto)
- [3. Configurare conversazioni e modello](#3_Configurare_conversazioni_e_modello)
- [4. Creare Space, pagina e primo Dot](#4_Creare_Space_pagina_e_primo_Dot)
- [5. Build e avvio della versione locale](#5_Build_e_avvio_della_versione_locale)
- [6. Avvio con Docker Compose](#6_Avvio_con_Docker_Compose)
- [7. Browser di ricerca e computer persistenti](#7_Browser_di_ricerca_e_computer_persistenti)
- [8. Collegare Slack](#8_Collegare_Slack)
- [Cosa ho verificato e cosa no](#Cosa_ho_verificato_e_cosa_no)
- [Limiti attuali](#Limiti_attuali)
- [La mia valutazione](#La_mia_valutazione)
- [Domande frequenti](#Domande_frequenti)
- [Fonti e riferimenti](#Fonti_e_riferimenti)

- [CopilotKit/OpenDots](#CopilotKitOpenDots)
- [OpenDots Setup](#OpenDots_Setup)
- [OpenAI - Introducing dots](#OpenAI_-_Introducing_dots)

 

## Che cos’è davvero OpenDots

 

OpenDots è una base di sviluppo per creare un workspace di “colleghi AI” persistenti. È costruito con CopilotKit e il protocollo AG-UI. L’interfaccia comprende Spaces, documenti, conversazioni separate per specialista, attività in background, controlli human-in-the-loop e collegamenti opzionali a Slack, chiamate e computer dedicati.

 

- **Spaces:** aree che raccolgono documenti e pagine organizzate anche come sottopagine;
- **Specialist Dots:** assistenti con nome, ruolo, istruzioni, strumenti e accesso solo agli Space assegnati;
- **Threads persistenti:** le conversazioni usano CopilotKit Intelligence e restano separate per pagina e specialista;
- **Background work:** attività che possono proseguire mentre l’interfaccia non è aperta, se il server rimane in esecuzione;
- **Canali:** integrazione Slack gestita e chiamate vocali tramite un provider Realtime;
- **Computer per Dot:** integrazione opzionale con OpenBot per browser, file e shell persistenti e permessi configurabili.

 

La distinzione importante è quella usata dagli stessi autori: **“a template, not a hosted product”**. Cloni il codice, gestisci l’infrastruttura e configuri i servizi. Il progetto è in alpha e non offre ancora identità multiutente, collaborazione in tempo reale, upload di file, delega automatica tra più Dot o un sistema completo di trigger ed eventi.

 

## OpenDots e OpenAI Dots: cosa cambia

   

### CopilotKit OpenDots

**Forma**Template open source MIT**Gestione**La installi e configuri tu**Stack**React, Node, CopilotKit, AG-UI, Intelligence**Stato**Alpha, singolo proprietario 

### OpenAI Dots

**Forma**Servizio gestito da OpenAI**Gestione**Computer cloud e controlli del workspace**Modello**GPT-6 Astra secondo OpenAI**Stato**Rollout in base a piano e regione  

Al 2 ottobre 2026 OpenAI esclude dal rollout per ChatGPT Pro il SEE, il Regno Unito e la Svizzera. Non è però corretto dire che Dots sia indisponibile in tutta Europa: OpenAI lo indica per Business Premium nelle regioni supportate e in beta per workspace Enterprise idonei. OpenDots interessa perché il codice è disponibile subito, ma richiede più lavoro e servizi esterni per diventare operativo.

                  

## Ti sta piacendo?

 

Ricevi una guida pratica ogni settimana. AI, tool e automazioni.

            Iscriviti gratis             Perfetto, sei dentro.        

## Guida all’installazione locale

 

### 1. Requisiti

 

- Node.js 24 o successivo;
- npm;
- Git;
- facoltativamente Docker per i container;
- un progetto CopilotKit Intelligence e un provider di modelli per le conversazioni reali.

 

Puoi aprire Spaces, configurare Dot e modificare pagine anche prima di collegare i servizi di conversazione. Senza credenziali l’app mostra lo stato di configurazione e non inventa risposte simulate.

 

### 2. Clonare e preparare il progetto

 

```
git clone https://github.com/CopilotKit/OpenDots.git
cd OpenDots
npm ci
cp .env.example .env
```

 

Prima di modificare `.env`, avvia pure la modalità locale per controllare che l’interfaccia parta:

 

```
npm run dev
```

 

Apri `http://127.0.0.1:5173`. L’API locale usa la porta `4310`.

 

### 3. Configurare conversazioni e modello

 

Apri il file `.env` esclusivamente sul server. Le variabili centrali sono:

 

```
INTELLIGENCE_API_KEY="..."
OPENAI_API_KEY="..."
OPENAI_MODEL="modello-supportato"
OWNER_ID="identita-stabile-del-proprietario"
DATABASE_PATH="./data/opendots.db"
OWNER_TOKEN="token-casuale-lungo"
```

 

`OPENAI_BASE_URL` permette di indicare un endpoint compatibile con l’adattatore configurato. Le credenziali restano sul server. La cronologia delle conversazioni vive nel progetto Intelligence, mentre pagine, Spaces, Dot e metadati delle attività sono salvati in SQLite: per un backup completo servono entrambi.

 

### 4. Creare Space, pagina e primo Dot

 

1. crea uno Space di laboratorio;
2. aggiungi una pagina con contenuto non sensibile;
3. crea un Dot con un ruolo preciso, per esempio ricercatore o redattore;
4. assegna al Dot soltanto lo Space di prova;
5. apri la chat della pagina e seleziona lo specialista;
6. salva manualmente le modifiche prima di chiedere al Dot di riscrivere il documento;
7. controlla che una revisione obsoleta non sovrascriva una versione più recente.

 

Le pagine funzionano anche senza servizi conversazionali. Il chat della pagina, il salvataggio di una conversazione e la revisione da parte del Dot richiedono invece Intelligence e un modello configurati.

 

### 5. Build e avvio della versione locale

 

```
npm run build
npm start
```

 

La versione compilata risponde su `http://127.0.0.1:4310`. Il server deve restare in esecuzione perché le attività in background possano continuare. Nella mia verifica la build Vite e TypeScript è riuscita; Vite ha segnalato alcuni chunk superiori a 500 kB, un limite di ottimizzazione da considerare ma non un errore di compilazione.

 

### 6. Avvio con Docker Compose

 

Imposta in `.env` due segreti diversi di almeno 24 caratteri per `OWNER_TOKEN` e `BROWSER_SECRET`, poi esegui:

 

```
docker compose up --build -d
```

 

L’app risponde su `http://localhost:4310`. I metadati sono conservati nel volume `opendots-data`. Per fermare i servizi mantenendo i dati:

 

```
docker compose down
```

 

### 7. Browser di ricerca e computer persistenti

 

Il browser semplice legge una URL pubblica e restituisce testo e cattura. Usa JavaScript disabilitato, non supporta indirizzi privati o pagine autenticate e non è un desktop generale:

 

```
npx playwright install chromium
npm run browser
```

 

Per dare a ogni Dot browser, file persistenti e shell bisogna invece seguire la configurazione OpenBot descritta in `docs/COMPUTERS.md`. I permessi browser, file e shell sono separati per Dot. È una superficie molto più sensibile: va testata in un ambiente isolato prima di inserire account o dati reali.

 

### 8. Collegare Slack

 

OpenDots usa Channels SDK e una connessione Slack gestita da CopilotKit Intelligence. Dopo aver selezionato lo stesso progetto Intelligence:

 

```
npx --yes copilotkit@latest project select
npx --yes copilotkit@latest channels add \
  --name opendots \
  --display-name "OpenDots" \
  --adapter slack \
  --json
```

 

La procedura restituisce le azioni da completare nella console Slack. In `.env` vanno poi configurati il nome del canale gestito, il team autorizzato, gli utenti consentiti e l’ID del Dot. Questo non crea un modello multiutente: gli utenti Slack ammessi vengono ancora mappati sul singolo proprietario OpenDots.

 

## Cosa ho verificato e cosa no

 

- **Verificato:** repository ufficiale, commit, installazione npm, audit delle dipendenze, build Vite e TypeScript;
- **Non verificato end to end:** progetto Intelligence, risposte del modello, Slack reale, chiamate, browser separato e computer OpenBot;
- **Avvertenza:** la build ha funzionato con Node 22, ma il requisito ufficiale è Node 24; non considererei Node 22 una configurazione supportata.

 

## Limiti attuali

 

- singolo proprietario, senza provisioning e ruoli multiutente;
- nessuna collaborazione in tempo reale sulle pagine;
- nessun upload di file o embed interattivo arbitrario;
- schedulazioni ricorrenti, non un motore completo di trigger e responsabilità persistenti;
- Dot separati, ma niente chat di gruppo multi-Dot o delega automatica;
- diversi flussi utili dipendono da servizi CopilotKit e provider esterni, quindi self-hosted non significa automaticamente tutto locale.

 

## La mia valutazione

 

Questo è il progetto coerente con l’idea di “alternativa open source a OpenAI Dots”: non una semplice chat locale, ma un template per assistenti persistenti che attraversano documenti, canali e computer. L’architettura è più ambiziosa, ma anche più dipendente da una configurazione corretta dei servizi.

 

Oggi lo userei come base di laboratorio o acceleratore per un prodotto interno, non come piattaforma pronta da consegnare a un team. Il primo test sensato è limitato: uno Space, un Dot, una pagina, nessun dato cliente e nessun computer operativo finché non sono stati verificati permessi, backup e confini dei provider.

 

Per il quadro sul servizio ufficiale puoi leggere anche [OpenAI Dots porta gli agenti sempre attivi nel cloud](https://francescogruner.it/radar-ai/29-settembre-2026/openai-dots-agenti-sempre-attivi-cloud/).

 

## Domande frequenti

 OpenDots è un prodotto pronto da usare?

No. È un template open source in alpha che va installato, configurato e adattato.

 OpenDots funziona senza servizi esterni?

Le pagine e la configurazione locale possono funzionare senza conversazioni. Chat persistenti, modelli, Slack, chiamate e alcune capacità richiedono invece servizi e credenziali configurati.

 È davvero self-hosted?

L’applicazione e SQLite possono essere ospitati da te. La cronologia può risiedere in CopilotKit Intelligence e le inferenze passano dal provider scelto: bisogna verificare ogni confine separatamente.

  

## Fonti e riferimenti

Verifica effettuata il 2 ottobre 2026.

 [### CopilotKit/OpenDots

Repository, architettura, stato e limiti ufficiali.

Apri fonte](https://github.com/CopilotKit/OpenDots) [### OpenDots Setup

Installazione, variabili, Slack, browser, container e verifiche.

Apri fonte](https://github.com/CopilotKit/OpenDots/blob/main/docs/SETUP.md) [### OpenAI - Introducing dots

Funzioni e disponibilità del servizio OpenAI usato nel confronto.

Apri fonte](https://openai.com/index/introducing-dots/?print=1)