# Umbraco MCP for AI Agents AI Agent Connect

> Umbraco MCP gives your AI agent direct access to your Umbraco CMS. It handles the heavy lifting of fetching delivery content, managing backoffice documents, and browsing media assets. You can automate content updates and pull structured data without leaving your editor.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_Q8Bf5msx9nS9Avd1WticWndyaU4yMUEsTqaFluBx/ai-agent-connect
- **Tags:** cms, content-delivery, media-management, asp-net, backoffice-automation, structured-content

## Description

Connecting your Umbraco CMS to an AI agent changes how you handle content. Instead of jumping between your CMS dashboard and your code editor, you can just tell your agent to do the work. It handles the specific details of the Delivery and Management APIs, letting you pull public pages, query specific content types, or create new document drafts just by describing what you need. If you're building a headless project, this takes the friction out of syncing content and checking schemas. It's one of the practical ways to use the Vinkius catalog to make your CMS actually work for you rather than against you. You can push updates to specific fields, delete outdated nodes, or grab a list of all your media files without manually clicking through dozens of pages. It turns your CMS into a dynamic data source that your agent can actually interact with in real-time. You no longer have to worry about the exact endpoint paths or the specific JSON structure for every single update. The agent handles the mapping while you focus on the actual content. Whether you're auditing thousands of pages or just trying to find one specific media asset, this connection puts the power of the Umbraco backend directly into your chat interface. It's about moving from manual data entry to intentional content direction.

## Tools

### update_cms_document
Update specific fields of an existing Umbraco document using its ID and a JSON update. It's the best way to make targeted changes to your live content.

### create_cms_document
Create a new document in the Umbraco CMS by providing a JSON object that follows your schema. This makes it easy to push content directly from your AI agent.

### delete_cms_document
Permanently remove a document from your Umbraco CMS. This action cannot be undone, so use it carefully for cleaning up old data.

### list_document_types
See all document types and schemas currently defined in your Umbraco setup. Use this to understand what data structures your agent can interact with.

### list_media_assets
Pull a list of all images and files from your Umbraco Media library. This helps you keep track of your assets without browsing the UI.

### query_delivery_content
Filter and search for specific content items using the Delivery API query syntax. Use this to find specific types of content across your whole site.

### get_delivery_content_by_id
Fetch a specific content item using its GUID or numeric ID from the Delivery API. It's the fastest way to grab a single piece of content.

### get_delivery_content_by_path
Get a specific content item based on its URL path, like `/home/about`. This is perfect for checking what a specific page looks like.

### get_management_document
Pull a specific document from the Umbraco Management API for draft or backoffice access. Use this when you need to see content that isn't public yet.

### list_delivery_content
List all content available through the Delivery API with support for pagination. It's great for getting a high-level overview of your public site.

## Prompt Examples

**Prompt:** 
```
Show me the content for the /about-us page and tell me what fields it has.
```

**Response:** 
```
I've pulled the content for that path. It's a 'Page' document. Here are the fields:

| Field Name | Value |
| :--- | :--- |
| **Title** | About Our Team |
| **BodyText** | We are a dedicated team of developers... |
| **HeroImage** | /media/about-hero.jpg |

Everything is mapped correctly from the Delivery API.
```

**Prompt:** 
```
What are all the different content types we have in our Umbraco CMS?
```

**Response:** 
```
I've retrieved the global Document Types for you. Here are the schemas currently defined:

*   **BlogPost**
*   **ProductPage**
*   **LandingPage**
*   **ServiceDetail**

Let me know if you'd like me to pull the specific fields for any of these.
```

**Prompt:** 
```
Create a new blog post draft with the title 'New Update' and a short description.
```

**Response:** 
```
I've prepared the draft for you. I created a new document in the **BlogPost** schema with the following details:

*   **Title**: New Update
*   **Description**: A brief summary of our latest features.

It's now saved in the Umbraco backoffice as a draft for your review.
```

## Capabilities

### Fetch public content by URL path
Get specific content items instantly by asking for a URL like /home/about.

### Create new CMS documents from JSON
Push new content drafts into Umbraco by providing a JSON object that matches your schema.

### Search for specific content types
Query your content library to find specific types of items like blog posts or products.

### List all available media assets
Get a full list of all images and files stored in your Umbraco Media library.

### Update existing document fields
Modify specific fields of an existing document using its unique ID and a JSON update.

### Delete old content from the CMS
Permanently remove outdated documents from your Umbraco CMS to keep your data clean.

## Use Cases

### Bulk content migration
An editor needs to move 50 pages. They ask the agent to create documents based on a CSV, using `create_cms_document` to push them all at once.

### Rapid prototyping
A dev wants to see the JSON for a 'Product' page. They ask the agent to fetch `/products/1` using `get_delivery_content_by_path` to see the structure.

### Media auditing
A designer wants to see all images. They ask the agent to list all assets using `list_media_assets` to get a count and list of files.

### Schema verification
An engineer wants to see all available content types. They ask the agent to list schemas using `list_document_types` to verify the API surface.

## Benefits

- Stop switching tabs between your CMS and your code. Use `get_delivery_content_by_path` to pull data directly into your workspace.
- Automate repetitive content entry. Use `create_cms_document` to push JSON drafts into Umbraco without manual data entry.
- Quickly audit your content structure. Use `list_document_types` to see every schema your agent can interact with instantly.
- Clean up outdated content faster. Use `delete_cms_document` to remove old nodes without hunting for them in the backoffice UI.
- Verify API payloads on the fly. Use `query_delivery_content` to check exactly what your frontend will receive before you write a line of code.

## How It Works

The bottom line is you get a direct, conversational interface for your Umbraco CMS backend.

1. Subscribe to the Umbraco MCP via the Vinkius platform.
2. Input your Umbraco Base URL and your Management/Delivery Bearer Auth Tokens.
3. Ask your AI agent to perform tasks like listing content types or creating a new draft.

## Frequently Asked Questions

**Can the Umbraco MCP create new pages for me?**
Yes, it can create new CMS documents using JSON data that follows your specific schemas. Just describe the content you want, and the agent handles the rest.

**How do I use the Umbraco MCP to see my media library?**
You can ask your agent to list all media assets, which pulls your images and files from the Umbraco Media library so you don't have to browse the UI.

**Does the Umbraco MCP work for headless setups?**
Yes, it specifically interacts with both the Delivery and Management APIs, making it ideal for headless workflows where you need to pull structured data.

**Can I use the Umbraco MCP to delete old content?**
Yes, it has a tool to permanently remove documents from the CMS, which helps in keeping your site content clean and up to date.

**Does the Umbraco MCP require a specific AI model?**
It works with any MCP-compatible client like Claude or Cursor that you have connected to Vinkius.

**How does the Umbraco MCP handle different content types?**
It can list all your document types so your agent knows exactly what schemas are available to query or create, ensuring the data is always structured correctly.

**Can it easily retrieve the content of a page assuming I only know its URL path?**
Absolutely. Instruct the agent to 'get_delivery_content_by_path' and supply something like '/home/about'. It traverses the Delivery API native routing map and returns perfectly all inner block grids and content variables attached.

**How do I ensure the JSON payloads for `create_cms_document` are exactly what Umbraco expects?**
Use the agent to first run 'list_document_types'. It pulls down the global schema blueprints. The LLM can explicitly read the allowed field types (like rich text or media pickers) and logically construct the insertion matching it exactly.

**Does it pull media details dynamically?**
Yes. Pinging 'list_media_assets' grants full insight over all stored visuals inside your Umbraco media containers, returning URL addresses alongside fundamental dimension formats so the agent can reference them anywhere.