# Webiny CMS MCP for AI Agents AI Agent Connect

> Webiny CMS MCP connects your headless content infrastructure to your AI agent so you can manage entries through natural conversation. You can create drafts, update fields, and publish content across multiple locales without leaving your chat interface. It handles the heavy lifting of GraphQL queries and content modeling so you can focus on the actual content.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_IUcCLFWKptm8T3ZnOC6XFGqdSwKmbpaEOYRidrry/ai-agent-connect
- **Tags:** graphql-api, content-modeling, serverless, content-lifecycle, data-structures, open-source

## Description

Imagine you're in the middle of a content sprint. Usually, that means jumping between your editor and a CMS dashboard, copy-pasting text, and praying the GraphQL query doesn't throw an error. This Connector changes that by bringing the entire Webiny CMS into your conversation. Instead of manually drafting JSON or wrestling with a playground, you just tell your agent what needs to happen. It handles the creation of new content entries, updates existing ones, and moves them from drafts to live status across your different locales. You can also use it to explore your content models, find specific IDs, and check your global tenant settings to make sure everything is running smoothly. It's like having a dedicated content operations manager who knows your exact data structures and can execute complex queries on demand. By connecting this to Vinkius, you get a unified way to interact with your headless infrastructure without the friction of manual data entry or complex API management.

## Tools

### create_cms_entry
Create a new draft entry for a specific content model using a JSON object for the fields. This lets you build content without opening the CMS dashboard.

### delete_cms_entry
Permanently remove a content entry revision from your CMS. Use this to clean up old drafts or mistakes.

### execute_graphql_query
Run raw GraphQL queries or mutations against the Webiny API for custom logic. This is great for complex data operations.

### get_api_introspection
Fetch the GraphQL schema to understand the available types and fields in your environment. It helps you see your full data structure.

### get_model_entry_details
Get the specific details and metadata for a content model entry by its revision ID. Use this to inspect field-level properties.

### list_model_entries
List all entries for a specific content model, filtering by draft or live status. It's the fastest way to browse your content.

### update_cms_entry
Update the fields of an existing content entry revision using a JSON object. Use this to make quick edits to live or draft content.

### get_tenant_config
Retrieve global settings and configurations for your entire Webiny tenant. This helps you verify your environment is healthy.

### publish_cms_entry
Take a draft entry and make it live and accessible via your Read API. This moves your content into production instantly.

## Prompt Examples

**Prompt:** 
```
List all the entries for our 'BlogPosts' in the US English locale.
```

**Response:** 
```
I've retrieved the entries for the **BlogPosts** model in **en-US**. Here is what I found:

| ID | Title | Status |
| :--- | :--- | :--- |
| post-1 | Introduction to Headless CMS | Draft |
| post-2 | Getting Started with Webiny | Live |
| post-3 | GraphQL Best Practices | Draft |

Would you like me to show you the full details for any of these?
```

**Prompt:** 
```
Create a new 'Product' entry with the name 'Leather Boots' and a price of $120.
```

**Response:** 
```
Done! I've created a new draft for the **Product** model:

*   **Name:** Leather Boots
*   **Price:** $120

I've assigned it the ID `prod-442`. Would you like me to publish this right now or make any other changes?
```

**Prompt:** 
```
Publish the blog post with ID 'post-99' and tell me if it's live.
```

**Response:** 
```
I've successfully published the **BlogPosts** entry (ID: `post-99`). 

It is now **Live** and accessible via your Read API. Let me know if you need help with anything else!
```

## Capabilities

### Create content drafts
Generate new entries for any content model using specific field data.

### Update existing entries
Modify fields in existing content revisions instantly.

### Publish live content
Move drafts to the live API for public consumption.

### Query raw GraphQL
Execute custom mutations or queries for complex data needs.

### Browse content models
List all entries for a specific content model like Articles or Products.

### Check tenant settings
Verify your environment's health and global configurations in seconds.

### Inspect entry details
Retrieve specific metadata and property values for any content ID.

## Use Cases

### Bulk Content Updates
A marketing manager needs to update the price on 20 products. They ask the agent to update the price field for all entries in the Products model.

### Quick Draft Creation
A writer wants to quickly add a new Author entry. They tell the agent the name and bio, and it creates the draft entry immediately.

### Schema Exploration
A developer needs to know what fields are available in the Blog model. They ask the agent to run introspection to see the schema.

### Publication Audits
A content lead wants to see what's live. They ask the agent to list all Articles with a read API type to verify publication status.

## Benefits

- Skip the dashboard: Use create_cms_entry to build drafts without ever opening a browser tab.
- Faster publishing: Move content to live status instantly with publish_cms_entry instead of clicking through menus.
- Simplified queries: Run complex data operations using execute_graphql_query without manual JSON drafting.
- Easy model browsing: Quickly see what's in your Articles or Products models using list_model_entries.
- Instant config checks: Verify your environment's health and settings with get_tenant_config in seconds.
- Precise updates: Modify specific fields on existing content with update_cms_entry to keep data accurate.

## How It Works

The bottom line is your AI agent becomes a direct interface for your entire content lifecycle.

1. Subscribe to the Webiny CMS MCP through the Vinkius Marketplace.
2. Provide your Webiny API Domain and Access Token in your AI client configuration.
3. Start giving commands like Publish the latest blog post or Create a new product entry.

## Frequently Asked Questions

**Can the Webiny CMS MCP help me update content in different languages?**
Yes. It supports multi-locale management, allowing you to list, create, and update content across various locales like en-US or pt-BR through your agent.

**How does this Connector handle complex GraphQL queries?**
It allows you to execute raw GraphQL mutations and queries using plain language. You can request complex data operations without drafting JSON manually.

**Can I use this to see my CMS settings?**
Yes. You can ask your agent to check your global tenant configurations to verify that your environment is healthy and correctly configured.

**Will this Connector let me see all my content models?**
Yes. The Connector uses introspection to let your agent discover all available types, fields, and models within your specific Webiny instance.

**How do I manage my content lifecycle with this Connector?**
You can manage the entire lifecycle by asking your agent to create drafts, update specific fields, and move content to a live status.

**Can I use this to find specific content IDs?**
Yes. You can ask your agent to list all entries for a specific model, which will provide you with the IDs needed for updates or deletions.

**Can I publish a draft content entry via chat?**
Yes. The `publish_cms_entry` tool allows you to take any draft revision live. You just need to provide the entry ID and the model name, and your AI agent will handle the publication through the Webiny 'manage' API.

**Is it possible to see the entire GraphQL schema of my instance?**
Absolutely. Using the `get_api_introspection` tool, your agent can retrieve the full GraphQL schema introspection, giving you a complete overview of all available types, fields, and content models in your environment.

**How do I add a new entry to a content model through conversation?**
Use the `create_cms_entry` tool. Provide the singular model name (e.g., 'Article'), the target locale, and a JSON object containing the field data. Your agent will create the new draft entry instantly.