Amplience MCP. Manage content item lifecycles via conversation.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
Amplience MCP Server connects your headless CMS to your AI agent. Use it to query content hubs, pull structured data, edit schemas, and deploy live content items directly via chat.
It lets you manage your entire enterprise content lifecycle—from drafting a blog post to hitting the live edge—without touching a UI.
Manage content structure, validate schemas, and deploy assets using conversational prompts.
What your AI agents can do
Create content item
Generates a new, structured content item within a specified folder, adhering to a schema.
Delete content item
Permanently deletes a content item from the repository database after version validation.
Get content item
Retrieves a specific content item's configuration, including its schema and revision lock.
Lists accessible Amplience Hubs and repositories, letting your agent understand the full content landscape.
Retrieves the folder structure within a repository, helping you pinpoint specific content types or assets.
Pulls a specific content item, returning its metadata, current schema, and revision lock for inspection.
Retrieves paginated lists of content items from a given repository for bulk review.
Creates new, structured content items into a designated folder, adhering to a specific schema.
Updates existing content item data, ensuring the new payload matches the item's current schema.
Forces a specific content item version to the live delivery CDN, making the changes visible to users.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Amplience MCP Server: 10 Tools for Content Ops
These tools let your AI client read, write, and publish content items across your Amplience CMS structure, managing the entire content lifecycle conversationally.
019d754dcreate content item
Generates a new, structured content item within a specified folder, adhering to a schema.
019d754ddelete content item
Permanently deletes a content item from the repository database after version validation.
019d754dget content item
Retrieves a specific content item's configuration, including its schema and revision lock.
019d754dget delivery content
Pulls the exact structural matching for Delivery CDN blocks.
019d754dlist content items
Retrieves paginated lists of content items from a specified repository.
019d754dlist folders
Lists all folders organizing content within a given repository.
019d754dlist hubs
Lists all accessible Amplience Hubs (environments) for the active workspace.
019d754dlist repositories
Lists all content repositories available inside a specific Hub.
019d754dpublish content item
Publishes a specific content item version to the live delivery CDN.
019d754dupdate content item
Updates an existing content item's data structure, matching its current schema.
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 Amplience, 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
Hey, this Amplience MCP Server connects your headless CMS straight to your AI agent. It lets your agent treat your whole content architecture like a conversational API. You don't gotta click around in a UI; you just talk to your CMS. You can figure out asset hierarchies, pull content metadata, update schemas, and push live items—all just by chatting with your agent.
Map Content Structure
Your agent first needs to understand where everything lives. You can list all accessible Amplience Hubs and all available content repositories within a Hub. From there, it retrieves the folder structure inside a repository, helping you pinpoint specific content types or assets. You can also get the exact structural matching for Delivery CDN blocks.
Fetch Content Details
To check anything out, your agent can pull a specific content item. This returns all its metadata, its current schema, and its revision lock. Need to see what's available? You can also read paginated lists of content items from any given repository for a bulk review.
Write Content Drafts
Want to create something? Your agent writes new, structured content items into a designated folder, making sure the content sticks to a specific schema. It can also update existing content item data, ensuring the new payload matches the item's current schema. You'll find it can permanently delete content items from the repository database, provided version validation allows it.
Publish Live Content
When you're done drafting, your agent publishes a specific content item version to the live delivery CDN, making the changes visible to users. It can also take a specific content item and retrieve its full configuration, including its schema and revision lock, so you know exactly what you're pushing. You can also list all content items available in a repository, or list all content folders available in a repository.
How Amplience MCP Works
- 1 First, enable the connector and provide your Amplience Hub Name and Personal Access Token.
- 2 Next, prompt your agent to perform a content action (e.g., 'List all repositories in the 'Core Web Components' Hub').
- 3 Finally, your agent runs the necessary tools, delivering structured JSON results you can use to refine your next prompt or action.
The bottom line is: you control complex content operations through natural language prompts instead of UI clicks.
Who Is Amplience MCP For?
Content Managers, Frontend Developers, and Marketing Ops Engineers. This is for anyone who spends too much time clicking through CMS dashboards, hunting down the right schema, or manually triggering a content publish. If your job involves moving content from 'draft' to 'live,' you need this.
Commands the agent to draft a promotional blog post, specifying SEO fields and target metadata, without leaving the chat window.
Asks the agent to read the precise output validation structure of an Amplience schema, allowing them to scaffold the required TypeScript interface in their IDE.
Directs the agent to locate a specific banner content block, update the live URL paths, and publish the changes instantly.
What Changes When You Connect
- Bypass the CMS UI entirely. Instead of clicking through five screens to find a banner config, you tell the agent to locate and update the block using tools like
list_repositoriesandupdate_content_item. - Ensure data integrity every time. Before publishing, use
get_content_itemto retrieve the schema lock and payload. This guarantees your changes fit the required structure. - Streamline deployments. Triggering a live push is simple. Use
publish_content_itemto bypass draft status and hit the delivery CDN directly. No manual publishing steps required. - Understand your entire content graph. Use
list_hubsandlist_repositoriesto map out the full content architecture. Your agent knows where every piece of content lives. - Write code against the CMS. Developers can use the agent to read schema validation rules and scaffold corresponding interfaces, using
get_content_itemdata directly in their IDE. - Batch content operations. Need to check 50 blog posts? Use
list_content_itemsto pull a paginated list, then useupdate_content_itemto process them all in sequence.
Real-World Use Cases
Fixing a broken banner on the homepage
The banner URL is wrong. Instead of logging into Amplience, finding the 'Core Web Components' repository, and manually updating the banner block, you ask your agent. The agent uses list_repositories to find the right spot, then runs get_content_item to grab the current structure, and finally runs update_content_item to fix the URL path. The problem is solved in three prompts.
Drafting a product page for a new line
The marketing team needs a new product page. They instruct the agent to create_content_item in the 'Product Metadata' folder, providing the title and SKU. The agent ensures the payload is strictly typed and ready for review, eliminating the need for a manual content creation form.
Making a content update live immediately
You finished editing a blog post draft. Instead of clicking the 'Publish' button and waiting for the queue, you ask the agent to publish_content_item. This forces the content item to the live delivery CDN, making it instantly available to the public.
Inspecting complex asset dependencies
You're unsure if a specific article is linked to the right imagery. You first use list_folders to map the article's path, then get_content_item to pull the article's metadata and schema. This reveals the exact dependencies on other content types, helping you audit the site structure.
The Tradeoffs
Trying to list everything at once
Prompting the agent to 'List all content items' without specifying filters or limits, causing the tool to run an unpaginated query that times out and crashes the connection pool.
→
Always use list_content_items and provide pagination parameters. If you need the whole list, ask the agent to run list_content_items in chunks, respecting the API limits.
Publishing without checking schema
Simply telling the agent to 'Publish this content' without first checking the required structure, leading to a failed deployment because the payload doesn't match the live schema.
→
First, run get_content_item to validate the schema and retrieve the current payload structure. Then, use update_content_item to make changes, and finally, publish_content_item.
Deleting content without validation
Asking the agent to delete_content_item on a critical piece of content without confirming its version status, potentially deleting the wrong item or triggering an irreversible failure.
→
Always run get_content_item first. Check the revision lock to confirm the item is safe for deletion before authorizing delete_content_item.
When It Fits, When It Doesn't
Use this MCP Server if your job requires managing content state, structure, and deployment across a complex headless CMS. You need to move data from a draft state to a live state, or you need to read the schema rules before writing data. Don't use it if you only need to view content in a single, simple list—a standard CMS API call is fine. If you just need to check which content types exist, use list_hubs and list_repositories first. If you need to verify what's live on the CDN, use get_delivery_content before you write anything.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Amplience. 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
Content publishing shouldn't feel like a pilgrimage through five different dashboards.
Today, updating a simple banner ad means logging into the CMS, navigating to the correct 'Components' hub, finding the specific 'Banner' repository, locating the asset folder, opening the item, changing the URL path, saving, and then finding a separate 'Publish' button. It's a multi-click nightmare.
With the Amplience MCP Server, you just tell your agent what needs fixing. The agent handles the navigation: it uses tools like `list_repositories` to find the right spot, `get_content_item` to read the data, and then `update_content_item` to push the fix. You get the updated content item JSON right in your chat window.
Amplience MCP Server: Deploying content updates via chat.
The manual steps that vanish are the tedious navigation, the copy-pasting of IDs, and the guesswork around which version you're updating. You don't worry about the underlying API calls; you just tell the agent, 'Publish this draft.'
The difference is that you treat the entire content lifecycle—drafting, validating, updating, and going live—as one conversation. It's immediate, traceable, and requires zero UI interaction.
Common Questions About Amplience MCP
How do I check what content is live on the CDN using the Amplience MCP Server? +
Use get_delivery_content. This tool retrieves the exact structural matching for Delivery CDN blocks, letting you verify what's currently live without guessing.
Can I use the Amplience MCP Server to create new content items? +
Yes, use create_content_item. You specify the target folder and provide the content payload, and the agent generates the new item adhering to the required schema.
What is the difference between `update_content_item` and `create_content_item`? +
create_content_item makes a brand new item. update_content_item changes an existing item's data structure, but it must match the item's current schema.
Is the Amplience MCP Server safe for deleting content? +
Deletion requires careful steps. You must first use get_content_item to retrieve the item and check its schema revision lock before the agent can execute delete_content_item.
How do I find all content repositories in my Amplience Hub? +
Use list_repositories. This tool takes your Hub as input and lists every available content repository within that specific environment.
How do I use the `list_hubs` tool with the Amplience MCP Server? +
The list_hubs tool lists all accessible Amplience Hubs. You use it first to identify the correct workspace environment before attempting any other operations.
What information does the `get_content_item` tool provide via the Amplience MCP Server? +
It retrieves the item's configuration, its schema revision lock, and its current payload. This allows you to verify the exact structure and versioning of the content before making changes.
Can the Amplience MCP Server handle content deletion using the `delete_content_item` tool? +
Yes, the delete_content_item tool permanently deletes content. However, it requires version validation to ensure you don't accidentally remove active or locked data.
Can the agent push updates without breaking my Amplience JSON schemas? +
Yes. Before invoking the update tool, the agent utilizes context to retrieve the item's precise configuration. It parses the associated Schema ID requirements and injects the updated stringified payload adhering identically to Amplience's validation rules.
Will the integration protect my items against concurrent manipulation issues? +
Yes. Our Amplience server requires the agent to explicitly pass the exact version lock integer on every DELETE or UPDATE request. If a human colleague alters your CMS page while the agent is typing, the AI request is robustly rejected avoiding fatal overwrites.
Can I publish a finalized post straight to the Edge Delivery API from here? +
Absolutely. Once the content looks solid offline, just declare 'Publish this content item now.' The agent resolves the publish_content_item tool pointing to your Edge API and the post lives dynamically on your core frontend instantly.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Roblox Avatar & Catalog Intelligence
Universal Roblox marketplace intelligence — audit item prices, bundles, and user inventories via AI.
Awin
Global affiliate marketing automation — manage advertiser programmes, track transactions, and generate tracking links via AI.
Simple Fatoora
Generate ZATCA-compliant electronic invoices for Saudi Arabian businesses with automated tax calculations and QR code embedding.
You might also like
Metricool
Social media analytics and scheduling via Metricool — track Instagram, Facebook, and Twitter metrics.
Beeline
Manage your external workforce via Beeline VMS — list assignments, requisitions, and timesheets directly from any AI agent.
Marketaux
Financial news and stock market intelligence — track global market sentiment and trending news.