# Magnolia CMS MCP for AI Agents AI Agent Connect

> Magnolia CMS MCP connects your enterprise content repository to your AI agent. It lets you manage JCR nodes, audit template schemas, and handle delivery endpoints using natural language. Instead of manual REST calls or complex dashboard navigation, you can query content, move nodes, and trigger publishing workflows directly through your agent.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_u6bjdVVF5duWxI08JFgNFgIEqXftnazuC33oVsOc/ai-agent-connect
- **Tags:** jcr-repository, content-orchestration, digital-experience, node-management, enterprise-cms, api-driven-content

## Description

This Magnolia CMS MCP connects your enterprise content repository to your AI agent. Managing a large-scale headless CMS usually involves jumping between multiple tabs, digging through nested JCR structures, and constantly double-checking schema definitions to make sure your JSON payloads actually line up. It's a lot of manual overhead that slows down deployment cycles and creates friction for developers and content teams alike. This connector changes that by letting you talk to your Magnolia instance as if it were a teammate. You can ask your agent to find specific content fragments, check if a template has the right fields, or move entire branches of content without ever having to touch the admin UI. It handles the heavy lifting of navigating the repository so you can focus on the actual content strategy instead of technical navigation. Whether you're auditing a workspace or verifying a delivery endpoint, you get immediate answers instead of hunting through logs or complex nested folders. It's one of the best ways to keep your content architecture organized, and finding it in the Vinkius catalog makes it easy to plug into your existing workflow. You'll spend less time on the 'how' of content management and more time on the 'what.' By automating the tedious parts of JCR node orchestration and template auditing, you get a much faster path to production. You can verify your delivery mappings in real time, ensuring that what you see in your content repository is exactly what your users will experience on the front end.

## Tools

### mg.copy_delivery_node
Retrieve the exact structural matching for delivery cloning logic. Use this to replicate content structures without breaking delivery rules.

### mg.create_cms_node
Provision a highly-available JSON payload writing model natively. This creates new content nodes that follow your system's rules.

### mg.wipe_cms_node
Irreversibly vaporize explicit App nodes to drop live database bytes. Use this to clean up your repository and remove old data.

### mg.execute_workspace_command
Dispatch an automated validation check routing explicit platform logic. This helps you run workspace commands like activation or publishing.

### mg.get_delivery_children
Perform structural extraction of properties driving active branch nesting. It helps you see how your content nodes are organized.

### mg.get_delivery_node
Return pure JSON mappings from the JCR tree securely. This identifies bounded routing spaces inside your Magnolia delivery layers.

### mg.get_template_schema
Enumerate explicitly attached structured rules exporting active fields. Use this to see exactly what fields a component expects.

### mg.list_jcr_workspaces
Identify precise active arrays spanning rented context domains. This shows you how your project data is distributed across the site.

### mg.query_delivery_nodes
Retrieve explicit cloud logging tracing explicit payload criteria. Use this to find specific content fragments based on your criteria.

### mg.patch_cms_node
Mutate global Web CRM boundaries by substituting draft document schemas. This lets you update existing content nodes and schemas.

## Prompt Examples

**Prompt:** 
```
Get the node details for path 'tours/bali' from the 'tours_v1' delivery endpoint
```

**Response:** 
```
Retrieving node '/tours/bali'… I've fetched the JSON mapping. It contains properties like **tourName**: 'Exotic Bali', **price**: 1200, and **duration**: '10 days'. Would you like to see the child nodes or the associated template definition?
```

**Prompt:** 
```
List all active JCR workspaces in our Magnolia instance
```

**Response:** 
```
I've identified the following workspaces:

* **website** (Site content)
* **dam** (Assets)
* **configuration** (System settings)
* **imaging** (Image processing)
* **categorization** (Tags)

Which one would you like to explore?
```

**Prompt:** 
```
Show me the schema definition for template 'mgnl-news-article'
```

**Response:** 
```
Retrieving schema for 'mgnl-news-article'… This template expects 4 main fields:

| Field | Type | Requirement |
| :--- | :--- | :--- |
| title | Text | Required |
| body | RichText | Required |
| image | Link to DAM | Optional |
| author | Text | Optional |

I can help you create a new node implementing this structure.
```

## Capabilities

### Create and move JCR nodes
Move content nodes across your repository while keeping structural integrity.

### Query content properties
Find specific data fragments using native JCR logic through natural language.

### Audit template schemas
Verify that your content matches the required fields for any component.

### Check delivery endpoints
Validate your JSON mappings for pages and tours instantly.

### Execute workspace commands
Trigger publishing and activation workflows without leaving your chat.

### List active workspaces
See how your project data is distributed across your site environments.

## Use Cases

### Verifying content mappings
A developer needs to check a specific tour's JSON data. They ask their agent to fetch the node details for 'tours/bali' from the 'tours_v1' delivery endpoint.

### Auditing component schemas
A content architect needs to see what fields a news article template requires. They ask their agent to show the schema for 'mgnl-news-article' to verify field types.

### Mapping content hierarchy
A content manager wants to see how content is nested. They ask their agent to perform a structural extraction of properties for an active branch using mg.get_delivery_children.

### Managing workspace distribution
An ops lead needs to see all active areas. They ask their agent to list all active JCR workspaces to see the distribution of website, DAM, and configuration data.

## Benefits

- Stop manual REST calls: Use mg.get_delivery_node to see JSON mappings instantly without opening a browser or Postman.
- Faster content migration: Use mg.copy_delivery_node to move content across your repository while keeping structural integrity.
- Schema accuracy: Audit your component fields with mg.get_template_schema to ensure your data matches the native requirements.
- Automated workflows: Trigger publishing and activation with mg.execute_workspace_command instead of clicking through multiple dashboard screens.
- Easier workspace visibility: Quickly see your project data distribution using mg.list_jcr_workspaces.

## How It Works

The bottom line is you get a direct natural language interface for your Magnolia CMS repository.

1. Subscribe to the Magnolia CMS MCP via Vinkius.
2. Enter your Magnolia Host, Port, and Base64 Auth credentials.
3. Connect to Claude or Cursor to start managing your repository.

## Frequently Asked Questions

**Can I use the Magnolia CMS MCP to check my content schemas?**
Yes, you can use it to pull the exact field definitions and structured rules for any template. This helps you ensure your content matches what the system expects before you hit publish.

**How does the Magnolia CMS MCP handle content publishing?**
You can trigger automated workspace commands like activation and publishing through your agent. It moves content through its lifecycle without you having to click through the admin UI.

**Can I move content between different folders with Magnolia CMS MCP?**
Yes, you can move or copy content nodes across your repository. This helps you maintain structural matching while moving content to new locations.

**Does Magnolia CMS MCP work for headless content delivery?**
It's designed specifically for headless delivery. You can verify JSON mappings and navigate through configured delivery endpoints like pages or tours.

**Can I see all my active workspaces using Magnolia CMS MCP?**
Yes, you can list all active JCR workspaces like your website, DAM, or configuration domains. This gives you a clear view of how your data is distributed.

**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.