Filament Studio

A dynamic data model manager for Filament v5 — create collections, define fields, manage records, and build dashboards, all at runtime. No migrations required.

Filament Studio turns your Filament admin panel into a flexible data platform. Define custom data structures through a visual interface, and the plugin handles the rest: forms, tables, filters, API endpoints, dashboards, workflow automation, and access control — all powered by an EAV (Entity-Attribute-Value) storage engine.

Screenshots

Why Filament Studio?

• No migrations per collection — Add new data types at runtime without touching your codebase
• Full Filament integration — Native forms, tables, filters, and actions that look and feel like hand-crafted resources
• Production-ready — Multi-tenancy, multilingual content, authorization, versioning, soft deletes, and audit logging out of the box
• Automatable — A visual workflow designer with triggers, versioned publishing, and full run observability, so data changes can kick off real automation
• AI-native — Built-in MCP server lets Claude, Cursor, and other AI tools manage your data model through natural language
• Extensible — Register custom field types, panel types, condition resolvers, and lifecycle hooks

Features

Dynamic Collections

Create and manage data collections with custom fields through the admin UI. Each collection gets a fully functional CRUD interface with forms, tables, and filters — generated dynamically from the field definitions.

33 built-in field types across 9 categories:

Dashboard Builder

Build data dashboards with 9 panel types: Metric, List, Time Series, Bar Chart, Line Chart, Pie Chart, Meter, Label, and Variable. Place panels on dashboards (12-column grid), collection pages, or record pages.

Panels support dynamic variables ($CURRENT_USER, $NOW, {{custom}}), aggregate functions (count, sum, avg, min, max), and interactive controls.

Advanced Filtering

A visual filter builder with 23 operators, nested AND/OR logic, dynamic variables, and saved filter presets. Operators adapt to data type — text fields get "contains" and "starts with", dates get "before" and "after", JSON fields get "contains any/all/none".

REST API

Auto-generated RESTful API with API key authentication, per-collection permissions, rate limiting, and OpenAPI documentation via Scramble.

MCP Server

A built-in Model Context Protocol server lets AI assistants (Claude, Cursor, Windsurf) manage your data model through natural language. Connect via stdio or HTTP and gain access to 34 tools covering every aspect of Filament Studio:

• Schema design — create and update collections, fields, and field options
• Data access — query, create, update, and delete records with full filter-tree support
• Dashboards — build and configure dashboards and panels
• Administration — manage saved filters and API keys

{
  "mcpServers": {
    "filament-studio": {
      "type": "stdio",
      "command": "php",
      "args": ["artisan", "mcp:start", "studio"],
      "env": { "STUDIO_API_KEY": "your-key", "STUDIO_MCP_ENABLED": "true" }
    }
  }
}

Flows (Automation Engine)

A self-contained workflow automation system: triggers start a run, a directed graph of operations executes in order, and every run is recorded for observability. Flows are opt-in (flows.enabled) and designed visually on a React-based canvas.

• Triggers — Manual, Webhook (HMAC-signed, rate-limited, IP-allowlisted), Collection Event, and Schedule (cron)
• Operations — Records CRUD, Condition, Transform Payload, Send Email, HTTP Request, Trigger Flow (composition, depth-limited)
• Draft → Publish versioning — edit a live draft, test it inline (with dry-run and step-through debugging), then publish an immutable, restorable version
• Observability — every run captures a step-by-step tree of inputs, outputs, timing, and status, with dashboard widgets for recent runs, failure rate, and duration
• Security — dangerous operations and public webhooks require explicit publish-time confirmation; sensitive config values are masked before logs are persisted
• Extensible — register custom operations and triggers via the plugin API

See Flows documentation for the full guide.

Conditional Logic

Fields can be conditionally visible, required, or disabled based on form values, user permissions, page context, or custom resolvers — with cycle detection for safety.

Multilingual Content

Opt-in per-locale support for translatable fields. Enable multilingual globally, then configure each collection with its own supported locales and default locale. Mark individual fields as translatable — non-translatable fields (booleans, dates, numbers) store a single value regardless of locale.

• Locale resolution — ?locale= query param > X-Locale header > session > collection default > global default
• Automatic fallback — When a translation is missing, falls back to the default locale with metadata indicating which fields fell back
• Admin locale switcher — Toggle between locales in the record editor; version history includes a per-locale viewer
• API support — All REST endpoints accept locale selection; ?all_locales=true returns all translations as nested objects
• OpenAPI documentation — Locale parameters and _meta response schemas appear automatically in API docs when multilingual is enabled

// config/filament-studio.php
'locales' => [
    'enabled' => true,
    'available' => ['en', 'fr', 'de'],
    'default' => 'en',
],

Multi-Tenancy

Full tenant isolation across all models. Every collection, record, dashboard, and API key is scoped to its tenant.

Record Versioning & Soft Deletes

Optional snapshot-based version history with restore capability, including per-locale snapshots for translatable fields. Optional soft deletes to recover deleted records.

Authorization & Spatie Permissions

Policy-based access control with granular per-collection permissions. When spatie/laravel-permission is installed, Filament Studio automatically syncs permissions for each collection:

• Per-collection CRUD permissions — studio.collection.{slug}.viewRecords, createRecord, updateRecord, deleteRecord
• Global permissions — studio.manageFields, studio.manageApiKeys
• Auto-sync — Permissions are created/removed automatically when collections are created, renamed, or deleted
• Navigation & action enforcement — UI elements (navigation items, create/edit/delete buttons) are hidden when the user lacks the corresponding permission
• Graceful fallback — If Spatie Permission is not installed, all actions are allowed by default

Quick Start

Install

composer require flexpik/filament-studio

Publish & Migrate

php artisan vendor:publish --tag="filament-studio-migrations"
php artisan migrate

Register the Plugin

use Flexpik\FilamentStudio\FilamentStudioPlugin;

public function panel(Panel $panel): Panel
{
    return $panel
        ->plugins([
            FilamentStudioPlugin::make(),
        ]);
}

Visit your admin panel — you'll find a new Studio section in the sidebar.

Configure (Optional)

FilamentStudioPlugin::make()
    ->navigationGroup('Content')
    ->enableVersioning()
    ->enableSoftDeletes()
    ->enableApi()
    ->fieldTypes([
        'currency' => CurrencyFieldType::class,
    ])
    ->panelTypes([
        CustomMapPanel::class,
    ]);

Publish the config for environment-level settings:

php artisan vendor:publish --tag="filament-studio-config"

Extending

Custom Field Types

Create field types by extending AbstractFieldType:

use Flexpik\FilamentStudio\FieldTypes\AbstractFieldType;
use Flexpik\FilamentStudio\Enums\EavCast;

class RatingFieldType extends AbstractFieldType
{
    protected static string $key = 'rating';
    protected static string $label = 'Rating';
    protected static string $icon = 'heroicon-o-star';
    protected static EavCast $eavCast = EavCast::Integer;
    protected static string $category = 'numeric';

    public function settingsSchema(): array { /* ... */ }
    public function toFilamentComponent(): Component { /* ... */ }
    public function toTableColumn(): ?Column { /* ... */ }
    public function toFilter(): ?Filter { /* ... */ }
}

Lifecycle Hooks

React to events and modify generated schemas:

FilamentStudioPlugin::afterCollectionCreated(fn ($collection) => /* ... */);
FilamentStudioPlugin::afterFieldAdded(fn ($field) => /* ... */);

FilamentStudioPlugin::modifyFormSchema(fn (array $schema, $collection) => $schema);
FilamentStudioPlugin::modifyTableColumns(fn (array $columns, $collection) => $columns);
FilamentStudioPlugin::modifyQuery(fn ($query) => $query);

Architecture

Filament Studio uses EAV (Entity-Attribute-Value) storage — data is stored across four core tables instead of creating a table per collection:

This approach enables runtime schema changes without migrations while preserving native database sorting and type safety through typed storage columns.

Documentation

Requirements

• PHP 8.3+
• Laravel 11+
• Filament v5

Testing

vendor/bin/pest

Changelog

See CHANGELOG for recent changes.

Contributing

See CONTRIBUTING for details.

Security

If you discover a security vulnerability, please send an email to the maintainers. All security vulnerabilities will be promptly addressed.

Credits

• Flexpik
• All Contributors

License

The MIT License (MIT). See LICENSE for details.