AIクライアントに対し、エージェント、ツール、モデル、および呼び出しごとのコスト追跡を管理する、単一の統制されたMCPエンドポイントを提供します。
別名 decocms/studio, deco-cli, decocms
- スター
- 418
- ツール
- —
- ダウンロード数(30日間)
- 85,291
- 最新バージョン
- —
- 最終コミット
- 2026年11月14日
- ライセンス
- MIT
deco Studio MCPとは
deco StudioはMCPサーバーです。 AIクライアントに対し、エージェント、ツール、モデル、および呼び出しごとのコスト追跡を管理する、単一の統制されたMCPエンドポイントを提供します。.
プロジェクトのREADMEから生成された概要
deco Studio MCP server について
Studioは、組織的なAI展開のための集中管理コントロールプレーンを提供します。エージェント、ツール、モデルを管理しながら、呼び出しごとのコストを追跡する、単一の統制されたMCPエンドポイントとして機能します。組織はこれを利用して、コンテキストとポリシーをパッケージ化し、Cursor、Claude Desktop、またはVS Codeなどのクライアントから呼び出し可能なエージェントを作成できます。
ユーザーは、暗号化されたVaultを通じてGitHub、Slack、Postgresなどのプライベートシステムを接続できるため、実際の認証情報を共有することなく、チーム内でMCP機能を共有できます。このプラットフォームは交換可能なモデルレイヤーをサポートしており、OpenRouterや、Anthropic、OpenAI、Googleなどの直接プロバイダーへの接続が可能です。PostgreSQLとNATSを含むDocker Composeを使用してローカルにデプロイすることも、リモートチームがアクセスできるクラウドサービス経由で使用することもできます。
管理者は、レイテンシ、エラー、トークンを追跡するオブザーバビリティダッシュボードを通じて監視を維持できます。システムは、SSO、ロールベースのアクセス制御、監査ログなどのエンタープライズグレードの管理機能を提供し、会社全体で安全で責任あるAI利用を保証します。
できること
- 1内部ツールの安全な共有開発者は、基盤となる認証情報を公開することなく、エージェントにプライベートデータベースへのアクセス権を付与できます。
- 2AI運用コストの監視管理者は、異なるモデルやエージェントにいくら費用が費やされているかを正確に追跡できます。
- 3エージェント設定の標準化チームは、組織全体で使用される、定義済みの指示とツールを備えた特定のエージェントを作成できます。
- 4マルチモデルルーティングの管理エンジニアは、単一のインターフェースを通じて、タスクごとに異なるAIプロバイダーを切り替えることができます。
プロジェクトの README から作成されています。すべてのユースケースは、その引用と照らし合わせて確認されています。
deco Studio MCPのインストール方法
フォーマット検証日 2026年11月10日Cursor に追加Gooseに追加Claude Codeにdeco Studio MCPをインストール
$ claude mcp add studio -- npx -y deco-cliCursorにdeco Studio MCPをインストール
~/.cursor/mcp.json
{
"mcpServers": {
"studio": {
"command": "npx",
"args": [
"-y",
"deco-cli"
]
}
}
}VS Codeにdeco Studio MCPをインストール
.vscode/mcp.json
{
"servers": {
"studio": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"deco-cli"
]
}
}
}VS Code CLIにdeco Studio MCPをインストール
$ code --add-mcp '{"name":"studio","type":"stdio","command":"npx","args":["-y","deco-cli"]}'Claude Desktopにdeco Studio MCPをインストール
claude_desktop_config.json
{
"mcpServers": {
"studio": {
"command": "npx",
"args": [
"-y",
"deco-cli"
]
}
}
}Codexにdeco Studio MCPをインストール
$ codex mcp add studio -- npx -y deco-cliCodex config.tomlにdeco Studio MCPをインストール
~/.codex/config.toml
[mcp_servers.studio] command = "npx" args = ["-y", "deco-cli"]
Gemini CLIにdeco Studio MCPをインストール
$ gemini mcp add -s user studio npx -- -y deco-cliGemini settings.jsonにdeco Studio MCPをインストール
~/.gemini/settings.json
{
"mcpServers": {
"studio": {
"command": "npx",
"args": [
"-y",
"deco-cli"
]
}
}
}自動チェック
実行日 2026年11月12日完全なレポート →自動チェックに合格しました。これはセキュリティ監査ではありません。コードを読み、サーバーに必要最小限のアクセス権を与えてください。 チェックの仕組み
- ソースリポジトリがリンクされており、アクセス可能合格
- オープンソースライセンス (OSI)合格
- 過去1年以内にコミットまたはリリースあり合格
- パッケージ名が有名なパッケージに酷似していない合格
- リモートエンドポイントがHTTPSを使用未チェック
- 破壊的なツールがラベル付けされている未チェック
- モデルへの隠れた指示がない合格
- パッケージおよびその依存関係に重大な勧告なし未チェック
README
GitHubで見るTL;DR: Your team needs a secure internal vibecoding platform. You just found it. Configure agents with team context. Connect private MCPs once — share capabilities, not credentials. Keep the model layer interchangeable. Roll out across the organization with SSO, RBAC, audit logs, and cost controls — all through one MCP endpoint. Local-first. Self-host or use the cloud.
What is deco Studio?
Studio packages the infrastructure behind an internal AI rollout: model routing, MCP authentication, agent configuration, SSO, RBAC, audit logs, and usage accounting. Your teams get chat. You keep control.
Under the hood it's one control plane for your AI agents — one MCP endpoint for all your agents, tools, and models. Agents package context, tools, and policy into something you publish to the organization. Connections give them governed access to your systems — GitHub, Slack, Postgres, Sentry, anything that speaks MCP — with tokens stored in an encrypted vault. Models stay interchangeable: OpenRouter or direct providers, chosen per agent and per tool.
Start with one team. Standardize approved models, tools, and context. Expand across the organization without copying secrets or rebuilding the platform. Install locally and it stays private; sync to the cloud for remote access, team roles, and shared billing.
┌─────────────────────────────────────────────────────────────────┐
│ Clients │
│ Cursor · Claude · VS Code · Custom Agents │
└───────────────────────────┬─────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ DECO STUDIO │
│ Agents · Connections · Models · Vault · Observability │
└───────────────────────────┬─────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ Tools & MCP Servers │
│ GitHub · Slack · Postgres · OpenRouter · Your APIs │
└─────────────────────────────────────────────────────────────────┘
Quick Start
Install Docker with Compose, then run from source:
git clone https://github.com/decocms/studio.git
cd studio
docker compose up --build --watch
Open http://localhost:4000. Compose starts PostgreSQL, NATS, object storage, migrations, and the hot-reloading API and web app. See CONTRIBUTING.md for contributor setup and worktrees.
What you get
Agents
Package context, tools, and policy into an agent. Define instructions, add skills and files, grant approved MCP access, choose a model policy, then publish the agent to the organization. Each agent is its own MCP endpoint — callable from Cursor, Claude Desktop, your own code, or another agent. Agents compose, and every action is tracked with cost attribution.
Connections
Connect private systems once, securely. Register MCP servers at the organization level through a web UI with one-click OAuth — no JSON configs. Tokens live in the encrypted vault, and you grant tool-level access by organization, role, or agent. Share MCP capabilities — not credentials.
As tool surfaces grow, Studio exposes Virtual MCPs — one endpoint, different strategies for which tools to surface:
- Full-context: expose everything (simple, deterministic, good for small toolsets)
- Smart selection: narrow the toolset before execution
- Code execution: load tools on demand in a sandbox
Models
Keep the AI layer interchangeable. Use OpenRouter or connect Anthropic, OpenAI, Google, or any compatible provider directly — the best model for each agent and tool, behind one router. For coding work, engineers can link their own Claude Code or Codex session and use the subscription already authenticated on their machine.
Projects
Projects bring agents and connections together around a goal. The project's UI adapts to what's inside — add a content agent and a CMS connection, the sidebar shows content management; add an analytics agent and a database, it shows dashboards and queries. The UI you see is the UI that's relevant for operating that project.
Observability
Account for every model and tool call. Trace the user, agent, model, tools, latency, errors, tokens, and cost for every thread. Break usage down by agent, connection, organization, or teammate — one dashboard.
From your desktop to your org
| Local | Docker Compose on your laptop, including PostgreSQL, NATS, and object storage. |
| Cloud | Log in to studio.decocms.com. Control local projects from any browser. |
| Team | Invite people. SSO and role-based access. Shared connections. Cost attribution. |
| Enterprise | Self-hosted. Organization isolation, tool-scoped API keys, audit logs. Your infra, your rules. |
Core Capabilities
| Capability | What it does |
|---|---|
| Agents | Package context, tools, and policy into publishable agents with cost attribution |
| Connections | Route MCP traffic through one governed endpoint with auth, proxy, and encrypted token vault |
| Models | Interchangeable AI layer — OpenRouter or direct providers, model policy per agent |
| Projects | Organize agents and connections around goals with an adaptive UI |
| Virtual MCPs | Compose and expose governed toolsets as new MCP endpoints |
| Observability | Traces, costs, errors, and latency per user, agent, and connection — one dashboard |
| Access Control | SSO + RBAC via Better Auth — OAuth 2.1 and tool-scoped API keys per workspace/project |
| Multi-tenancy | Organization/project isolation for config, credentials, policies, and audit logs |
| Bindings | Capability contracts so tools target interfaces, not specific implementations |
| Store | Discover and install agents, tools, and templates |
Define Tools
Type-safe, audited, observable, callable 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" };
},
});
Every tool call gets input/output validation, access control, audit logging, and OpenTelemetry traces automatically.
Documentation
Studio documentation lives in docs-tanstack, alongside the Storefront documentation. Update public product guides and architecture there. Workspace READMEs and engineering plans stay here with the implementation.
Project Structure
Applications
| Workspace | Purpose |
|---|---|
apps/api |
Hono API, authentication, tools, storage, migrations, and the deco CLI |
apps/web |
Vite and React 19 administration interface |
Packages
| Workspace | Purpose |
|---|---|
packages/bindings |
Runtime-validated MCP capability contracts |
packages/create-deco |
npm create deco project scaffolding CLI |
packages/e2e |
Black-box Playwright suite for Studio |
packages/harness-runner |
In-sandbox coding-agent harness process |
packages/mcp-utils |
MCP proxy, gateway, aggregation, and sandbox primitives |
packages/runtime |
Runtime helpers for MCP servers, OAuth, tools, and triggers |
packages/sandbox |
Agent sandbox lifecycle, daemon, dispatch, and proxy implementation |
packages/sandbox-controller |
Sandbox provider bundled for a remote host such as the control plane |
packages/shared |
Private isomorphic contracts, SDK utilities, and async primitives |
packages/typegen |
Typed client generator for Studio Virtual MCPs |
packages/ui |
Internal React design system |
Development
bun install # Install dependencies
bun run dev # Docker Compose Watch: dependencies, migrations, API + web
bun test # Run tests
bun run check # Type check
bun run lint # Lint
bun run fmt # Format
App-specific commands
bun run --cwd=apps/web dev # Vite dev server (port 4000)
bun run --cwd=apps/api dev:server # Hono server with hot reload
bun run --cwd=apps/api migrate # Run database migrations
For parallel worktrees, Compose lifecycle commands, and frontend-only work, see CONTRIBUTING.md.
Deploy Anywhere
# Docker Compose: released Studio + PostgreSQL + NATS + object storage
docker compose -f selfhost/examples/docker-compose/compose.yaml up -d
# Kubernetes (Helm)
helm install deco-studio oci://ghcr.io/decocms/chart-deco-studio --version <version> -n deco-studio --create-namespace
Run Studio with Docker Compose or Kubernetes on your own infrastructure.
What you need to run it
| Tier | Footprint |
|---|---|
| Laptop | Docker with Compose; the development stack includes its dependencies. |
| Docker | Published Studio image with configured PostgreSQL, NATS, and object storage. |
| Production (Helm) | PostgreSQL you bring, plus NATS for streaming and cross-pod coordination, ClickHouse + OTel Collector (traces and analytics), and the sandbox operator (isolated agent environments on Kubernetes). Your identity provider, your model keys, your storage. |
Production topology
graph TB
clients["MCP clients — Cursor · Claude · VS Code · your code"]
clients -->|"one MCP endpoint · SSO · RBAC · audit"| api
subgraph k8s ["Kubernetes (Helm)"]
api["Studio API + Admin UI"]
api --> sandbox["Agent sandboxes<br/>(sandbox-operator)"]
api <-->|"streams and broadcasts"| nats["NATS"]
api -->|"traces · costs"| otel["OTel Collector"]
nats <-->|"streams and broadcasts"| worker["Workers<br/>DBOS runs"]
otel --> ch[("ClickHouse")]
end
pg[("PostgreSQL")]
api --> pg
worker <-->|"DBOS queues and journal"| pg
subgraph upstream ["Models & tools"]
models["Anthropic · OpenAI<br/>OpenRouter · Ollama"]
mcps["GitHub · Slack · Postgres<br/>your MCP servers"]
end
api -->|"model routing · vaulted credentials"| upstream
Every box is optional except Studio and PostgreSQL — start small, turn on the rest as the rollout grows.
Tech Stack
| Layer | Tech |
|---|---|
| Runtime | Bun / Node |
| Language | TypeScript + Zod |
| Framework | Hono (API) + Vite + React 19 |
| Database | Kysely → PostgreSQL |
| Auth | Better Auth (OAuth 2.1 + API keys) |
| Observability | OpenTelemetry |
| UI | React 19 + Tailwind v4 + shadcn |
| Protocol | Model Context Protocol (MCP) |
Roadmap
- Agent marketplace — discover, hire, and compose agents
- Declarative planning engine
- Cost analytics and spend caps
- Remote access from any browser
- Live tracing debugger
- Workflow orchestration with guardrails
License
MIT — see LICENSE.md.
Questions? builders@decocms.com
Contributing
bun run fmt # Format
bun run lint # Lint
bun test # Test
See AGENTS.md for coding guidelines, CONTRIBUTING.md for the contribution workflow, and TESTING.md for the testing rules.
Good first steps: open an issue, pick one labeled good first issue, or ask in Discord.
Contributors
Studio is built in the open. Thanks to everyone who has shipped a commit.
Maintainers — see MAINTAINERS.txt:
@guitavano · @viktormarinho · @mcandeia · @pedrofrxncx · @JonasJesus42 · @aka-sacci-ccr · @vibegui · @tlgimenes · @vibe-dex · @nicacioliveira
deco Studio MCPのよくある質問
deco Studio MCPをClaude Codeに追加するには
ターミナルでclaude mcp add studio -- npx -y deco-cliを実行します。すべてのプロジェクトで利用するには--scope userを追加します。
deco Studio MCPをCursorに追加するには
~/.cursor/mcp.jsonを開き、上記のインストールセクションに示すCursor設定を使ってmcpServersの下にサーバーを追加します。
deco Studioをローカルで実行するにはどうすればよいですか?
リポジトリをクローンしてDocker Composeで起動し、localhost:4000を開いてください。ComposeによってPostgreSQL、NATS、オブジェクトストレージ、マイグレーション、API、およびWebアプリが立ち上がります。
Studioは接続されたツールの認証情報をどのように保存しますか?
MCP serverのトークンは組織レベルの暗号化されたVaultに保持され、組織、ロール、またはエージェントごとにアクセス権が付与されます。
異なるAIモデルプロバイダーを使用できますか?
はい、StudioはOpenRouter、またはAnthropic、OpenAI、Googleなどの直接プロバイダー経由でモデルをルーティングします。これらはエージェントやツールごとに選択可能です。
エージェントの使用状況について何を確認できますか?
すべてのモデルおよびツールの呼び出しは、ユーザー、エージェント、モデル、レイテンシ、エラー、トークン、コストとともに追跡され、エージェント、接続、組織、またはチームメンバーごとに内訳を表示できます。
StudioはSSOとロールベースのアクセス制御をサポートしていますか?
はい、OAuth 2.1を備えたBetter AuthによるSSOとRBAC、およびツールスコープのAPIキーを提供します。また、セルフホスト環境では組織の分離と監査ログも利用可能です。