# Strapi MCP

> Strapi MCP connects your AI agent directly to a headless CMS. You can programmatically read content type schemas, fetch existing data entries, create new structured content posts, update records, and upload media assets—all through conversation.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** open-source-cms, api-development, schema-design, media-orchestration, rest-api, content-types

## Description

This connector lets you treat Strapi like an exposed API endpoint inside your conversational workflow. Instead of navigating admin dashboards or writing boilerplate code, you tell your agent what needs to happen with your site's content. It reads the structure of your entire CMS, letting you see every available field and collection type instantly. You can then ask it to draft a new article by generating all necessary JSON parameters, or update pricing data across multiple product entries without leaving your chat window. If you’re building complex systems that rely on accurate content management, connecting via Vinkius makes Strapi's entire ecosystem accessible from one place, letting you manage everything from initial schema discovery to final asset deployment.

## Tools

### create_entry
Creates a new content entry for a specific type using JSON field parameters.

### delete_entry
Permanently and irreversibly removes an existing content entry from the system.

### get_entry_details
Retrieves all stored field details for a specific, known content entry ID.

### list_assets
Generates a list of every media asset currently stored in the Strapi Media Library.

### list_content_types
Outputs a complete roster of all content types available (collections and single types).

### list_entries
Lists multiple entries belonging to a specified content type.

### list_cms_users
Provides a list of all currently registered users within the CMS system for auditing purposes.

### update_entry
Changes specific fields on an existing content entry using its IDs and new data values.

### upload_media_asset
Takes a public file URL, fetches the image, and uploads it to the Media Library.

## Prompt Examples

**Prompt:** 
```
Review my Strapi content types and show the schema for 'product'.
```

**Response:** 
```
Connected to Strapi.
**Content Types (`list_content_types`)**:
- `api::user.user`
- `api::product.product`

Schema for `api::product.product`:
- `title` (string), `price_tag` (decimal), `sku_code` (string), `available_inventory` (integer).
```

**Prompt:** 
```
Construct a newly formatted post about system updates in the 'articles' content type.
```

**Response:** 
```
Building JSON parameters...

**Executing Task (`create_entry`)**:
Successfully created entry ID: `402` in the `api::article.article` collection. Title set to 'System Updates V2', formatted correctly.
```

**Prompt:** 
```
Upload a new promotional image dependency securely into the Media Library.
```

**Response:** 
```
Accessing the Strapi Media Library securely...

**Asset Deployed (`upload_media_asset`)**:
The image `promo_banner_spring.jpg` has been successfully uploaded and is assigned the dynamic referential ID: `1005`. It's ready to be bound to your entries.
```

## Capabilities

### View Content Schemas
See every top-level content type and its specific fields defined across your CMS.

### Browse Existing Data
Retrieve lists of entries for any specified content type, allowing you to audit or analyze current records.

### Read Specific Content Details
Get the full details and metadata for a single, specific piece of content using its unique ID.

### Build and Save New Entries
Generate structured JSON payloads to create brand new records across various content types.

### Modify Existing Content
Update specific fields of a content entry without having to delete and recreate the entire record.

### Manage Media Assets
List existing media files in the library or upload new external images for use in your entries.

## Use Cases

### The Global Content Audit
A technical marketer needs to check if all 'article' types have a proper author assigned. They ask their agent to run `list_entries` for articles, and the agent returns a list of IDs, allowing them to programmatically verify missing metadata fields.

### Fixing Broken Product Pages
A developer discovers that several 'product' listings are missing their current inventory count. They use `get_entry_details` on a sample item and then instruct the agent to update all necessary entries via `update_entry`.

### Adding New Visual Content
A marketing team gets new banner images from an external source. Instead of manually uploading them, they ask the agent to `upload_media_asset`, which securely pulls the image and makes it available for use in posts.

### Schema Validation Check
A backend architect wants to ensure a new feature field is correctly implemented. They first run `list_content_types` to confirm the structure, then request that the agent validate the payload using `create_entry` before committing any changes.

## Benefits

- Schema Discovery: Use `list_content_types` to instantly map out your entire CMS structure. You get a full picture of available data models without opening any developer console.
- Content Creation at Scale: Instead of manual form filling, you tell the agent to construct content using `create_entry`, generating complex JSON payloads and saving them immediately.
- Media Management: Seamlessly handle visuals by running `list_assets` or feeding external dependencies into the system via `upload_media_asset`. Your assets are always available for linking.
- Data Integrity: Protect your live site using `list_cms_users` to audit who has access. This ensures you only work with authorized accounts when making changes.
- Efficient Updates: Don't rewrite entire posts; use `update_entry` to precisely target and modify specific fields, saving time and minimizing the chance of errors.

## How It Works

The bottom line is you give it credentials and a goal, and it executes the necessary API calls to achieve that outcome.

1. First, define this MCP as an active integration within your configuration environment.
2. Next, you must bind your deployed Strapi base URL and a verified API key from your admin panel into the parameter matrix.
3. Finally, state your objective in plain language; for example: "List all content types, then fetch the details for 'products' that need price updates."

## Frequently Asked Questions

**How do I view all the available data models using Strapi MCP?**
You run `list_content_types`. This immediately gives you a comprehensive list of every collection and single type defined in your CMS, helping you map out your entire data architecture.

**Can I update multiple entries at once using Strapi MCP?**
Yes. After listing the content types with `list_content_types`, you can use `list_entries` to gather IDs, and then command the agent to run `update_entry` across all necessary records.

**What is the difference between list_assets and upload_media_asset in Strapi MCP?**
Use `list_assets` when you need to see what images are already stored on the platform. Use `upload_media_asset` when you have an external image URL that needs to be fetched and added to your media library.

**Is deleting content irreversible with Strapi MCP?**
Yes, `delete_entry` is designed as a permanent action. The system explicitly warns that this action cannot be undone, so proceed carefully.

**Can I check who has access to the CMS using Strapi MCP?**
You use the `list_cms_users` tool. This function pulls a list of all registered users in your CMS environment for auditing and security checks.