# Kontent.ai MCP

> Kontent.ai (Enterprise Headless CMS) MCP lets you manage complex enterprise content workflows directly through your AI client. You can audit schemas, create new content containers, update specific language texts for items, and push variants live—all without logging into the Kontent UI.

## Overview
- **Category:** collaboration
- **Price:** Free
- **Tags:** content-orchestration, enterprise-cms, content-lifecycle, language-variants, content-delivery

## Description

This MCP gives your agent full control over your Kontent.ai CMS. Instead of clicking through menus to manage content, you talk to it. You can discover exactly what fields a piece of content needs by inspecting content type definitions. Need to update text for one language? Your agent handles the `upsert_language_variant` call and places that version into Draft status immediately. When everything is ready, running the publish workflow transitions those specific variants to Published, making them live via your delivery APIs—all in a conversation. Connecting this MCP through Vinkius means you connect once from Claude, Cursor, or any compatible client and get access to this entire content lifecycle management system.

## Tools

### get_item
Retrieves the metadata for a single piece of content using its unique codename.

### get_taxonomy
Fetches detailed information, including all nested terms, for a specific organizational tag group.

### get_content_type
Retrieves the precise structural definition and required fields for any content type schema.

### list_assets
Lists all uploaded media files and documents, providing their identifiers and cloud URLs.

### list_items
Retrieves a list of every top-level content container present in the Kontent.ai project space.

### list_taxonomies
Lists all available hierarchical taxonomy groups, similar to site tags or categories.

### list_content_types
Retrieves a list of every content type schema defined and registered in the environment.

### publish_variant
Changes a specific language variant's status from Draft to Published, making the content immediately live via APIs.

### upsert_item
Creates or updates the top-level container for a piece of content without changing its actual text fields.

### upsert_language_variant
Updates the actual body copy and structured data elements for an item, placing the new version into Draft status.

## Prompt Examples

**Prompt:** 
```
List all content items in our project
```

**Response:** 
```
I've retrieved your content items. Highlights include 'Homepage' (codename: homepage), 'About Us' (about_us), and 'Q4 Roadmap' (q4_roadmap). Would you like to check the language variants for any of these?
```

**Prompt:** 
```
Publish the 'default' variant for item 'q4_roadmap'
```

**Response:** 
```
Publishing variant… Done. The 'default' language version of 'q4_roadmap' has been transitioned to the Published stage. It is now live and available via your delivery endpoints.
```

**Prompt:** 
```
What are the structural fields for the 'Article' content type?
```

**Response:** 
```
The 'Article' content type (codename: article) contains 5 fields: 'title' (Text), 'slug' (URL slug), 'body' (Rich text), 'author' (Content relation), and 'hero_image' (Asset). I can help you create a new item implementing this schema.
```

## Capabilities

### Audit Content Structure
Inspect available fields and structural requirements for any registered content type.

### Manage Item Containers
List existing content items or create/update the top-level containers that hold all your content.

### Update Multilingual Variants
Change specific text fields for a single language (like Portuguese) within an item, moving it to Draft status automatically.

### Publish Content Live
Transition specific content variants from Draft into Published status, making them instantly available on the front end.

### Govern Taxonomy and Assets
List all organizational tags or audit uploaded media files to get their precise identifiers and cloud URLs.

## Use Cases

### Preparing a Global Launch Campaign
The marketing team needs to launch an article in five languages. They first use `list_items` to find the main container, then call `upsert_language_variant` for each language's copy, and finally run `publish_variant` sequentially for all versions to ensure a perfect, simultaneous global rollout.

### Debugging a Broken Homepage Feature
The developer realizes the homepage hero image is using an outdated asset. They use `list_assets` to get the current identifier and then pass that ID into the content type schema check using `get_content_type` before updating the item container via `upsert_item`.

### Auditing Content Schema Drift
The content architect needs to verify if a new department has added mandatory fields to the 'Article' type. They call `get_content_type` and compare the returned structure against known schemas, ensuring no required element is missing.

### Mass Content Migration
The team needs to update five different content items (using `get_item` first) and change their associated category tags. They use `upsert_language_variant` for the text changes, followed by calls to ensure the correct taxonomy groups are assigned.

## Benefits

- Go beyond simple content updates. You can audit the full schema using `get_content_type` and verify exactly what fields are available before writing any code.
- Never worry about stale links again. Use `list_assets` to get precise identifiers and cloud URLs for all media, ensuring your frontend always points to the right source.
- Manage content status changes instantly. Instead of manually updating a variant in the UI, calling `publish_variant` moves the item live with one command.
- Maintain multilingual integrity easily. You can run `upsert_language_variant` to update text for Portuguese or French without affecting the English copy or leaving the record un-drafted.
- Audit your entire site structure by using `list_taxonomies` and `list_content_types`. This helps content architects verify that all necessary organizational tags exist across environments.

## How It Works

The bottom line is that you manage your entire content lifecycle through natural conversation, never needing to touch the Kontent UI again.

1. Subscribe to this MCP, providing your Kontent.ai Environment ID and Management API Key.
2. Your agent connects using these credentials, granting it full programmatic access to the CMS backend.
3. You issue a command—for example, 'Update the article body for English'—and the system executes the necessary content writes or publishes.

## Frequently Asked Questions

**How do I publish an item using Kontent.ai MCP?**
You use the `publish_variant` tool. This function takes a specific content container and language variant, changing its status from Draft to Published so it's live on your delivery APIs.

**What is the difference between list_items and list_content_types in Kontent.ai MCP?**
`list_items` gives you a roster of actual content pieces (e.g., 'About Us'). `list_content_types` tells you about the *structure* of content, like defining that every article must have a 'title' and 'body'.

**Can I update text for only one language using Kontent.ai MCP?**
Yes, absolutely. You use `upsert_language_variant`. This tool lets you target the actual content fields of an item while specifying exactly which language (e.g., Portuguese) needs updating.

**Does Kontent.ai MCP help me find asset IDs?**
Yes, running `list_assets` will retrieve a list of all uploaded media and document files, providing you with the necessary cloud URLs and identifiers needed for your frontend applications.

**What should I do if I need to create a new piece of content?**
First, run `upsert_item` to create the top-level container. Then, use `upsert_language_variant` for each language's text, and finally publish it.