# Builder.io MCP for AI Agents MCP

> Builder.io connects your AI agent directly to your visual CMS backend. It lets you manage content entries, check model schemas, and track reusable digital components without needing to log into a dashboard. You can list all content for specific models, update records programmatically, or even monitor API usage statistics—all through natural conversation.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Tags:** visual-cms, content-modeling, digital-experience, web-development, content-automation, component-management

## Description

You need to manage complex web content, but logging into the CMS dashboard just to check a single page entry is slow. This MCP lets your AI agent bypass the UI entirely. Instead of manually navigating content models and checking schemas, you talk to it directly. You can ask your agent to list all blog posts or retrieve specific metadata from an old page template by name or ID. It handles everything from listing available spaces across your organization to updating a full content entry with new text and images. Because it's hosted on Vinkius, you connect once from any compatible client and get access to this powerful CMS tool alongside hundreds of others. You simply tell the agent what content you need—whether it's reviewing model structures or creating an entire set of new announcements—and it executes the required API calls in plain language.

## Tools

### create_content_entry
Creates a brand new piece of structured content in the CMS.

### get_content_entry
Retrieves all detailed data for one specific content entry by its ID or name.

### get_model
Shows the full schema structure and metadata for a single, specified content model type.

### get_space
Gets detailed information about a specific workspace or container within your account.

### get_api_usage
Pulls real-time statistics showing how much the CMS API has been used over time.

### list_content
Lists all available content entries for a particular model type within your space.

### list_models
Returns a list of every content model (like 'Page' or 'Blog') defined in the current workspace.

### list_spaces
Provides an overview of all distinct workspaces available across your entire organization account.

### list_symbols
Lists every reusable component or symbol that can be used across different pages and models.

### update_content_entry
Modifies an existing piece of content, changing text, images, or metadata programmatically.

## Prompt Examples

**Prompt:** 
```
What content models do I have available in my space?
```

**Response:** 
```
**Available Models:**

*   **Page**: Primary landing pages.
*   **Blog Post**: Standard articles with author and date fields.
*   **Testimonial**: Simple single-field component for quotes.

Please specify the model name if you want to list entries or check its schema.
```

**Prompt:** 
```
I need an update on the 'About Us' page. Can you pull up the current details?
```

**Response:** 
```
Found it! Here are the details for content entry `page_3`:

*   **Title:** About Our Company
*   **Status:** Published
*   **Last Modified:** 2026-05-15
*   **Primary Model:** Page
*   **Key Fields:** Mission Statement (Rich Text), Team Section (Reference to 'Team Member' model).
```

**Prompt:** 
```
Show me the structure for a blog post entry.
```

**Response:** 
```
Here is the schema for the `blog-post` model:

| Field Name | Data Type | Required |
| :--- | :--- | :---: |
| title | Text | Yes |
| content | Rich Text | Yes |
| author | Reference (User) | Yes |
| publishDate | Date | No |

The `content` field accepts markdown and rich text, allowing for complex formatting.
```

## Capabilities

### Retrieve Specific Content Details
Get detailed data for a single content entry or model type by its ID, allowing deep dives into the structure.

### Maintain CMS Structure and Assets
List all spaces, models, and reusable symbols to audit and understand the full scope of your digital architecture.

### Execute Content Changes
Create new content entries or update existing ones programmatically, treating the CMS like a data layer rather than a visual editor.

## Use Cases

### Reviewing a new website section
A developer needs to know what content types are available. They ask their agent, 'Show me all the possible models.' The agent uses `list_models` and returns a list of templates like 'Testimonial' and 'Gallery,' letting them start coding immediately.

### Updating a seasonal announcement
The marketing team needs to change a banner across 20 pages. They ask the agent to update the specific entry ID for the announcement bar using `update_content_entry`. It confirms success instantly, saving hours of manual work.

### Auditing content consistency
An architect wants to ensure all blog posts follow a strict schema. They ask the agent to use `get_model` on 'Blog Post' and review the required fields, ensuring every new article gets the necessary author reference.

### Tracking organizational growth
A digital lead needs to see what spaces exist across departments. They ask their agent to run `list_spaces`. The result shows all 15 separate department workspaces, helping them route content management requests correctly.

## Benefits

- Need to update a page? Use `update_content_entry` to modify published content instantly, bypassing the manual CMS editor.
- Building out a new section? Run `list_models` to see every available content template right from your chat window. You get an immediate blueprint of what's possible.
- Worrying about API limits? Check usage with `get_api_usage`. This tool provides real-time statistics so you never hit a ceiling unexpectedly.
- Don't know the structure? Use `list_symbols` to see all reusable components, ensuring consistency across every part of your site architecture.
- Getting specific data? Instead of searching dashboards, use `get_content_entry` or `get_model` to pull metadata and schema details instantly.

## How It Works

The bottom line is that you treat your entire CMS backend like an extension of conversation; no dashboards or manual clicks required.

1. First, subscribe to this MCP and provide your Builder.io Public and Private API Keys.
2. Next, connect your AI agent or preferred client (like Cursor or Claude) to Vinkius using those credentials.
3. Finally, give your AI agent a natural language prompt—for example, 'What are the available content models?'—and it executes the necessary calls.

## Frequently Asked Questions

**How do I use the Builder.io MCP to manage content entries?**
You simply ask your AI agent what you want to do with the content (like 'List all blog posts'). The agent handles connecting to the CMS and executing the necessary calls, giving you structured data right in the chat.

**Can this MCP help me audit my digital experience models?**
Yes. It allows you to pull model schemas using the `get_model` tool. This means you can see exactly what fields every content type requires, helping you maintain consistency across your entire site.

**I need to update a page on my website; is this MCP right for me?**
Absolutely. You use the `update_content_entry` tool. You just give the agent the ID and the new data, and it performs the change directly in your CMS backend.

**Does Builder.io MCP let me see all available components?**
Yes. The `list_symbols` tool retrieves a list of every reusable symbol or component you've built into your CMS, which is crucial for maintaining design consistency.

**What if I need to know what spaces exist in my organization?**
Use the MCP to run `list_spaces`. This tool provides a complete overview of every workspace or environment you manage, so you can direct your content efforts to the right location.