Kontent.ai MCP. Manage content, variants, and publishing status.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Kontent.ai (Enterprise Headless CMS) MCP Server lets your AI agent manage your entire content lifecycle. You can list content types, retrieve item metadata, and manage language variants—all without opening the Kontent.ai UI.
It handles item creation, updates content fields for specific languages, and publishes content to make it live.
What your AI agents can do
Get content type
Retrieves the structural fields for a specific Content Type.
Get item
Gets the metadata for a specific Kontent.ai item using its codename.
Get taxonomy
Retrieves details and nested terms for a specific Taxonomy group.
Use list_content_types and get_content_type to see exactly what fields a specific content type uses.
Use list_items and get_item to find and pull metadata for existing content containers.
Use upsert_language_variant to change the actual text fields for a specific language version of an item.
Use publish_variant to move a specific language version of an item from Draft to Published status.
Use list_taxonomies and get_taxonomy to audit or manage the content's classification hierarchy.
Use list_assets to get a list of all uploaded media and document file IDs for your site.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Kontent.ai CMS MCP Server: 10 Tools for Content Management
These tools let your AI agent manage the content lifecycle in Kontent.ai. You can read schemas, list assets, and publish variants entirely through your chat interface.
019d75c3get content type
Retrieves the structural fields for a specific Content Type.
019d75c3get item
Gets the metadata for a specific Kontent.ai item using its codename.
019d75c3get taxonomy
Retrieves details and nested terms for a specific Taxonomy group.
019d75c3list assets
Lists all uploaded media assets and document files in the environment.
019d75c3list content types
Lists all content type schemas registered in your environment.
019d75c3list items
Lists all content items within the Kontent.ai environment.
019d75c3list taxonomies
Lists all hierarchical taxonomy groups (tags/categories).
019d75c3publish variant
Publishes a specific language variant of an item, making it live via Delivery APIs.
019d75c3upsert item
Creates or updates the top-level container for a content item, but does not update the content text itself.
019d75c3upsert language variant
Updates the actual content fields of an item for a specific language, placing the variant into Draft status.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Kontent.ai (Enterprise Headless CMS), then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
Kontent.ai (Enterprise Headless CMS) MCP Server gives your AI agent total control over your content lifecycle. You can manage content structure, update language variants, and publish everything without ever opening the Kontent.ai UI. You'll use your agent to handle content item creation, update text fields for specific languages, and push content live.
Inspect Content Structure
To see what fields a specific content type uses, you can use list_content_types to get a list of all registered schemas. Then, get_content_type pulls the structural details for any type you point it to. You'll also see what fields a specific content item has by checking its metadata using get_item.
Manage Content Items
Want to find or set up a content container? You can run list_items to get a full list of all content items in your environment. You can then use get_item to pull the metadata for a specific item using its codename. If you need to create or update the top-level shell of an item, but don't want to touch the actual content text, you use upsert_item.
Update Content Variants
To change the actual text fields for a specific language version of an item, you use upsert_language_variant. This tool places that language variant into Draft status.
Publish Content
When the content is ready, you use publish_variant to move a specific language version of an item from Draft to Published status, making it live via Delivery APIs.
Classify and Tag Content
If you need to audit or manage the content's classification hierarchy, you'll use list_taxonomies to get all the available taxonomy groups. To see the specific details and nested terms within a group, you run get_taxonomy.
Handle Media Assets
To get a list of all uploaded media and document file IDs for your site, you just call list_assets.
How Kontent.ai MCP Works
- 1 Subscribe to the server and provide your Kontent.ai Environment ID and Management API Key.
- 2 Ask your agent to scope the content by listing content types (
list_content_types) or items (list_items). - 3 Execute the necessary action—whether it's running
upsert_language_variantto update text, orpublish_variantto go live.
The bottom line is, you manage the entire content flow, from schema audit to live publishing, through conversation with your AI client.
Who Is Kontent.ai MCP For?
Digital Content Editors, Content Architects, and Frontend Developers. If your job involves moving content from a draft state into a live website, or if you need to audit complex content schemas across multiple languages, this tool saves you from logging into the Kontent.ai UI and clicking through multiple dashboards.
Updates content text for specific languages and publishes finished items without leaving their workflow client.
Verifies content type schemas and audits taxonomy trees across different projects to ensure consistency.
Uses the server to introspect content types and verify asset identifiers so their applications map correctly.
What Changes When You Connect
- You can publish content directly. Use
publish_variantto transition any language version of an item to Published, making it live without manual API calls. - Content updates are tracked by language.
upsert_language_variantlets you change the actual text fields for English, Portuguese, or any other language, and it safely drafts the variant. - Audit your entire structure first. Use
list_content_typesto discover every available field and parameter before trying to build a new piece of content. - Keep track of everything. Use
list_itemsto get a full list of content item containers, andget_itemto pull its specific metadata. - Organize content taxonomy. Use
list_taxonomiesandget_taxonomyto list and verify the hierarchical structure used for content filtering. - Audit media assets easily.
list_assetsprovides precise identifiers and cloud URLs for all uploaded media and documents, which is crucial for front-end development.
Real-World Use Cases
Updating multilingual landing page copy
The editor needs to change the headline copy for a new product launch in both German and Spanish. They ask their agent to run upsert_language_variant twice, once for each language, ensuring the new copy is saved in Draft status before review.
Launching a new article post
A content architect finishes writing an article in English. The agent first runs get_item to confirm the item exists, then runs upsert_language_variant for the English variant, and finally executes publish_variant to push the content live.
Verifying site structure for a new feature
A frontend developer needs to know if the 'Article' content type has a 'featured_image' field. They run get_content_type to inspect the schema and verify the field name before coding the front-end component.
Listing and managing all site content
A project manager needs a list of every major content section. They ask the agent to run list_items to get all codenames, then run list_taxonomies to see how those sections are categorized.
The Tradeoffs
Trying to update content fields without setting the item container.
The user thinks upsert_language_variant is enough. They run it, but the agent fails because the top-level content container doesn't exist or needs to be initialized first.
→
First, run upsert_item to create or update the top-level item shell. Then, use upsert_language_variant to change the actual text fields for the specific language.
Publishing content without checking the schema.
The developer blindly calls publish_variant on an item, only to find out later that the required 'author' field was never populated, causing the published page to break.
→
Always start by running get_content_type to confirm all required fields (like 'author' or 'slug') are populated before attempting to publish with publish_variant.
Listing assets without knowing their URLs.
The frontend team writes code assuming an asset ID works directly in the public URL, but the asset is private or the ID is wrong.
→
Run list_assets first. This tool provides the precise identifiers and cloud URLs needed for reliable front-end delivery.
When It Fits, When It Doesn't
Use this server if your content workflow involves managing content state transitions, multilingual text updates, or complex schema auditing. The key is moving content from Draft to Published using specific language variants. Don't use this if you only need to store simple blog posts without structured fields. If your only need is to list simple text articles, a basic database connection might suffice. However, if your content is housed in an enterprise CMS like Kontent.ai, you need the granular control this server provides—specifically, the combination of get_content_type and upsert_language_variant makes it essential for reliable enterprise publishing.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Kontent.ai. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Managing content variants shouldn't require logging into the Kontent.ai UI.
Right now, updating a single page's copy often means logging into the CMS, navigating to the specific item, finding the language tab (English, then Spanish, then German), manually changing the text, and then clicking 'Save Draft.' If you have ten pages and three languages, that's 30 clicks, 30 logins, and a high chance of missing a required field.
With this MCP server, your agent handles the whole process. You tell it, 'Update the hero headline for item X in Spanish.' The agent uses `upsert_language_variant` and gets the change saved, all from your chat window. It's fast, it's traceable, and you never touch the CMS dashboard.
Kontent.ai MCP Server: Publish content variants directly from your agent
Before this, making content live required a complex manual workflow: save the draft, then trigger the publish webhook, and hope the delivery pipeline picked it up correctly. It was a brittle, multi-step process that often failed without manual oversight.
Now, you just ask your agent to publish the variant. The agent runs `publish_variant`, and the content is immediately marked live and available via the Delivery APIs. It's a single, reliable command that handles the entire state transition.
Common Questions About Kontent.ai MCP
How do I use the `upsert_language_variant` tool? +
The upsert_language_variant tool updates the actual content fields for a specific item and language. You need to provide the item's codename, the language code, and the new field values.
Is `upsert_item` the same as updating content text? +
No. upsert_item only handles the top-level container metadata. You must use upsert_language_variant to change the actual content text within the item.
How do I check what fields an article needs? +
Use the get_content_type tool. You provide the codename of the content type (e.g., 'article'), and it returns the exact structural fields available.
Can I list all my content items using `list_items`? +
Yes. The list_items tool retrieves a list of all content item containers in your Kontent.ai environment, giving you their codenames for use in other tools.
How do I make content live using `publish_variant`? +
The publish_variant tool takes a specific item and language variant and moves it to the Published status, making the content visible via your delivery endpoints.
How do I use `get_content_type` to verify the schema before creating an item? +
The get_content_type tool returns the exact structural fields of a Content Type. You use this to inspect available fields, scalar parameters, and required blocks before calling upsert_item.
What information do I get when I run `list_assets`? +
list_assets returns a list of all uploaded Media Assets and Document files. This data includes precise identifiers and cloud URLs, which you need for frontend delivery.
How do I manage my content structure using `list_taxonomies` and `get_taxonomy`? +
list_taxonomies lists all hierarchical groups, and get_taxonomy retrieves the nested terms for a specific group. This lets you manage and audit your content's classification structure.
Can I update the actual text of an item using my agent? +
Yes. Use the upsert_language_variant tool. While upsert_item creates the container, the variant tool allows you to populate the specific content fields (elements) for a given language, placing the item into Draft status.
How do I make my draft content live on the website? +
The publish_variant tool transitions a specific language variant from Draft to Published. This makes the content immediately accessible to your frontend applications via the public Delivery APIs.
Can my agent help me understand which fields are in a content model? +
Absolutely. Use the get_content_type tool by providing the type codename. Your agent will perform a schema introspection and list all available elements, allowing you to understand the exact structure you need to populate.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Timeero
Track employee time and mileage with GPS-verified clock-ins that generate accurate timesheets for field service teams.
CodeRabbit
Manage AI-powered code reviews via CodeRabbit — list users, track PR review metrics, audit admin actions, and control seat assignments from any AI agent.
Bonusly
Recognize and reward your team via Bonusly — give bonuses, track points, and view leaderboards directly from any AI agent.
You might also like
Canvas LMS
Manage Canvas LMS courses, assignments, and users directly through your AI agent — streamline educational workflows and administrative tasks.
Common Paper
Common Paper helps you create, send, and sign standard commercial contracts faster. Use this MCP server to automate your contract workflow and track agreement status.
Contentful
Equip your AI agent to fetch, create, and manage digital content effortlessly using Contentful's headless architecture.