# Builder MCP for AI Agents AI Agent Connect

> Builder MCP lets you manage your Builder.io headless CMS directly through your AI agent. You can create content blocks, update data models, and fetch media assets without leaving your editor. It gives your agent the ability to handle complex CMS tasks, like pushing bulk updates or checking schema definitions, making it a lot faster to move content from your brain to the live site.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_BqALflagL8xNOmjaZGHvPIxPB3BCwZBh8bTcwCPe/ai-agent-connect
- **Tags:** visual-editor, digital-experience, content-automation, schema-management, web-development, no-code

## Description

Imagine you're halfway through a project and need to push a hundred localized blocks to your CMS. Usually, that means a lot of clicking, copy-pasting, and hoping you didn't miss a field. With this Connector, you just tell your agent what needs to happen. It handles the heavy lifting of navigating your models and inserting the data for you. You can ask it to find specific pages, check the rules for a content block, or even wipe out old, messy components that are cluttering your space. It's about making the CMS feel like an extension of your own thoughts rather than a separate dashboard you have to keep open. Because Vinkius makes it so easy to plug these tools into your existing stack, you can keep your focus on the creative side while the agent handles the data entry. You get to move faster because the barrier between your idea and the live site just got a lot thinner.

## Tools

### list_builder_models
See every data model and schema in your Builder space. This gives your agent a full map of your CMS architecture.

### search_active_models
Find models that match a specific name or criteria. This makes it easy to locate specific models in large spaces.

### update_visual_block
Modify an existing content block or document. Use this to update content without opening the visual editor.

### count_model_entities
Check how many live items are in a specific model. This helps you audit your content volume quickly.

### create_visual_block
Add new content entries or visual blocks to a Builder model. Use this to push new data into your CMS.

### wipe_visual_block
Permanently delete a specific content entry from your Builder.io space. This is great for cleaning up old data.

### get_single_content
Retrieve a specific content document using a query string match. It helps you find specific pages by title or ID.

### get_media_file
Get the metadata and URLs for uploaded media assets. This lets your agent see what images are available.

### get_model_schema
Pull the exact field structure and JSON bounds for a model. Use it to understand exactly what data a block requires.

### list_model_content
Fetch a list of content entries for a specific model. This is useful for pulling dynamic content blocks or pages.

## Prompt Examples

**Prompt:** 
```
Can you show me the data fields for the 'custom-hero' model?
```

**Response:** 
```
The **custom-hero** model requires the following fields:

| Field | Type | Required |
| :--- | :--- | :--- |
| `title` | Text | Yes |
| `subtitle` | Text | No |
| `cta_link` | URL | Yes |
| `bg_image` | File/URL | No |

Would you like me to create a sample content block using these fields?
```

**Prompt:** 
```
Find the page with the title 'Home' on the 'page' model.
```

**Response:** 
```
I searched the **page** model for the title 'Home' and found 1 match:

* **Document ID:** `d9e72a4...`
* **Status:** Published

It currently contains several visual layout blocks. Should I fetch the full JSON structure for you?
```

**Prompt:** 
```
How many blog posts do we have live in the 'blog-post' model?
```

**Response:** 
```
I checked the **blog-post** model for you.

There are currently **42** live items stored in that model. Let me know if you'd like me to list the most recent ones.
```

## Capabilities

### Create content blocks
Add new content entries or visual blocks to a Builder model.

### Update existing entries
Modify an existing content block or document.

### Delete deprecated content
Permanently delete a specific content entry from your space.

### Fetch model schemas
Pull the exact field structure and JSON bounds for a model.

### Search for specific pages
Retrieve a specific content document using a query string match.

### Count items in a model
Check how many live items are in a specific model.

### Fetch media metadata
Get the metadata and URLs for uploaded media assets.

## Use Cases

### Pushing bulk translations
A content editor needs to update 50 landing page sections in 10 languages. They ask their agent to push the updates, and it uses create_visual_block to do it in one go.

### Checking schema bounds
A frontend dev is building a new hero component. They ask their agent to fetch the model schema to see the exact JSON requirements for the title and image fields.

### Cleaning test environments
A DevOps engineer needs to clear out orphaned blocks from a staging environment. They ask their agent to wipe_visual_block to clear the junk instantly.

### Auditing live content
A site owner wants to know how many blog posts are live. They ask their agent to count_model_entities for the 'blog-post' model to get an instant count.

## Benefits

- Push bulk content updates: Use create_visual_block and update_visual_block to push dozens of entries in seconds without manual clicks.
- Faster schema discovery: Use get_model_schema and list_builder_models to see exactly what data your frontend needs before you write a single line of code.
- Automated cleanup: Use wipe_visual_block to clear out old content or test data without having to navigate through the UI.
- Dynamic content retrieval: Use list_model_content and get_single_content to grab specific blocks or pages for your application.
- Easy asset management: Use get_media_file to quickly grab URLs and metadata for your images and videos during development.
- Accurate data auditing: Use count_model_entities and search_active_models to keep track of your live content volume and model health.

## How It Works

The bottom line is you get a direct bridge between your AI agent and your Builder.io CMS.

1. Subscribe to the Builder MCP and grab your API keys.
2. Connect your Builder.io space to your AI client.
3. Start asking your agent to pull schemas or push content blocks.

## Frequently Asked Questions

**Can the Builder MCP help me push content to my CMS?**
Yes, it allows your AI agent to create, update, and manage content blocks directly. You can describe the content you want, and the agent will push it to your Builder.io space for you.

**How does the Builder MCP handle schema discovery?**
It can pull the exact field structure and JSON definitions for any model in your space. This helps you understand exactly what data is required before you build your frontend.

**Can I use the Builder MCP for bulk content updates?**
Absolutely. Instead of clicking through pages manually, you can ask your agent to push multiple content updates at once, which is much faster for large projects.

**Does the Builder MCP work with Cursor or VS Code?**
Yes, it works with any MCP-compatible client, including Cursor, Claude, and Windsurf. You can use it directly within your preferred code editor.

**Can I delete content using the Builder MCP?**
Yes, the Connector includes a tool to permanently remove specific content entries. This is perfect for cleaning up test data or deleting deprecated components.

**Is the Builder MCP good for frontend developers?**
It's a huge time-saver for developers. It lets you verify schemas and fetch content data without ever having to leave your IDE to check the CMS dashboard.

**Can my AI read the strict structure of a custom model before creating a block?**
Yes! We highly recommend asking your agent to use `get_model_schema` first. By retrieving the exact JSON fields (Strings, Lists, Booleans), the AI naturally learns the shape of your `Page` or `HeroContent` model and formats its `create_visual_block` mutation flawlessly avoiding validation errors.

**How can I count how many blogs or pages are in my Builder space?**
You can use the native `count_model_entities` tool. By querying a model like `blog-post`, the agent accesses the Builder backend with `limit=1` exclusively to extract the metadata counts without downloading heavyweight content arrays—highly efficient for broad analytics.

**Can the agent wipe an accidentally created page completely?**
Yes. If an error occurs or a staging draft needs removal, the agent can call `wipe_visual_block`. Supply the targeted entity ID, and the HTTP DELETE command is irreversibly broadcasted to the Builder environment. Always review IDs manually.