Stellify MCP Server
OfficialProvides tools for building Laravel applications, including creating controllers, models, middleware, services, and methods with type hints, and managing file structures and dependencies.
Provides tools for building Vue.js components, including creating files with Vue SFC support, converting HTML to Stellify elements, and managing reactive refs and imports.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Stellify MCP Server Create a UserController with a store method"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Stellify MCP Server
Model Context Protocol (MCP) server for Stellify - the AI-native code generation platform.
What is This?
This MCP server lets AI assistants (like Claude Desktop) interact with your Stellify projects to build Laravel and Vue.js applications incrementally. Instead of generating full code files at once, AI can:
Create file structures (classes, controllers, models, middleware, Vue components)
Add method signatures with type hints
Parse PHP/JavaScript code into structured JSON (statement-by-statement)
Convert HTML to Stellify elements in a single operation
Search existing code in your projects
Install reusable code from the global library
Build applications through natural conversation
Related MCP server: laravel-artisan-mcp
Quick Start — Hosted Server (recommended)
The easiest way to connect is the hosted server at https://api.stellisoft.com/mcp. No install, no Node.js, no API token — your MCP client opens a browser window where you sign in with your Stellify account and approve access (OAuth).
Claude (web or desktop): Stellify is listed in the Claude connectors directory — go to Settings → Connectors, find Stellify, and click Connect. Or choose Add custom connector and paste https://api.stellisoft.com/mcp.
Claude Code:
claude mcp add --transport http stellify https://api.stellisoft.com/mcpCursor (.cursor/mcp.json):
{
"mcpServers": {
"stellify": { "url": "https://api.stellisoft.com/mcp" }
}
}VS Code (.vscode/mcp.json):
{
"servers": {
"stellify": { "type": "http", "url": "https://api.stellisoft.com/mcp" }
}
}Windsurf (~/.codeium/windsurf/mcp_config.json):
{
"mcpServers": {
"stellify": { "serverUrl": "https://api.stellisoft.com/mcp" }
}
}Local Install (npm alternative)
Prefer to run the server locally? The npm package speaks the same protocol against the same platform API, authenticated with an API token instead of OAuth.
Prerequisites
Node.js 18 or higher
A Stellify account - Sign up at stellisoft.com
Claude Desktop (or another MCP-compatible AI client)
Installation
Install globally via npm:
npm install -g @stellisoft/stellify-mcpConfiguration
Get your Stellify API token:
Log into Stellify
Navigate to Settings → API Tokens
Click "Create New Token"
Copy your token
Configure Claude Desktop:
Edit your Claude Desktop configuration file:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/claude/claude_desktop_config.json
Add the Stellify MCP server:
{ "mcpServers": { "stellify": { "command": "stellify-mcp", "env": { "STELLIFY_API_URL": "https://stellisoft.com/api/v1", "STELLIFY_API_TOKEN": "your-token-here" } } } }Restart Claude Desktop
That's it! The Stellify tools should now be available in Claude Desktop.
Usage
Once configured, you can talk to Claude naturally to build applications:
Example Conversations
Create a new controller:
"Create a UserController in my Stellify project"Add methods:
"Add a method called 'store' that takes a Request parameter and returns a JsonResponse"Implement method logic:
"Add this implementation to the store method:
$user = User::create($request->validated());
return response()->json($user, 201);"Build a Vue component:
"Create a Counter component with an increment button"Convert HTML to elements:
"Convert this HTML to Stellify elements:
<div class='container'><h1>Hello</h1><button>Click me</button></div>"Search your codebase:
"Search for all controller files in my project"
"Find methods related to authentication"Available Tools
Project & Directory Tools
get_project
Get the active Stellify project for the authenticated user. Call this first before any other operations.
Parameters: None
Returns:
uuid: Project UUID (needed for most operations)name: Project namedirectories: Array of{uuid, name}for existing directories
get_directory
Get a directory by UUID to see its contents.
Parameters:
uuid(required): The UUID of the directory
create_directory
Create a new directory for organizing files.
Parameters:
name(required): Directory name (e.g., "js", "css", "components")
File Tools
create_file
Create a new file in a Stellify project. This creates an empty file shell - no methods, statements, or template yet.
Parameters:
directory(required): UUID of the directory (get fromget_projectdirectories array)name(required): File name without extension (e.g., "Counter", "UserController")type(required): File type - "class", "model", "controller", "middleware", or "js"extension(optional): File extension. Use "vue" for Vue components.namespace(optional): PHP namespace (e.g., "App\Services\"). Only for PHP files.includes(optional): Array of fully-qualified class names to import (e.g.,["App\\Models\\User", "Illuminate\\Http\\Request"]). Stellify will resolve these to file UUIDs, fetching from Laravel API or vendor directory if needed.
Directory selection: Match the directory to your file's purpose. If the directory doesn't exist, create it first with create_directory.
File Type | Directory | Namespace |
Controllers |
|
|
Models |
|
|
Services |
|
|
Middleware |
|
|
Vue/JS |
| N/A |
Example workflow:
create_file→ creates empty shell, returns file UUIDcreate_statement+add_statement_code→ add variables/importscreate_method+add_method_body→ add functionshtml_to_elements→ create template elements (for Vue)save_file→ finalize with all UUIDs wired together
Auto-dependency creation (when auto_create_dependencies: true):
When you create a file with code like:
<?php
namespace App\Http\Controllers;
use App\Models\User;
use Illuminate\Http\Request;
class UserController extends Controller
{
public function store(Request $request)
{
$user = User::create($request->validated());
return response()->json($user);
}
}Stellify will:
Parse
usestatements to find dependencies (User,Request,Socialite)Check Application DB for framework classes → find cached classes
For core Laravel classes → fetch from api.laravel.com
For vendor packages (Socialite, Spatie, etc.) → read from
vendor/directoryCreate missing App classes → create
Usermodel fileWire up the file's
includesarray with all dependency UUIDs
Supported sources:
Laravel API - Core
Illuminate\*classes fetched from api.laravel.comVendor packages -
Laravel\Socialite\*,Laravel\Cashier\*,Spatie\*,Livewire\*, etc. read directly from yourvendor/directory using PHP-Parser
The response includes a dependencies report showing what was created/resolved and from which source.
get_file
Get a file by UUID with all its metadata, methods, and statements.
Parameters:
uuid(required): UUID of the file
save_file
Save/update a file with its full configuration. This finalizes the file after create_file.
Parameters:
uuid(required): UUID of the filename(required): File name (without extension)type(required): File type ("js", "class", "controller", "model", "middleware")extension(optional): File extension ("vue" for Vue SFCs)template(optional): Array of root element UUIDs for Vue<template>sectiondata(optional): Array of METHOD UUIDs only (functions)statements(optional): Array of STATEMENT UUIDs (imports, variables, refs)includes(optional): Array of file UUIDs to import
Important: data = method UUIDs only, statements = statement UUIDs (code outside methods)
search_files
Search for files in the project by name or type.
Parameters:
name(optional): File name pattern to search fortype(optional): File type filter
Method Tools
create_method
Create a method signature in a file (without implementation).
Parameters:
file(required): UUID of the file to add the method toname(required): Method name (e.g., "increment", "store", "handleClick")visibility(optional): "public", "protected", or "private" (PHP only, default: "public")is_static(optional): Whether the method is static (PHP only, default: false)returnType(optional): Return type (e.g., "int", "string", "void")parameters(optional): Array of{name, type}objects
add_method_body
Parse and add code to a method body. Stellify parses the code into structured JSON statements.
Parameters:
file_uuid(required): UUID of the file containing the methodmethod_uuid(required): UUID of the method to add code tocode(required): Code for the method body (just the statements, no function declaration)
Example:
code: "return $a + $b;"search_methods
Search for methods in the project by name or within a specific file.
Parameters:
name(optional): Method name to search for (supports wildcards)file_uuid(optional): Filter results to a specific file
Statement Tools
create_statement
Create an empty statement in a file. This is step 1 of 2 - you must call add_statement_code next.
Parameters:
file(optional): UUID of the file to add the statement tomethod(optional): UUID of the method to add the statement to (for method body statements)
Use cases:
PHP: Class properties, use statements, constants
JS/Vue: Variable declarations, imports, reactive refs
add_statement_code
Add code to an existing statement. This is step 2 of 2 - call after create_statement.
Parameters:
file_uuid(required): UUID of the file containing the statementstatement_uuid(required): UUID of the statement to add code tocode(required): The code to add
Examples:
code: "use Illuminate\\Http\\Request;"
code: "const count = ref(0);"
code: "import { ref } from 'vue';"get_statement
Get a statement by UUID with its clauses (code tokens).
Parameters:
uuid(required): The UUID of the statement
Route Tools
create_route
Create a new route/page in a Stellify project.
Parameters:
project_id(required): The UUID of the Stellify projectname(required): Route/page name (e.g., "Home", "Counter", "About")path(required): URL path (e.g., "/", "/counter", "/about")method(required): HTTP method ("GET", "POST", "PUT", "DELETE", "PATCH")type(optional): Route type - "web" for pages, "api" for API endpoints (default: "web")data(optional): Additional route data
get_route
Get a route/page by UUID.
Parameters:
uuid(required): The UUID of the route
search_routes
Search for routes/pages in the project by name.
Parameters:
search(optional): Search term to match route namestype(optional): Filter by route type ("web" or "api")per_page(optional): Results per page (default: 10)
Views & Blade Templates
Stellify stores Blade views as elements instead of files. The root element's name field maps to the view name:
Element with
name="notes.index"→view('notes.index', $data)Element with
name="layouts.app"→@extends('layouts.app')Element with
name="components.card"→<x-card>
Use update_element to set the name on a root element after creating it with html_to_elements.
Convention for reusable templates: Attach layouts, components, and partials to a template route (e.g., /template/app-layout, /template/card) to keep them organized and editable.
Element Tools (UI Components)
create_element
Create a new UI element. Provide either page (route UUID) for root elements, or parent (element UUID) for child elements.
Parameters:
type(required): Element type - one of:HTML5:
s-wrapper,s-input,s-form,s-svg,s-shape,s-media,s-iframeComponents:
s-transition,s-freestyle,s-motionBlade:
s-directiveShadcn/ui:
s-chart,s-table,s-combobox,s-accordion,s-calendar,s-contiguous
page(optional): UUID of the page/route (for root elements)parent(optional): UUID of the parent element (for child elements)
Using s-directive for Blade Conditionals:
s-directive elements output Blade directives (like @if, @foreach, @endif). They are sibling elements — they don't wrap children. To conditionally render content:
Create an
s-directiveelement with a statement for the opening directive (e.g.,@if(...))Create the content element(s) as the next sibling(s)
Create another
s-directiveelement with a statement for the closing directive (e.g.,@endif)
Example — conditionally showing an image:
// 1. Create statement for @if
create_statement_with_code({
file: "<file-uuid>",
code: "@if($item->featured_image)"
})
// 2. Create opening directive element and set its statement
create_element({ type: "s-directive", page: "<route-uuid>" })
update_element({ uuid: "<if-directive-uuid>", data: { "statement": "<if-statement-uuid>" } })
// 3. Create the image as the next sibling
html_to_elements({ page: "<route-uuid>", elements: "<img class=\"w-full\" />" })
// Then update with dynamic src:
update_element({ uuid: "<img-uuid>", data: { "srcField": "featured_image" } })
// 4. Create statement for @endif
create_statement_with_code({ file: "<file-uuid>", code: "@endif" })
// 5. Create closing directive element
create_element({ type: "s-directive", page: "<route-uuid>" })
update_element({ uuid: "<endif-directive-uuid>", data: { "statement": "<endif-statement-uuid>" } })The three elements render in order as siblings:
@if($item->featured_image)
<img class="w-full" src="{{ $item->featured_image }}" />
@endifUsing s-directive for Loops:
// 1. Create @foreach directive
create_statement_with_code({ file: "<file-uuid>", code: "@foreach($posts as $item)" })
create_element({ type: "s-directive", page: "<route-uuid>" })
update_element({ uuid: "<foreach-uuid>", data: { "statement": "<foreach-statement-uuid>" } })
// 2. Create loop content (article with dynamic fields)
html_to_elements({ page: "<route-uuid>", elements: "<article><h2></h2><p></p></article>" })
// Update elements to use loop item fields:
update_element({ uuid: "<h2-uuid>", data: { "textField": "title" } }) // → {{ $item->title }}
update_element({ uuid: "<p-uuid>", data: { "textField": "excerpt" } }) // → {{ $item->excerpt }}
// 3. Create @endforeach directive
create_statement_with_code({ file: "<file-uuid>", code: "@endforeach" })
create_element({ type: "s-directive", page: "<route-uuid>" })
update_element({ uuid: "<endforeach-uuid>", data: { "statement": "<endforeach-statement-uuid>" } })Loop Item Attributes:
Inside @foreach loops, use these attributes on elements to reference $item:
textField: "fieldName"→ outputs{{ $item->fieldName }}hrefField: "fieldName"→ outputshref="{{ $item->fieldName }}"srcField: "fieldName"→ outputssrc="{{ $item->fieldName }}"hrefExpression: "{{ route('posts.show', $item->slug) }}"→ for complex expressionssrcExpression,altExpression→ same pattern for other attributes
update_element
Update an existing UI element.
Parameters:
uuid(required): UUID of the element to updatedata(required): Object with HTML attributes and Stellify fields
Standard HTML attributes: placeholder, href, src, type, etc.
Stellify fields:
name: Element name in editortype: Element typelocked: Prevent editing (boolean)tag: HTML tag (div, input, button, etc.)classes: CSS classes array["class1", "class2"]text: Static text contentstatements: Array of statement UUIDs for dynamic Blade content
Loop item fields (for elements inside @foreach loops, references $item):
textField: Field name → outputs{{ $item->fieldName }}hrefField: Field name → outputshref="{{ $item->fieldName }}"srcField: Field name → outputssrc="{{ $item->fieldName }}"
Expression attributes (for complex Blade expressions):
hrefExpression: Full Blade expression for href (e.g.,"{{ route('posts.show', $item->slug) }}")srcExpression: Full Blade expression for srcaltExpression: Full Blade expression for alt
Event handlers (set value to method UUID):
click: @clicksubmit: @submitchange: @changeinput: @inputfocus: @focusblur: @blurkeydown: @keydownkeyup: @keyupmouseenter: @mouseentermouseleave: @mouseleave
get_element
Get a single element by UUID.
Parameters:
uuid(required): UUID of the element
get_element_tree
Get an element with all its descendants as a hierarchical tree structure.
Parameters:
uuid(required): UUID of the root element
delete_element
Delete an element and all its children (CASCADE).
Parameters:
uuid(required): UUID of the element to delete
search_elements
Search for elements in the project.
Parameters:
search(optional): Search query to match element name, type, or contenttype(optional): Filter by element typeinclude_metadata(optional): Include additional metadata (default: false)per_page(optional): Results per page, 1-100 (default: 20)
html_to_elements
Convert HTML to Stellify elements in ONE operation. This is the fastest way to build interfaces!
Parameters:
elements(required): HTML string to convertpage(optional): Route UUID to attach elements to. Omit for Vue components.selection(optional): Parent element UUID to attach to (alternative to page)file(optional): Vue component file UUID. Pass this to auto-wire @click handlers to method UUIDs.test(optional): If true, returns structure without creating elements
⚠️ CRITICAL: Multiple Root Elements
When passing HTML with multiple root-level elements (e.g., <header>, <main>, <footer>), only the FIRST root element gets attached to the route via routeParent. Other elements are created but become orphaned (not attached to the route).
Wrong approach (causes orphaned elements):
html_to_elements(page: routeUUID, elements: "<header>...</header><main>...</main><footer>...</footer>")
// Result: Only <header> is attached to the route. <main> and <footer> are orphaned!Correct approach (make separate calls for each root element):
// Call 1: Header
html_to_elements(page: routeUUID, elements: "<header>...</header>")
// Call 2: Main content
html_to_elements(page: routeUUID, elements: "<main>...</main>")
// Call 3: Footer
html_to_elements(page: routeUUID, elements: "<footer>...</footer>")Features:
Parses HTML structure
Creates all elements with proper nesting
Preserves attributes, classes, text content
Auto-detects Vue bindings (
{{ variable }}) and creates linked statementsReturns element UUIDs for use in
save_filetemplate array
Element type mapping:
button,input,textarea,select→s-inputdiv,span,p,section, etc. →s-wrapperform→s-formimg,video,audio→s-media
Global Library Tools
list_globals
List all global files in the Application database. Globals are reusable, curated code that can be installed into tenant projects.
Parameters: None
get_global
Get a global file with all its methods, statements, and clauses.
Parameters:
uuid(required): UUID of the global file
install_global
Install a global file from the Application database into a tenant project.
Parameters:
file_uuid(required): UUID of the global file to installdirectory_uuid(required): UUID of the directory to install into
search_global_methods
Search for methods across the Application database (global/framework methods).
Parameters:
query(required): Search query to find methods by name
Module Tools
Modules are named collections of related global files that can be installed together.
list_modules
List all available modules.
Parameters: None
get_module
Get a module with all its files.
Parameters:
uuid(required): UUID of the module
create_module
Create a new module to group related global files.
Parameters:
name(required): Unique name for the module (e.g., "laravel-sanctum-auth")description(optional): Description of what the module providesversion(optional): Version string (default: "1.0.0")tags(optional): Tags for categorization (e.g.,["auth", "api", "sanctum"])
add_file_to_module
Add a global file to a module.
Parameters:
module_uuid(required): UUID of the modulefile_uuid(required): UUID of the global file to addorder(optional): Installation order (auto-increments if not specified)
install_module
Install all files from a module into a tenant project.
Parameters:
module_uuid(required): UUID of the module to installdirectory_uuid(required): UUID of the directory to install files into
How Stellify Works
Stellify stores your application code as structured JSON in a database, not text files. This architecture enables:
Surgical precision: AI modifies specific methods without touching other code
Query your codebase like data: Find all methods that use a specific class
Instant refactoring: Rename a method across your entire application instantly
Version control at the statement level: Track changes to individual code statements
AI-native development: Give AI granular access without worrying about breaking existing code
Auto-dependency resolution: Framework classes are automatically fetched from Laravel API docs
When you build with Stellify through this MCP server, code is parsed into structured data and can be assembled back into executable code when you deploy.
Dependency Resolution
When you use auto_create_dependencies, Stellify resolves dependencies in this order:
Tenant Database - Check if the class exists in your project
Application Database - Check the global library of pre-defined classes
Laravel API Docs - For core
Illuminate\*classes, fetch from api.laravel.comVendor Directory - For installed packages, read directly from
vendor/
Supported Package Sources
Source | Namespaces | Method |
Laravel API |
| Fetches from api.laravel.com |
Vendor |
| Reads from vendor/laravel/socialite |
Vendor |
| Reads from vendor/laravel/cashier |
Vendor |
| Reads from vendor/laravel/sanctum |
Vendor |
| Reads from vendor/laravel/passport |
Vendor |
| Reads from vendor/spatie/* packages |
Vendor |
| Reads from vendor/livewire/livewire |
Vendor |
| Reads from vendor/inertiajs/inertia-laravel |
For vendor packages, Stellify uses PHP-Parser to extract the actual method signatures from your installed package version - ensuring accuracy with your specific dependencies.
Code Structure
Directory
└── File
└── Method
├── Parameters (Clauses)
└── Statements
└── Clauses / Language TokensEach piece of code is broken down into:
Directory: Organizational container for files
File: Contains methods and file metadata
Method: Function with parameters and body statements
Statement: A single line/statement of code
Clause: Leaf node (variable, string, number, etc.)
Language Token: System-defined keywords and symbols (reusable)
Workflows
PHP Controller Workflow
get_project→ Find directory UUIDcreate_file→ type='controller', name='UserController'create_method→ name='store', parameters=[{name:'request', type:'Request'}]add_method_body→ code='return response()->json($request->all());'
Vue Component Workflow
get_project→ Find the 'js' directory UUIDcreate_file→ type='js', extension='vue' in js directoryCreate statements for imports and data:
create_statement+add_statement_code:"import { ref } from 'vue';"create_statement+add_statement_code:"const count = ref(0);"
create_method+add_method_body→ Create functionshtml_to_elements→ Convert template HTML to elementsupdate_element→ Wire event handlers (click → method UUID)save_file→ Finalize with:extension: 'vue'template: [rootElementUuid]data: [methodUuid] (METHOD UUIDs only)statements: [importStmtUuid, refStmtUuid] (STATEMENT UUIDs)
Development
Watch mode (auto-rebuild on changes):
npm run watchManual build:
npm run buildTroubleshooting
"STELLIFY_API_TOKEN environment variable is required"
Make sure your .env file exists and contains your API token.
"Connection refused" or API errors
Verify your API token is valid
Check that
STELLIFY_API_URLis correctTest the API directly:
curl -H "Authorization: Bearer YOUR_TOKEN" https://stellisoft.com/api/v1/file/search
Claude Desktop doesn't see the tools
Verify the configuration file path is correct for your OS
Check that the Stellify API token is valid
Restart Claude Desktop completely (Quit, not just close window)
Check Claude Desktop logs for error messages
TypeScript errors during build
rm -rf node_modules package-lock.json
npm install
npm run buildInstallation issues
# Clear npm cache and reinstall
npm cache clean --force
npm uninstall -g @stellisoft/stellify-mcp
npm install -g @stellisoft/stellify-mcpArchitecture
Claude Desktop (AI)
↓ (stdio)
Stellify MCP Server (Node.js)
↓ (HTTPS)
Stellify API (Laravel)
↓
Database (Structured Code)The MCP server is a thin client that:
Exposes tools to Claude
Translates tool calls to API requests
Returns formatted responses
Contributing
We welcome contributions! Please see our contributing guidelines and feel free to submit pull requests.
Support
For issues or questions:
GitHub Issues: Report a bug or request a feature
Email: support@stellisoft.com
Documentation: https://stellisoft.com/docs
Discord: Join our community (coming soon)
About Stellify
Stellify is building the future of AI-native software development. By storing code as structured data instead of text files, we enable a new paradigm where AI and humans collaborate seamlessly to build better software, faster.
Learn more at stellisoft.com
License
MIT License - see LICENSE file for details
Built with love by the Stellify team
Available Tools
50 toolsadd_method_bodyAInspect
Append code to an existing method. Use this when you need to ADD MORE code to a method that already has statements.
For new methods: Use create_method with the body parameter instead - it creates the method with code in one call.
Nested code is handled correctly. The parser tracks brace/bracket/paren depth and only splits on semicolons at the top level. Arrow functions with block bodies, computed properties, and other nested constructs work as single statements.
Pass 'types' to specify TypeScript types for variables declared in the code.
IMPORTANT: This APPENDS to existing method statements. To REPLACE a method's code entirely:
Create a NEW method with create_method (with body parameter)
Update the file's 'data' array to include new method UUID (remove old one)
Update any element click handlers to reference the new method UUID
Delete the old method with delete_method
Inputs: file (required), method (required), code (required), types.
add_statement_codeAInspect
Add code to an existing statement. This is step 2 of 2 - call this AFTER create_statement.
ALTERNATIVE: Use create_statement_with_code for a single-call approach that combines both steps.
The statement must already exist (created via create_statement). This parses and stores the code.
Examples:
PHP: "use Illuminate\Http\Request;" or "private $items = [];"
JS/Vue: "const count = ref(0);" or "import { ref } from 'vue';"
Inputs: file (required), statement (required), code (required).
analyze_attributesAInspect
Analyze PHP 8 attribute usage across a Stellify project. Useful for auditing, finding missing attributes, and searching attribute values.
Three modes:
usage (default): List all attributes used in the project with counts
Optional: file_type to filter (e.g., "model", "controller")
Returns: attribute names, counts, and files using each
missing: Find files of a specific type missing a required attribute
Required: file_type (e.g., "model", "class")
Required: attribute name (e.g., "Fillable", "FailOnUnknownFields")
Returns: files missing vs having the attribute
search: Find files where an attribute contains a specific value
Required: attribute name
Optional: value to search for in attribute args
Optional: file_type to filter
Returns: matching files with their attribute values
Example queries:
"Find every FormRequest missing FailOnUnknownFields": mode=missing, file_type=class, attribute=FailOnUnknownFields
"Find models where 'email' is fillable": mode=search, attribute=Fillable, value=email
"List all attributes used": mode=usage
Inputs: mode, file_type, attribute, value.
analyze_performanceCInspect
Analyze execution performance from logs. Types: full, slow_methods, high_query_methods, high_memory_methods, failure_rates, trend.
Inputs: type, days, limit.
analyze_qualityBInspect
Analyze Laravel code for quality issues. Types: full, relationships, fillables, casts, routes. Returns actionable suggestions.
Inputs: type.
broadcast_element_commandAInspect
Push real-time UI updates via WebSocket. Use for SHOW/DISPLAY/DEMONSTRATE requests.
Actions: update (modify element), create (ephemeral element), batch (multiple updates), delete.
Changes are EPHEMERAL (not saved). For persistent changes, use update_element or html_to_elements.
Inputs: action (required), element, changes, updates.
create_directoryAInspect
Create a new directory for organizing files.
Common directories:
'js' for JavaScript/Vue files
'css' for stylesheets
'components' for reusable components
IMPORTANT: Check existing directories first using get_project and get_directory before creating new ones.
Inputs: name (required).
create_elementBInspect
Create a UI element. Provide page (route UUID) for root elements, or parent (element UUID) for children.
Inputs: type (required), page, parent.
create_fileAInspect
Create an empty file shell in a Stellify project. Returns file UUID.
For PHP: type='class', 'model', 'controller', or 'middleware'. For Vue: type='js', extension='vue'. Auto-creates app.js and template route.
Pass 'includes' array for framework class dependencies (auto-resolved to UUIDs). Use 'models' array in save_file for project models.
IMPORTANT - Check appJs response for Vue components:
If
appJs.action_required === "create_or_select_mount_file": No mount file exists. You MUST ask the user if they want to create a new app.js mount file before proceeding.If
appJs.action_required === "register_component": Mount file exists but component isn't registered. Call save_file on the mount file to add the component UUID to its includes array.
Inputs: directory (required), name (required), type (required), extension, +4 more.
create_methodBInspect
Create a method in a file. Pass 'body' to include implementation. Async auto-detected from await. For significant methods, include context fields.
Inputs: file (required), name (required), visibility, is_static, +10 more.
create_resourcesAInspect
Scaffold Model, Controller, Service, and Migration. Routes are NOT auto-wired - use create_route after.
Inputs: name (required), fields, relationships, controller, +5 more.
create_routeAInspect
Create a route/page. For API routes, you MUST pass BOTH controller AND controller_method UUIDs to wire execution.
IMPORTANT: Both 'controller' (file UUID) and 'controller_method' (method UUID) are required together for API routes to execute code. Without both, the route won't run any code.
Route params like {id} auto-inject into controller method parameters when names match.
Inputs: project_id (required), name (required), path (required), method (required), +5 more.
create_statementAInspect
Create empty statement (step 1 of 2). Call add_statement_code next. Prefer create_statement_with_code for single call.
Inputs: file, method.
create_statement_with_codeAInspect
Create a statement with code in one call. Preferred over two-step create_statement + add_statement_code.
Pass 'types' to specify TypeScript types for variables. The assembler infers the full type from code structure:
ref([])+ type "Todo" → outputsconst todos: Ref<Todo[]>ref(0)+ type "number" → outputsconst count: Ref<number>reactive({})+ type "State" → outputsconst state: State
Inputs: file (required), code (required), method, types.
delete_elementAInspect
Delete an element and all its children (CASCADE). Returns the count of deleted elements.
Inputs: uuid (required).
delete_fileAInspect
Delete a file from the project by UUID. This permanently removes the file and all its methods/statements.
WARNING: This is destructive and cannot be undone. Make sure the file is not referenced elsewhere before deleting.
Inputs: directory (required), uuid (required).
delete_methodAInspect
Delete a method from a file by UUID. This permanently removes the method and all its code. Requires both the file UUID and method UUID.
Inputs: file (required), uuid (required).
delete_routeAInspect
Delete a route/page from the project by UUID. This permanently removes the route.
WARNING: This is destructive and cannot be undone. Any elements attached to this route will be deleted also.
Inputs: uuid (required).
delete_settingAInspect
Delete a setting profile from the tenant's settings table.
WARNING: This permanently removes the entire setting profile and all its values. This cannot be undone.
EXAMPLE: { "name": "vote" }
This removes the "vote" setting profile entirely.
Inputs: name (required).
delete_statementBInspect
Delete a statement from a file by UUID. This permanently removes the statement (import, variable, ref, etc.).
Inputs: file (required), method (required), uuid (required).
get_assembled_codeAInspect
Get the assembled source code for a file. Returns the actual Vue SFC or PHP class as it would be rendered.
Use this after save_file to verify the component was built correctly:
Check that all methods are included
Verify @click handlers are wired to methods
Confirm imports and reactive state are present
Spot any missing pieces before deployment
Inputs: uuid (required).
get_directoryAInspect
Get a directory by UUID to see its contents.
Use this to inspect directories returned by get_project. The project's data array contains directory UUIDs. Returns the directory name and list of files/subdirectories inside it.
Inputs: uuid (required).
get_elementAInspect
Get a single element by UUID. Returns the element data with all its attributes.
Inputs: uuid (required).
get_element_treeBInspect
Get an element with all its descendants (children, grandchildren, etc.) as a hierarchical tree structure.
Inputs: uuid (required).
get_fileAInspect
Get a file by UUID with all its metadata, methods, and statements.
Inputs: uuid (required).
get_methodAInspect
Get a method by UUID. Returns the method data including its parameters and body.
Inputs: uuid (required).
get_patternAInspect
Get a UI pattern checklist (accordion, modal, tabs, dropdown, toast). Returns best practices and common pitfalls.
Inputs: name (required).
get_projectAInspect
Get active project. Returns uuid, name, branches, and directories array.
Inputs: no named parameters.
get_routeAInspect
Get a route/page by UUID. Returns route details including name, path, and attached elements.
Use this to look up a route you created or to find existing routes in the project.
Inputs: uuid (required).
get_settingAInspect
Get a setting profile by name. Returns key-value pairs accessible via config() in code.
Inputs: name (required).
get_statementAInspect
Get a statement by UUID. Returns the statement data including its clauses (code tokens).
Inputs: uuid (required).
get_stellify_framework_apiAInspect
Get Stellify Framework API reference with full type signatures. Import from "stellify-framework".
Returns composables (useForm, useAuth, etc.) with options/returns, utilities (Http, Collection, etc.) with methods/staticMethods, and validation rules.
Each item includes summary, type signatures, and JSDoc descriptions. Collection is iterable with v-for.
Inputs: module.
html_to_elementsAInspect
Convert HTML to Stellify elements.
IMPORTANT - Choose the right approach:
For SSR/Blade Pages (WordPress imports, static content, layouts):
MUST pass 'page' (route UUID) - elements attach to the route for server-side rendering
This is the most common use case
For Vue Components (client-side interactivity):
Omit 'page' - elements are standalone, referenced by file's template array
Returns UUIDs to use in save_file's template array
Where elements go:
Pass 'page' (route UUID): Elements attached to the route for SSR rendering
Pass 'selection' (element UUID): Elements attached as children of existing element
Omit both: Elements are standalone (Vue components only) - use returned UUIDs in save_file's template array
⚠️ CRITICAL: Multiple Root Elements Limitation When HTML contains multiple root-level elements (e.g., , , ), only the FIRST root element gets attached to the route. Other elements become orphaned!
WRONG: html_to_elements(page: routeUUID, elements: "<header>...</header><main>...</main><footer>...</footer>")
→ Only attaches to route. and are orphaned!
CORRECT: Make separate calls for each root element:
html_to_elements(page: routeUUID, elements: "<header>...</header>")html_to_elements(page: routeUUID, elements: "<main>...</main>")html_to_elements(page: routeUUID, elements: "<footer>...</footer>")
OR wrap all elements in a single container div.
@click auto-wiring: Pass 'file' UUID to auto-resolve @click="methodName" handlers. Methods must exist in the file first.
Blade Syntax Handling: For SSR/Blade pages, do NOT pass raw Blade expressions in text or attributes. The HTML parser stores them literally which causes rendering issues. Instead:
For static HTML: Pass clean HTML without Blade syntax, then use
update_elementto add dynamic behaviorFor loop content: After creating elements, use
update_elementwith:textField,hrefField,srcFieldfor simple field access (outputs{{ $item->field }})hrefExpression,srcExpression,altExpressionfor paths with prefixes or complex expressionsstatementsarray with statement UUIDs for text content with Blade code
For conditionals: Use
s-directiveelements as siblings (see update_element docs)
IMPORTANT - Links with path prefixes:
hrefField outputs ONLY the field value with no prefix. There is NO hrefPrefix attribute.
For links like /post/my-slug, use hrefExpression: "/post/{{ $item->slug }}" instead.
Loop variable: Inside @foreach loops created with s-directive, the default loop variable is $item. Use textField: "title" to output {{ $item->title }}.
Prefer SVG icons over emoji (encoding issues).
Inputs: elements (required), page, selection, file, +1 more.
install_packageAInspect
Install a foundation package into the current project. Creates routes and other resources defined in the package manifest.
Returns success with installed counts, or error with code:
PACKAGE_NOT_FOUND: Package name doesn't exist
PACKAGE_NOT_INSTALLABLE: Package is disabled
ALREADY_INSTALLED: Package routes already exist in project
UNKNOWN_MANIFEST_KEY: Package requires newer platform version
INSTALL_FAILED: Transaction failed
Inputs: name (required).
list_patternsAInspect
List all available UI pattern checklists.
Returns an array of pattern names and descriptions. Use this to discover what patterns are available before building UI components.
Inputs: no named parameters.
request_capabilityAInspect
Log a missing framework-level capability. Creates a ticket in the Stellify backlog.
Inputs: capability (required), description (required), use_case (required), workaround, +1 more.
run_codeAInspect
Execute a method in sandboxed environment. Requires file and method UUIDs. Returns output, success, error, and optional benchmark data.
Inputs: file (required), method (required), args, timeout, +1 more.
save_directoryAInspect
Update an existing directory. Use this to rename or modify directory properties.
Inputs: uuid (required), name.
save_fileAInspect
Finalize a file. Full replacement - call get_file first to update existing files.
Required: uuid, name, type. For significant changes, include context fields: summary, rationale, references, decisions.
Inputs: uuid (required), name (required), type (required), extension, +11 more.
save_methodAInspect
Update a method's properties. Use add_method_body to append code.
For significant changes, include context fields: summary, rationale, references, decisions.
Inputs: uuid (required), name, visibility, is_static, +10 more.
save_patternBInspect
Save or update a UI pattern checklist.
Use this to add new patterns or update existing ones based on lessons learned.
EXAMPLE: { "name": "accordion", "description": "Collapsible content panels", "checklist": [ "Use v-show for visibility toggle", "Store open state as boolean" ], "example": "const panels = ref([...]);" }
Inputs: name (required), description (required), checklist (required), example.
save_routeAInspect
Update a route/page. Wire to controller with both controller and controller_method UUIDs. For significant routes, include context fields.
Inputs: uuid (required), controller, controller_method, path, +9 more.
save_settingAInspect
Create or update a setting profile. Data is merged with existing values. Access via config('name.key') in code.
Inputs: name (required), data (required).
save_statementBInspect
Update an existing statement. Use this to modify statement properties after creation.
Inputs: uuid (required), data.
search_attributesAInspect
Search for available PHP 8 attributes in Laravel. Returns attribute suggestions with descriptions, namespaces, targets (class/method/property/parameter), and expected arguments.
Use this before adding attributes to files or methods to find the correct attribute name and syntax.
Three modes of operation:
List categories (no params): Returns all available attribute categories
Call with no arguments to discover categories like "eloquent", "queue", "routing"
List category attributes (category only): Returns all attributes in a category
Example: category="eloquent" → returns Fillable, Hidden, ObservedBy, etc.
Search by query (query provided): Searches attribute names
Example: query="fill" → finds Fillable attribute
Can combine with category to search within a specific category
Inputs: query, category, target.
search_elementsAInspect
Search for elements in the project. Useful for finding elements by name, type, or content.
Note: To reorder elements, use update_element to modify the parent element's 'data' array with the new order of child UUIDs.
Inputs: search, type, include_metadata, per_page.
search_filesBInspect
Search for files in the project by name or type
Inputs: query, type.
search_methodsAInspect
Search for methods in the project by name or within a specific file
Inputs: name, file_uuid.
search_routesAInspect
Search for routes/pages in the project by name. Use this to find existing routes before creating new ones.
Returns paginated results with route details including UUID, name, path, and type. Use the returned UUID with html_to_elements (page parameter) or get_route for full details.
Inputs: search, type, per_page.
update_elementAInspect
Update a UI element. Data object: tag, classes, text, event handlers (method UUIDs), classBindings. Set 'name' on root elements to create Blade views (e.g., name="notes.index" for view('notes.index')).
For elements inside @foreach loops (SSR/Blade):
Use these attributes to reference the loop variable (defaults to $item):
textField: Field name for text content → outputs{{ $item->fieldName }}hrefField: Field name for href → outputshref="{{ $item->fieldName }}"(field value ONLY, no prefix)srcField: Field name for src → outputssrc="{{ $item->fieldName }}"
For hrefs with path prefixes (IMPORTANT):
hrefField outputs ONLY the field value. There is NO hrefPrefix attribute.
For links like /post/slug-here, you MUST use hrefExpression:
hrefExpression: "/post/{{ $item->slug }}"→ outputshref="/post/{{ $item->slug }}"hrefExpression: "/category/{{ $item->slug }}"→ outputshref="/category/{{ $item->slug }}"
For complex Blade expressions in attributes: Use expression attributes when you need more than simple field access:
hrefExpression: Blade expression for href → outputshref="..."with the expressionsrcExpression: Blade expression for src → outputssrc="..."with the expressionaltExpression: Blade expression for alt → outputsalt="..."with the expression
Examples:
Path prefix:
hrefExpression: "/post/{{ $item->slug }}"Route helper:
hrefExpression: "{{ route('posts.show', $item->slug) }}"
For Blade text content:
Use the statements array with statement UUIDs containing Blade code. The statement's code property will be output directly for Blade to evaluate.
Inputs: uuid (required), data (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 50 tools
Many tools have overlapping purposes (e.g., multiple ways to create methods/statements), and the sheer number of similar names can cause confusion. However, detailed descriptions help differentiate them.
Most tools follow a verb_noun pattern (e.g., create_element, delete_file), but there are inconsistent outliers like 'html_to_elements' and varying verb forms (add vs create).
With 50 tools, the set is very large. While the comprehensive scope justifies the count, it borders on overwhelming and may exceed typical MCP server expectations.
The tool set covers a wide range of development needs: file management, UI elements, routes, methods, analysis, performance, attributes, packages, and patterns. Only minor gaps like deployment or testing are missing.
Maintenance
Related MCP Connectors
AI colleagues that keep your standards, your project and their reasoning between sessions
Build, version, review, and export websites, web apps, and games from a conversation.
Let your AI agent build, preview and update web apps, download source and publish when you allow it.
Deploy and manage your apps, databases, storage, and scheduled jobs from your AI agent
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceA Laravel-based AI-powered chat interface for business management operations, enabling users to execute tasks like creating customers and updating task statuses through natural language conversations.-
- AlicenseNot gradedqualityDmaintenanceEnables secure execution of Laravel Artisan commands through AI assistants, allowing controlled management of Laravel projects via natural language.6MIT
- AlicenseCqualityDmaintenanceFull-stack AI agent for Livewire v4.2+ / Laravel 13 / PHP 8.4+ with planning, memory, bug fixing, version control, GitHub integration, and design conversion.75MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI assistants to research topics, analyze codebases, generate requirements and user stories, scaffold starter projects, and run multi-step development workflows through natural language.42 npmMIT