# DatoCMS MCP for AI Agents AI Agent Connect

> DatoCMS MCP lets you manage your headless content and digital experience platform directly through your AI client. You can query the GraphQL tree, create or update records, audit your media library, and inspect content models without leaving your workspace. It handles the heavy lifting of JSON:API specifications and item type validation so you don't have to.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_kqbiRIDEEpzmpnqcg7HU2AYruJAL07EBAujlMqZU/ai-agent-connect
- **Tags:** graphql, digital-experience, content-modeling, api-first, media-optimization, web-development

## Description

DatoCMS helps you manage your headless content and digital experience platform through natural conversation. Managing a headless CMS usually means jumping between a content editor and a developer's terminal. You're constantly switching tabs to check if a record updated correctly or to see if a media asset actually made it into the right folder. This Connector changes that by putting your entire content management workflow inside your AI client. Instead of manually hunting for IDs or writing complex queries every time you need a specific data point, you just tell your agent what you need. It handles the heavy lifting of navigating the data tree and enforcing the right rules for your content models. You can move from auditing your media library to patching a production record in a few seconds. It's a way to keep your content moving faster while making sure everything stays consistent with your schema. By connecting this to the Vinkius catalog, you get a unified way to manage your digital experience platform alongside all your other essential tools. It turns your content management from a series of manual clicks into a conversation.

## Tools

### create_cms_record
Create new content items using a JSON payload. This ensures your new records meet all required schema rules.

### wipe_cms_record
Permanently delete specific document rows. Use this to clear out old data or hit specific database limits.

### wipe_media_upload
Remove specific media files from your storage. This helps you keep your media library clean and organized.

### get_single_record
Pull the exact details for one specific content node. It's the fastest way to check a single entry's properties.

### get_media_upload
Retrieve the structural data for a specific file block. This is useful for verifying image and file metadata.

### execute_graphql_cda
Run GraphQL queries against your content delivery area. It helps you see exactly how your data will appear on the site.

### list_global_models
See all the content models and item types in your project. This gives you a bird's-eye view of your entire content structure.

### list_cma_records
Fetch a list of records from your content management area. You can use this to audit your logs or check specific JSON:API arrays.

### list_media_uploads
Browse through your uploaded assets and storage mappings. It helps you track what's actually in your media library.

### patch_cms_record
Update specific fields on an existing content record. This lets you make surgical changes without overwriting the whole entry.

## Prompt Examples

**Prompt:** 
```
Show me all the content models we have in DatoCMS.
```

**Response:** 
```
I've pulled the list of content models for you. Here they are:

| Model Name | ID |
| :--- | :--- |
| Blog Post | 123 |
| Product | 456 |
| Author | 789 |
| Page | 000 |

Which one do you want to look at closer?
```

**Prompt:** 
```
Update the status of the 'Summer Sale' post to 'Published'.
```

**Response:** 
```
I've updated that for you. The **Summer Sale** post is now marked as **Published**. You can see the change in your content management area.
```

**Prompt:** 
```
List the last 5 images we uploaded.
```

**Response:** 
```
Here are the 5 most recent media uploads:

* **hero-banner.jpg** (ID: 999)
* **logo-white.png** (ID: 998)
* **team-photo.webp** (ID: 997)
* **icon-v1.png** (ID: 996)
* **bg-texture.jpg** (ID: 995)

All assets are ready for use in your content blocks.
```

## Capabilities

### Query the data tree
Find specific content blocks and delivery arrays using your agent.

### Create content records
Provision new content items that follow your specific schema rules.

### Patch existing records
Update specific attributes on live records without rewriting the whole entry.

### Delete document nodes
Remove specific records to clear out old data or manage database limits.

### Audit media assets
Inspect internal arrays and storage identifiers for your uploaded files.

### List content models
View all registered item types and content structures in your project.

## Use Cases

### Bulk updating blog categories
A content editor needs to update 10 blog posts with a new category. They ask the agent to patch_cms_record on each one.

### Checking content schema
A developer wants to see the schema for a new Product page. They use list_global_models to see the fields.

### Finding specific image IDs
A product manager needs to find a specific image ID. They use list_media_uploads to scan the library.

### Testing live queries
A dev needs to test a query before going live. They use execute_graphql_cda to see the returned data.

## Benefits

- Stop manual tab switching by using execute_graphql_cda to pull data directly into your workspace.
- Maintain data integrity by letting the Connector handle JSON:API specs when you use create_cms_record.
- Speed up content updates by using patch_cms_record to change specific fields instead of re-entering everything.
- Keep your storage clean by using wipe_media_upload to remove assets you no longer need.
- Audit your entire content structure instantly with list_global_models to see every registered item type.
- Verify media proxy mappings and storage IDs quickly with list_media_uploads.

## How It Works

The bottom line is you get a direct line to your DatoCMS content without the tab-switching.

1. Subscribe to this Connector and grab your Full Access API Token from your DatoCMS settings.
2. Plug that token into your preferred AI client configuration.
3. Ask your agent to list records, run queries, or update content.

## Frequently Asked Questions

**Can I use the DatoCMS MCP to create new content?**
Yes, you can create new records directly through your agent. It handles the JSON:API requirements so your new content follows your project's rules perfectly.

**Does the DatoCMS MCP let me delete media files?**
Yes, it can remove specific media uploads from your storage. This is great for cleaning up your library or removing old assets.

**Can I use this to run GraphQL queries?**
Definitely. You can run queries against your content delivery area to see exactly how your data will appear on your site.

**How do I manage my content models with this?**
You can use the Connector to list all your registered models and item types. It gives you a quick way to see how your content is structured.

**Is this Connector safe for updating production records?**
Yes, it uses the patch_cms_record tool to update specific fields. This allows for precise changes without affecting the rest of your data.

**Can I see my media library's storage IDs?**
Yes, the Connector lets you inspect the internal arrays of your uploaded assets. This is helpful for verifying storage identifiers securely.

**Can my agent execute custom GraphQL queries against DatoCMS?**
Yes. Use the 'execute_graphql_cda' tool. You can provide any valid GraphQL query string to fetch data from the Content Delivery API (CDA) tree, bypassing rigid limits and retrieving exactly what your agent needs.

**How do I create a new content item using the agent?**
Use the 'create_cms_record' tool. Provide the Item Type ID and a JSON object containing the attributes. The agent will orchestrate the absolute explicit bindings to generate a new record in your DatoCMS project.

**Can I inspect the available content models through chat?**
Absolutely. The 'list_global_models' tool enumerates all registered item types and models. This allows your agent to identify precisely what schemas bind to your editor blocks and which fields are available for data mutations.