Build on Aipokit
A REST API and a Workspace MCP surface over one governed core — the same operations behind editors and Ask (the in-product AI assistant). Point a REST integration or an external agent at a workspace and it can author files, run processes, manage media, and publish — under the same risk classes and approvals. WebDAV authoring mounts workspace folders for local tools; reindex so graph and search stay current. Self-hosted multi-user software, per-account isolation, no private path around controls for agents.
Surfaces for integration
One action equals one service function — exposed identically to the UI, the REST API, and agents over MCP.
Architecture
A lean file-and-media kernel, a memory graph, an agent runtime, and a process engine.
Quickstart
Obtain a workspace, author or import files, and connect an agent — three steps.
API and MCP
REST is the stable contract; Workspace MCP is a thin agent adapter over the same operations as Ask (in-product AI).
Agent integration
Bring your own agent — Claude, Hermes, OpenClaw, or a custom loop — over MCP. Same policy as Ask (in-product AI).
Self-hosting
Docker image, one private authoring node plus N public delivery nodes, database per account.
Parity model
Documented outcomes and no private path around controls — every surface calls the same shared service.
A lean core, clear surfaces.
At the centre is a file-and-media kernel with a memory graph, an agent runtime, and a process engine. Editors are SPA authoring surfaces layered over the same service contracts — a clear shell over a governed core. End-user output is published as static, SEO-safe pages that never depend on an authoring bundle to render.
Architecture
The Stack
| Layer | Technology |
|---|---|
| Language | Rust (stable) |
| Web Framework | Axum 0.8 |
| Templates | Askama 0.13 (SSR, type-safe) |
| Database | SQLite via sqlx (compile-time checked) |
| Sessions | tower-sessions 0.14 + SQLite store |
| Auth | OIDC (Casdoor recommended) |
| CSS | TailwindCSS v4 + DaisyUI |
| Video | FFmpeg (HLS) + MediaMTX (RTMP) |
| Observability | OpenTelemetry 0.31 + OTLP/gRPC |
Workspace Crate Architecture
Aipokit is a Cargo workspace with 34 crates organized by domain:
crates/
common/ # Shared types, storage, database
media-core/ # Media detection, EXIF extraction
media-manager/ # Upload, serve, search, CRUD
video-manager/ # HLS transcoding (8-stage pipeline)
access-control/ # 4-layer permission model
access-codes/ # Shareable access links
access-groups/ # Team roles and invitations
user-auth/ # OIDC + session management
workspace-manager/ # Workspace browser and folder types
vault-manager/ # Storage vault isolation
site-generator/ # Astro site generation
course/ # Course viewer + presentations
...and 22 moreThe Dual-Use Pattern
Every app crate implements the FolderTypeRenderer trait for embedded mode (inside workspace browser) and exports a Router for standalone mode (own URL). Same logic, same templates, two deployment modes.
Storage Layout
storage/
workspaces/{workspace_id}/ # File browser content
folder-a/ # Regular folder
media-gallery/ # Typed folder (media-server)
vaults/{vault_id}/ # Media pipeline storage
media/
images/{slug}.webp
videos/{slug}/index.m3u8
documents/{filename}
thumbnails/
images/{slug}_thumb.webp
videos/{slug}_thumb.webpRate Limiting
Three tiers based on resource intensity:
| Tier | Limit | Endpoints |
|---|---|---|
| Default | 60 RPM | Most API endpoints |
| Upload | 15 RPM | File upload, transcoding |
| Serving | 300 RPM | Media delivery, thumbnails |
REST is the contract surface
The REST API is the stable, versioned way to drive the platform from any language or integration. The Workspace MCP server is a thin agent adapter that maps directly onto the same operations — no parallel implementation, no drift. Whatever an editor can do, the API can do; whatever the API can do, an agent can do over MCP.
Bring your own agent
External agents — Claude Desktop, a custom loop, or anything that speaks MCP — connect to a workspace and operate it directly: read and write files, run and supervise processes, manage media, and publish output. The agent works against the same governed operations people use, scoped to an account and its files, with the memory graph as context.
Three steps to your first workspace.
Runs on your infrastructure
Ship it as a single Docker image. Run one private authoring node plus any number of public delivery nodes, federated over a single code path and kept in sync. Every account is a database-per-account isolation boundary — data residency and sovereignty are the default, not an add-on.
Begin with the architecture.
Review the architecture, connect an agent over MCP, and run a workspace on infrastructure you control.