Magnolia MCP. Audit schemas and manage JCR structure via chat.
Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Magnolia CMS MCP Server connects your AI agent directly to an enterprise-grade headless content repository. It lets you manage complex JCR nodes, audit component schemas, and execute publishing commands via natural conversation.
You query the underlying structure—not just the rendered website.
What your AI agents can do
Mg.copy delivery node
Copies a content node while maintaining the structural matching required for delivery logic.
Mg.create cms node
Creates a new CMS node, generating and writing structured JSON payloads natively.
Mg.execute workspace command
Dispatches an automated validation check that routes explicit platform logic commands.
Retrieve detailed component definitions to see exactly what fields a template expects.
Create, update (mg.patch_cms_node), or delete nodes in the JCR repository structure.
Run complex queries against specific property sets and content paths using native JCR logic.
Trigger operational commands like publishing or activating workspaces across the entire instance.
Fetch pure JSON mappings from configured delivery paths to verify content boundaries.
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
Magnolia (Enterprise Headless CMS) MCP Server: 10 Tools for Ops & Devs
Use these ten tools to control every aspect of your content repository, from auditing component fields to running full platform publishing commands.
019d75cbmg.copy delivery node
Copies a content node while maintaining the structural matching required for delivery logic.
019d75cbmg.create cms node
Creates a new CMS node, generating and writing structured JSON payloads natively.
019d75cbmg.execute workspace command
Dispatches an automated validation check that routes explicit platform logic commands.
019d75cbmg.get delivery children
Extracts properties and lists all child nodes driving the active branch nesting structure.
019d75cbmg.get delivery node
Retrieves pure JSON mappings for a specific delivery endpoint path from the JCR tree securely, identifying bounded routing spaces.
019d75cbmg.get template schema
Enumerates all explicitly attached structured rules and exports the required active fields for a component or page template.
019d75cbmg.list jcr workspaces
Identifies and lists every precise, active JCR workspace spanning your entire context domain.
019d75cbmg.patch cms node
Modifies existing content nodes across global Web CRM boundaries, updating draft document schemas in place.
019d75cbmg.query delivery nodes
Retrieves explicit cloud logging data by tracing specific payload criteria within the repository.
019d75cbmg.wipe cms node
Deletes a CMS node irreversibly, dropping all associated live database bytes and content.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Magnolia (Enterprise Headless CMS), then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Magnolia CMS MCP Server connects your AI agent straight into an enterprise-grade headless content repository. This isn't just reading what hits the live site; you get full, direct control over Magnolia’s entire JCR structure and content management layer through natural conversation. You query the underlying data—the actual schema and nodes—not just the rendered website.
Inspecting the Content Structure
The server lets you audit component schemas using mg.get_template_schema. When you run it, you get a dump of all explicitly attached structured rules, letting you see exactly what fields a template or component expects to run correctly. Need to map out how content is delivered? You can fetch pure JSON mappings for any specific delivery endpoint path by calling mg.get_delivery_node, which identifies those bounded routing spaces within the JCR tree.
If you need to know all the components driving a page—like nested sections or branches—you run mg.get_delivery_children; this extracts properties and lists every single child node that contributes to the active branch nesting structure.
Querying and Discovering Data
You can poke around your repository using native JCR logic. By listing all active JCR workspaces with mg.list_jcr_workspaces, you know precisely which context domain you're operating in. Need to find specific bits of content? You run complex queries against property sets and specific content paths, giving you secure access to the underlying data.
For detailed auditing, you can use mg.query_delivery_nodes to retrieve explicit cloud logging data by tracing specific payload criteria within the repository.
Managing Content Nodes
This is where you make changes. You write new content using mg.create_cms_node, which generates and writes structured JSON payloads natively into a brand-new CMS node. If something already exists, you modify it directly with mg.patch_cms_node. This tool updates existing content nodes across global Web CRM boundaries, letting you patch draft document schemas in place without hassle.
Need to clean up? You can irreversibly delete an entire CMS node using mg.wipe_cms_node, which drops all associated live database bytes and content from the system. Furthermore, if a whole section needs to move—like copying a full article while keeping its structure intact—you use mg.copy_delivery_node; this copies a content node while maintaining the structural matching required for delivery logic.
Executing Operational Commands
The server lets you run platform commands that manage your entire workflow. You dispatch automated validation checks using mg.execute_workspace_command to route explicit system logic commands, which is crucial for publishing or activating content. By combining these tools, you can manage the complete lifecycle of content right from your agent’s conversation, handling everything from schema auditing and node creation to triggering final publication workflows.
How Magnolia MCP Works
- 1 Subscribe to the server and input your Magnolia Host, Port, and Basic Auth credentials.
- 2 Your AI client authenticates against the Vinkius Marketplace endpoint.
- 3 You prompt the agent (e.g., 'What are all active workspaces?'), and it executes the required tool call (
mg.list_jcr_workspaces) to return structured data.
The bottom line is, you treat your complex backend CMS like a simple API that answers questions based on its internal structure.
Who Is Magnolia MCP For?
This server is for the people who live in the gap between content design and production code. It’s for developers tired of writing repetitive REST calls, and architects who need to audit schemas faster than a manual GUI allows.
You use it to test delivery API results or verify JCR node properties via conversation, skipping the boilerplate of writing manual REST clients.
You audit component schemas and manage hierarchical content trees across multiple site environments without logging into the CMS UI.
You monitor workspace health, execute publishing commands, and validate data movement across your entire Magnolia instance in one session.
What Changes When You Connect
- Stop manually writing REST calls for simple audits. Use
mg.get_template_schemato instantly understand what fields a component needs, saving hours of documentation digging. - Never lose track of content locations again. Run
mg.list_jcr_workspacesto get an instant map of every active domain (website, DAM, config) in your instance. - Validate content delivery paths with precision. The
mg.get_delivery_nodetool pulls pure JSON mappings for any endpoint path, showing exactly what data makes it live. - Manage the entire content lifecycle without leaving your agent. Execute commands like publishing or activating workspaces using
mg.execute_workspace_command. - Need to update content? Use
mg.patch_cms_nodeto modify nodes across global boundaries instead of building complex patch scripts for every single field change.
Real-World Use Cases
Auditing Content Dependencies
An architect needs to know if a new component relies on an old, deprecated field. Instead of checking three different documentation pages and running multiple manual queries, they prompt the agent: 'Show me the schema for template X.' The agent runs mg.get_template_schema and immediately provides the required fields, solving the dependency question in seconds.
Publishing a Major Site Update
The digital ops team is ready to push content live across all environments. Instead of manually navigating through multiple CMS dashboards and running separate publish commands, they prompt: 'Activate and publish the website workspace.' The agent runs mg.execute_workspace_command, validating and deploying the entire site in one go.
Verifying a New API Endpoint
A developer builds a new content delivery endpoint (/tours/bali). They don't want to manually test every JSON output. They ask the agent to run mg.get_delivery_node on that path, getting pure JSON mappings and confirming the exact boundaries of the data before writing any client code.
Cleaning Up Legacy Content
A content owner needs to decommission an entire old section ('tours/old'). Instead of manually deleting hundreds of nodes through a GUI, they ask the agent to locate and wipe the whole structure using mg.wipe_cms_node after confirming its path with mg.get_delivery_children.
The Tradeoffs
Assuming simple writes are enough
Trying to patch a node by just knowing the field name, without first checking if that field is required or even exists in the target template.
→
First, use mg.get_template_schema to audit the component's expected fields. Then, run mg.patch_cms_node using only those validated properties. This prevents schema failures.
Missing context on node location
Trying to copy content from a development environment but accidentally overwriting production data because the exact workspace isn't specified.
→
Always use mg.list_jcr_workspaces first. Confirm you are targeting the correct source and destination workspaces before running mg.copy_delivery_node.
Ignoring content lineage
Simply deleting a node without knowing if it's referenced by other active delivery endpoints, causing broken links or data loss.
→
Before wiping anything with mg.wipe_cms_node, use mg.query_delivery_nodes to trace all payload criteria and confirm no live services depend on that content.
When It Fits, When It Doesn't
Use this server if your primary challenge is managing the structure of enterprise content—the JCR nodes, schemas, and delivery pathways—rather than just querying simple data points. You need to know how the system works internally.
Don't use it if you only need to read a single, clean piece of content (e.g., 'What is the current headline?'). In that case, a basic search tool might suffice. Use this when your task requires high-level operations: auditing schemas (mg.get_template_schema), moving data (mg.copy_delivery_node), or running system commands (mg.execute_workspace_command). If you need to know the boundaries of content delivery, mg.get_delivery_node is non-negotiable.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Magnolia CMS. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Content structure management shouldn't feel like navigating a maze of REST endpoints.
Today, updating or auditing a complex piece of content means jumping between the CMS UI, running multiple manual API calls to check schemas, and then writing complex patch scripts just to update one field. It’s slow, error-prone, and you spend more time debugging endpoints than building features.
With this server, your agent handles the complexity. You tell it what needs fixing—'I need a new node for X with fields A, B, and C.' The agent runs `mg.create_cms_node` and structures the data perfectly in one conversational step. It’s that simple.
Magnolia CMS MCP Server: Get full control over content delivery.
Forget the manual steps of listing workspaces, running discovery queries, and then attempting to patch a single node. Those tasks used to require specialized scripts for every environment change.
Now you use `mg.list_jcr_workspaces` to see all environments, confirm the right context, and execute complex actions like migrating data with `mg.copy_delivery_node`. The whole process is managed in a single conversation.
Common Questions About Magnolia MCP
How do I check what fields my component needs using mg.get_template_schema? +
Run mg.get_template_schema and specify the template name you're interested in. The agent will return a detailed list of required properties, showing you exactly what to pass when creating or patching nodes.
Can I run publishing commands using mg.execute_workspace_command? +
Yes. mg.execute_workspace_command allows you to dispatch automated platform logic. You can use it to trigger official publish or activation workflows across your CMS instance.
What is the difference between mg.get_delivery_node and mg.query_delivery_nodes? +
mg.get_delivery_node fetches pure JSON mappings for a specific, defined endpoint path. mg.query_delivery_nodes, on the other hand, performs broader cloud logging traces based on payload criteria.
If I delete content, how do I make sure it's gone completely? Should I use mg.wipe_cms_node? +
Yes, mg.wipe_cms_node is designed for irreversible deletion. It drops the live database bytes and associated app nodes, ensuring complete removal from the repository.
How do I set up authentication before using tools like mg.list_jcr_workspaces? +
You must first provide your Magnolia Host, Port, and Basic Auth credentials (Base64). The agent uses this connection data to securely access the JCR repository. Ensure these details are correct before running any discovery commands.
If I need to move content while preserving its structure, should I use mg.copy_delivery_node? +
Yes, mg.copy_delivery_node is for this. It copies nodes and performs structural matching validation during the process. This guarantees the new node keeps the exact delivery logic of the source.
How can I update content boundaries without losing existing data using mg.patch_cms_node? +
mg.patch_cms_node lets you mutate global Web CRM boundaries. You specifically substitute Draft Document schemas, allowing controlled updates without affecting unrelated live content.
What does mg.get_delivery_children do for detailed navigation? +
mg.get_delivery_children extracts properties driving active Branch nesting. It doesn't just list nodes; it shows you the specific nested elements and their property types, which is crucial for complex content debugging.
Can I navigate the JCR tree structure through my agent? +
Yes. Use the mg.get_delivery_children tool by providing an endpoint and parent path. Your agent will retrieve exclusively the hierarchical descendants, allowing you to understand the branch nesting and property distribution accurately.
How do I audit the required fields for a specific Magnolia component? +
The mg.get_template_schema tool parses the YAML definitions of your components. Your agent will list exactly what fields and scalar parameters the template respects, making it easy to verify your content model without opening the code.
Can my agent trigger a content publication command? +
Absolutely. Use the mg.execute_workspace_command tool and specify 'activate' or 'publish' as the command name. Your agent will dispatch the JSON payload to Magnolia's command system to transition your content across lifecycle states.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
HackEDU (Security Journey)
Automate security training via HackEDU — manage users, track progress, and integrate vulnerability data directly from any AI agent.
Infura (Ethereum Node RPC Provider)
Access Ethereum blockchain data via Infura — query blocks, check balances, estimate gas, and interact with smart contracts directly from any AI agent.
Mistral AI
Build with European open-weight language models that deliver strong reasoning, multilingual capability, and efficient inference.
You might also like
FatSecret
Access millions of food items with calorie tracking, macro data, and serving sizes from the FatSecret platform used by 30M+ users worldwide.
Zapier Webhook Trigger
This MCP does exactly one thing: it sends JSON payloads to Zapier Webhooks. That's its only function. Incredible for connecting AI agents to thousands of visual automation workflows instantly.
Avochato
Manage business messaging, contacts, and broadcasts via Avochato — orchestrate SMS and MMS directly via AI.