4,500+ servers built on MCP Fusion
Vinkius

Magnolia MCP. Audit schemas and manage JCR structure via chat.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Magnolia (Enterprise Headless CMS) MCP on Cursor AI Code Editor MCP Client Magnolia (Enterprise Headless CMS) MCP on Claude Desktop App MCP Integration Magnolia (Enterprise Headless CMS) MCP on OpenAI Agents SDK MCP Compatible Magnolia (Enterprise Headless CMS) MCP on Visual Studio Code MCP Extension Client Magnolia (Enterprise Headless CMS) MCP on GitHub Copilot AI Agent MCP Integration Magnolia (Enterprise Headless CMS) MCP on Google Gemini AI MCP Integration Magnolia (Enterprise Headless CMS) MCP on Lovable AI Development MCP Client Magnolia (Enterprise Headless CMS) MCP on Mistral AI Agents MCP Compatible Magnolia (Enterprise Headless CMS) MCP on Amazon AWS Bedrock MCP Support

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.

+ 7 more capabilities included
Audit Component Schemas

Retrieve detailed component definitions to see exactly what fields a template expects.

Manage Content Nodes

Create, update (mg.patch_cms_node), or delete nodes in the JCR repository structure.

Query Repository Data

Run complex queries against specific property sets and content paths using native JCR logic.

Execute CMS Workflows

Trigger operational commands like publishing or activating workspaces across the entire instance.

Inspect Delivery Endpoints

Fetch pure JSON mappings from configured delivery paths to verify content boundaries.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

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.

mg.copy019d75cb

mg.copy delivery node

Copies a content node while maintaining the structural matching required for delivery logic.

mg.create019d75cb

mg.create cms node

Creates a new CMS node, generating and writing structured JSON payloads natively.

mg.execute019d75cb

mg.execute workspace command

Dispatches an automated validation check that routes explicit platform logic commands.

mg.get019d75cb

mg.get delivery children

Extracts properties and lists all child nodes driving the active branch nesting structure.

mg.get019d75cb

mg.get delivery node

Retrieves pure JSON mappings for a specific delivery endpoint path from the JCR tree securely, identifying bounded routing spaces.

mg.get019d75cb

mg.get template schema

Enumerates all explicitly attached structured rules and exports the required active fields for a component or page template.

mg.list019d75cb

mg.list jcr workspaces

Identifies and lists every precise, active JCR workspace spanning your entire context domain.

mg.patch019d75cb

mg.patch cms node

Modifies existing content nodes across global Web CRM boundaries, updating draft document schemas in place.

mg.query019d75cb

mg.query delivery nodes

Retrieves explicit cloud logging data by tracing specific payload criteria within the repository.

mg.wipe019d75cb

mg.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
Start building

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. 1 Subscribe to the server and input your Magnolia Host, Port, and Basic Auth credentials.
  2. 2 Your AI client authenticates against the Vinkius Marketplace endpoint.
  3. 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.

Headless Developer

You use it to test delivery API results or verify JCR node properties via conversation, skipping the boilerplate of writing manual REST clients.

Content Architect

You audit component schemas and manage hierarchical content trees across multiple site environments without logging into the CMS UI.

Digital Operations Engineer

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_schema to instantly understand what fields a component needs, saving hours of documentation digging.
  • Never lose track of content locations again. Run mg.list_jcr_workspaces to get an instant map of every active domain (website, DAM, config) in your instance.
  • Validate content delivery paths with precision. The mg.get_delivery_node tool 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_node to modify nodes across global boundaries instead of building complex patch scripts for every single field change.

Real-World Use Cases

01

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.

02

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.

03

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.

04

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

How we secure it →

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

mg.copy_delivery_node mg.create_cms_node mg.execute_workspace_command mg.get_delivery_children mg.get_delivery_node mg.get_template_schema mg.list_jcr_workspaces mg.patch_cms_node mg.query_delivery_nodes mg.wipe_cms_node

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.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 10 tools

We've already built the connector for Magnolia. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 10 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.