studio

Introduzione

Control plane open-source per i tuoi agenti AI.

Deco CMS Studio è la piattaforma dove puoi ingaggiare agenti, connettere strumenti e organizzarli in progetti che svolgono compiti reali. Tutto è tracciato: token, costi, errori, latenza, per ogni connessione, per ogni agente. Puoi ospitarlo in locale per la privacy o sincronizzarlo con il cloud per l'accesso remoto, i ruoli di team e la fatturazione condivisa.

Cos'è Deco CMS?

Studio è dove ingaggi agenti, connetti strumenti e li organizzi in progetti che fanno davvero cose.

Gli agenti arrivano con competenze reali e prompt collaudati. Le connessioni danno loro accesso ai tuoi strumenti — GitHub, Slack, Postgres, OpenRouter, qualsiasi cosa che parli MCP — configurati tramite una UI web con OAuth one-click. I progetti raggruppano agenti e connessioni attorno a un obiettivo: ogni progetto ha la sua sidebar e UI, modellate in base a ciò che contiene.

┌─────────────────────────────────────────────────────────────────┐
│                           Client                                │
│         Cursor · Claude · VS Code · Agenti Personalizzati       │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                         DECO CMS                              │
│ Agenti · Connessioni · Progetti · Osservabilità · Token Vault   │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                     Strumenti & Server MCP                      │
│      GitHub · Slack · Postgres · OpenRouter · Le tue API        │
└─────────────────────────────────────────────────────────────────┘

Avvio Rapido

bunx decocms

Oppure clona ed esegui dal codice sorgente:

git clone https://github.com/decocms/studio.git
bun install
bun run dev

In esecuzione su http://localhost:3000 (client) + server API

Cosa ottieni

Agenti

Sfoglia e ingaggia agenti AI specializzati dallo store integrato. Ogni agente sa come usare strumenti specifici e viene fornito con prompt collaudati. Gli agenti possono comporsi l'un l'altro e ogni azione è tracciata con attribuzione dei costi.

Connessioni

Configura connessioni MCP tramite una UI web con OAuth one-click. Nessuna configurazione JSON. Monitora latenza, errori e costi per connessione. Condividi strumenti con il tuo team senza condividere le credenziali.

Man mano che le superfici degli strumenti crescono, Studio espone MCP Virtuali — un singolo endpoint, diverse strategie per quali strumenti esporre:

• Contesto completo: espone tutto (semplice, deterministico, ottimo per set di strumenti piccoli)
• Selezione intelligente: restringe il set di strumenti prima dell'esecuzione
• Esecuzione di codice: carica gli strumenti su richiesta in una sandbox

Progetti

I progetti raggruppano agenti e connessioni attorno a un obiettivo. L'interfaccia utente del progetto si adatta a ciò che contiene: aggiungi un agente di contenuto e una connessione CMS, la sidebar mostrerà la gestione dei contenuti; aggiungi un agente di analisi e un database, mostrerà dashboard e query. L'interfaccia utente che vedi è quella pertinente per l'operatività di quel progetto.

Puoi anche definire gli outcome in modo dichiarativo e lasciare che Studio lavori a ritroso per derivare le milestone, assegnare gli agenti e verificare i risultati.

Osservabilità

Spesa di token per connessione — OpenRouter, Perplexity, Firecrawl, tutto. Latenza, errori, colli di bottiglia. Una dashboard unificata.

Dal tuo laptop alla tua organizzazione

Funzionalità principali

Definizione degli strumenti

Tipizzati in modo sicuro, auditati, osservabili, richiamabili via MCP.

import { z } from "zod";
import { defineTool } from "~/core/define-tool";

export const CONNECTION_CREATE = defineTool({
  name: "CONNECTION_CREATE",
  description: "Create a new MCP connection",
  inputSchema: z.object({
    name: z.string(),
    connection: z.object({
      type: z.enum(["HTTP", "SSE", "WebSocket"]),
      url: z.string().url(),
      token: z.string().optional(),
    }),
  }),
  outputSchema: z.object({
    id: z.string(),
    scope: z.enum(["workspace", "project"]),
  }),
  handler: async (input, ctx) => {
    await ctx.access.check();
    const conn = await ctx.storage.connections.create({
      projectId: ctx.project?.id ?? null,
      ...input,
      createdById: ctx.auth.user!.id,
    });
    return { id: conn.id, scope: conn.projectId ? "project" : "workspace" };
  },
});

Ogni chiamata di strumento ottiene automaticamente la validazione dell'input/output, il controllo degli accessi, la registrazione degli audit e le trace OpenTelemetry.

Struttura del progetto

├── apps/
│   ├── mesh/                # Deco CMS full-stack (API Hono + Vite/React)
│   │   ├── src/
│   │   │   ├── api/         # Hono HTTP + route proxy MCP
│   │   │   ├── auth/        # Better Auth (OAuth + chiavi API)
│   │   │   ├── core/        # MeshContext, AccessControl, defineTool
│   │   │   ├── tools/       # Strumenti di gestione MCP integrati
│   │   │   ├── storage/     # Adattatori DB Kysely
│   │   │   ├── event-bus/   # Sistema di delivery eventi Pub/sub
│   │   │   ├── encryption/  # Token vault & gestione credenziali
│   │   │   ├── observability/  # Tracing & metriche OpenTelemetry
│   │   │   └── web/         # UI admin React 19
│   │   └── migrations/      # Migrazioni database Kysely
│   └── docs/                # Sito di documentazione Astro
│
└── packages/
    ├── bindings/            # Bindings MCP core e astrazioni di connessione
    ├── runtime/             # Proxy MCP, OAuth e utility di runtime
    ├── ui/                  # Componenti React condivisi (basati su shadcn)
    ├── cli/                 # Tooling CLI (comandi deco)
    ├── create-deco/         # Scaffolding di progetto (npm create deco)
    └── vite-plugin-deco/    # Plugin Vite per progetti Deco

Sviluppo

bun install          # Installa le dipendenze
bun run dev          # Avvia il server di sviluppo (client + API)
bun test             # Esegui i test
bun run check        # Controllo dei tipi
bun run lint         # Lint
bun run fmt          # Formatta

Comandi Studio (da apps/mesh/)

bun run dev:client     # Server dev Vite (porta 4000)
bun run dev:server     # Server Hono con hot reload
bun run migrate        # Esegui le migrazioni del database

Worktrees

dev:worktree instrada http://<WORKTREE_SLUG>.localhost tramite Caddy — utile per eseguire più workspace senza conflitti di porta.

# Setup una tantum
brew install caddy && caddy start

# Avvio
WORKTREE_SLUG=my-feature bun run dev:worktree

# Adattatore Conductor (imposta WORKTREE_SLUG da CONDUCTOR_WORKSPACE_NAME)
bun run dev:conductor

Deploy ovunque

# Docker (PostgreSQL embedded)
docker compose -f deploy/docker-compose.yml up

# Docker (PostgreSQL)
docker compose -f deploy/docker-compose.postgres.yml up

# Bun
bun run build:client && bun run build:server && bun run start

# Kubernetes (Helm)
helm install deco-studio oci://ghcr.io/decocms/chart-deco-studio --version <version> -n deco-studio --create-namespace

Nessun vendor lock-in. Funziona su Docker, Kubernetes, AWS, GCP o runtime locali.

Stack Tecnologico

Licenza

Sustainable Use License (SUL) — vedi LICENSE.md.

• Gratuito per self-hosting per uso interno
• Gratuito per progetti client (agenzie, SI)
• Licenza commerciale richiesta per SaaS o sistemi di produzione che generano entrate

Domande? builders@decocms.com

Collaborazione

bun run fmt      # Formatta
bun run lint     # Lint
bun test         # Test