nocobase-mcp-server enables AI assistants to programmatically manage a NocoBase instance via MCP tools, covering collections, UI schemas, desktop routes, flowPage blocks, and JS blocks.
Collections
List all collections and retrieve details by name.
UI Schemas (Classic Pages)
List all UI schema nodes; get a full nested tree, direct child properties, or parent schema by UID.
Create root-level nodes, insert new nodes (via insertNewSchema), or insert relative to a target (before/after, first/last child).
Patch a single node or batch-patch multiple nodes; remove a node and its descendants; save a node as a reusable block template.
Desktop Routes / Navigation
List all desktop routes (pages, menus, groups, tabs) for classic and flowPages.
FlowPage Blocks
Get a block by UID or by parent ID + subKey.
Create or update blocks; attach to a container at a specific position; move, duplicate (deep copy, auto-attached), or delete a block and its children.
JavaScript Blocks
Get and update JS block code in classic pages.
Update JS block code in flowPages using the NocoBase sandbox (ctx.render(), supporting React + Ant Design).
Dynamic Tools
Auto-generate additional tools from NocoBase's OpenAPI/Swagger spec when the API documentation plugin is enabled.
Provides integration with Ant Design UI components within NocoBase's JS block sandbox, enabling AI assistants to render JSX interfaces using Ant Design's React components for building rich user interfaces.
Provides integration with React within NocoBase's JS block sandbox, enabling AI assistants to create and render React components for building dynamic user interfaces in flowPage blocks.
Enables dynamic tool generation from NocoBase's OpenAPI/Swagger specifications, automatically loading all API endpoints as tools when the API documentation plugin is enabled.
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., "@nocobase-mcp-server list all collections in my NocoBase instance"
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.
An MCP (Model Context Protocol) server for NocoBase, enabling AI assistants like Claude to interact with your NocoBase instance — read collections, manage UI schemas, build flowPage blocks, and run dynamic API operations via OpenAPI.
24 hand-crafted tools covering collections, UI schemas, desktop routes, flow models, and JS blocks
Dynamic tools auto-generated from your NocoBase's OpenAPI/Swagger spec (requires API documentation plugin)
Works with NocoBase v2.x (tested on 2.0.17-full)
Related MCP server: anyapi-mcp-server
Node.js 18+
A running NocoBase instance
A NocoBase API token (root or sufficient permissions)
npm install -g @reroet/nocobase-mcp-serverThen add to ~/.claude/mcp.json:
{
"mcpServers": {
"nocobase": {
"type": "stdio",
"command": "nocobase-mcp-server",
"env": {
"NOCOBASE_URL": "http://localhost:13000",
"NOCOBASE_API_TOKEN": "your-api-token-here"
}
}
}
}Or use npx without installing globally:
{
"mcpServers": {
"nocobase": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@reroet/nocobase-mcp-server"],
"env": {
"NOCOBASE_URL": "http://localhost:13000",
"NOCOBASE_API_TOKEN": "your-api-token-here"
}
}
}
}git clone https://github.com/puguhsudarma/nocobase-mcp-server.git
cd nocobase-mcp-server
pnpm installThen add to ~/.claude/mcp.json:
{
"mcpServers": {
"nocobase": {
"type": "stdio",
"command": "/absolute/path/to/nocobase-mcp-server/node_modules/.bin/tsx",
"args": ["/absolute/path/to/nocobase-mcp-server/src/index.ts"],
"env": {
"NOCOBASE_URL": "http://localhost:13000",
"NOCOBASE_API_TOKEN": "your-api-token-here"
}
}
}
}Replace /absolute/path/to/nocobase-mcp-server with the actual path (e.g. /Users/yourname/Projects/nocobase-mcp-server).
Variable | Required | Default | Description |
| Yes | — | NocoBase API token |
| No |
| NocoBase instance base URL |
In NocoBase UI: Settings → Plugins → enable the API keys plugin
Go to Settings → API keys → Add API key
Copy the generated token
Enable the API documentation plugin in NocoBase (Settings → Plugins). Once active, the server will automatically load all additional API endpoints as tools on startup.
Tool | Description |
| List all collections |
| Get a collection by name |
Tool | Description |
| List all UI schema nodes |
| Get full nested UI schema tree by UID |
| Get the parent schema of a node |
| Create a new root-level UI schema node |
| Create and insert a new UI schema node |
| Insert a schema node relative to a target node |
| Patch an existing UI schema node |
| Patch multiple UI schema nodes in one request |
| Remove a UI schema node and its descendants ⚠️ |
| Save a UI schema node as a reusable block template |
Tool | Description |
| List all desktop routes (pages, menus, groups, tabs) |
Tool | Description |
| Get a flowPage block by UID |
| Get a flowPage block by parent ID and subKey |
| Create or update a flowPage block |
| Attach a block to a flowPage container |
| Move a block to a different position |
| Deep-copy a block and auto-attach it |
| Delete a block and its children ⚠️ |
Tool | Description |
| Get a JS block schema (classic page) |
| Update JS block code (classic page) |
| Update JS block code inside a flowPage — use |
⚠️ Destructive operations cannot be undone.
flowPage JS blocks run in NocoBase's sandbox. Available APIs:
// Render HTML
ctx.render(`<h1>Hello</h1>`);
// Render JSX with React + Ant Design
const { React, antd } = ctx.libs;
const { useState } = React;
const { Table, Tag } = antd;
function MyComponent() {
const [tab, setTab] = useState("a");
return <div>...</div>;
}
ctx.render(<MyComponent />);How to get UIDs:
Block UID — right-click any block in NocoBase UI → Copy UID (e.g.
add17a3cf3f)Page UID — visible in the browser URL when you open a page (e.g.
http://localhost:13000/page/96acpujiwc6→ UID is96acpujiwc6)
List all collections in my NocoBase, then create a JS block on flowPage "<your-page-uid>"
that shows a summary dashboard with total records from the "users" collection.Get the flowPage with UID "<your-page-uid>", add a new JS block below the existing ones
(the grid block UID is "<your-grid-uid>"), and implement a tabbed table showing data
from the "orders" and "products" collections.Show me all desktop routes, then fetch the UI schema tree of the first page
and explain its block structure.Here's my Figma design: https://www.figma.com/board/XXXXXXXXXXXXXXXX/MyApp?node-id=8273-xxxx
Implement it as a JS block on flowPage "<your-page-uid>" (grid UID: "<your-grid-uid>").
Use React + Ant Design from ctx.libs. Use dummy data for now.Fetch the Figma design at the link above, then create a new JS block on my NocoBase
flowPage and implement the tabs component with the exact columns from the Figma table.
The block UID I want to update is "<your-block-uid>".Contributions are welcome! To add a new tool:
Fork the repo and create a feature branch
Add your tool in src/index.ts using server.registerTool()
Follow the existing pattern — use nocoFetch() for API calls and ok() to format responses
Update the tool list in README.md
Open a pull request
For bug reports or feature requests, open an issue on GitHub.
MIT — see LICENSE for details.
Attach an existing flowPage block/model to a parent. Use this to add an existing block into a flowPage container at a specific position.
Inputs: uid (required), parentId (required), subKey (required), subType, +1 more.
Patch multiple UI schema nodes in a single request. Each object in the patches array must include 'x-uid' plus the fields to update.
Inputs: patches (required).
Create a new root-level UI schema node in NocoBase
Inputs: schema (required).
Delete a flowPage block/model by UID. DESTRUCTIVE — also removes child blocks.
Inputs: uid (required).
Duplicate an existing flowPage block/model (deep copy) and automatically attach it to the same parent. Returns the new block's data.
Inputs: uid (required).
Get a specific collection by name
Inputs: name (required).
Get a flowPage block/model by UID. Use this for blocks inside flowPage type pages (not classic 'page' type). Returns the block's model data including 'use' (component type), 'parentId', 'stepParams', etc.
Inputs: uid (required), includeAsyncNode.
Get a flowPage block/model by its parent ID and subKey. Useful for navigating the flowPage block tree.
Inputs: parentId (required), subKey, includeAsyncNode.
Get a JS block UI schema by UID (for classic 'page' type pages, not flowPage)
Inputs: uid (required).
Get the full nested UI schema tree for a node by UID (uses :getProperties to include all descendants)
Inputs: uid (required).
Get the parent UI schema of a node by UID
Inputs: uid (required).
Insert a schema node at a position relative to a target node. Position values: beforeBegin (prev sibling), afterBegin (first child), beforeEnd (last child), afterEnd (next sibling)
Inputs: uid (required), schema (required), position (required).
Create and insert a new UI schema node via NocoBase's insertNewSchema action
Inputs: schema (required).
List all collections in NocoBase
Inputs: no named parameters.
List all desktop routes (pages and menus) in NocoBase v2. Each route has a type: 'page', 'flowPage', 'group', 'tabs'. Use schemaUid to fetch page content. Works for both classic pages and flowPages.
Inputs: pageSize.
List all UI schemas in NocoBase (returns raw schema nodes, not page-level navigation)
Inputs: no named parameters.
Move a flowPage block/model to a different position relative to another block.
Inputs: sourceId (required), targetId (required), position.
Remove a UI schema node and all its descendants by UID. DESTRUCTIVE — cannot be undone.
Inputs: uid (required).
Save an existing UI schema node as a reusable block template
Inputs: uid (required), values (required).
Create or update a flowPage block/model. If 'uid' is provided in values, it updates; otherwise creates a new one. The 'use' field specifies the component type (e.g. 'JSBlockModel', 'TableBlockModel'). NOTE: after creating, call attach_flow_model to make it appear on the page.
Inputs: values (required).
Update the JavaScript code of a JSBlockModel inside a flowPage. Code runs in NocoBase sandbox — use ctx.render(htmlString) to render output. Example: ctx.render(<h1>Hello</h1>);
Inputs: uid (required), code (required).
Update the code content of a JS block UI schema by UID (for classic 'page' type pages, not flowPage)
Inputs: uid (required), code (required).
Patch an existing UI schema node by UID (partial update)
Inputs: uid (required), patch (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 23 tools
Tools are generally distinct, with clear differentiation between flowPage blocks, classic pages, JS blocks, and UI schema operations. However, the high number of flow model and schema tools could cause some confusion, though descriptions help.
All tool names follow a consistent verb_noun pattern in snake_case, with no mixing of conventions. Examples include 'attach_flow_model', 'batch_patch_ui_schema', 'get_flow_model_by_parent'.
23 tools is slightly on the high side but appropriate for a full-featured low-code platform like NocoBase. The count reflects the complexity of managing UI schemas, blocks, collections, and routes without being excessive.
The tool set covers most essential operations for UI schema management: create, read, update, delete, move, duplicate, and template. Minor gaps exist (e.g., no direct tool for updating page metadata), but these can be handled via update_ui_schema.
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
