Supercharge your AI with Agility CMS. Map your content structure instantly.
Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Agility CMS MCP manages and queries your content structure through AI. It gives you programmatic access to nested sitemaps, specific page layouts, and entire reference lists within the Agility CMS environment.
You can list article entries, search for keywords across content types, or track incremental updates directly via natural language prompts.
What your AI can do
Get page layout
Pulls the structural modules and layout definitions for one given page ID.
Get site flat router
Gets the complete and exact flat list of all available CMS routes/pages.
Count reference items
Gets the total item count for any defined CMS reference list.
Fetch the full nested sitemap tree or generate a complete flat list of every CMS route.
Determine the total number of items in specific content reference lists, such as articles or authors.
Retrieve the exact structural modules and layout definitions used on a single page ID.
Filter large content lists by specific keywords or criteria within the Headless CMS environment.
Get only the pages or items that have been updated since your last sync token, minimizing data transfer.
Ask an AI about this
Compatible AI Apps
OAuth 2.0 CompatibleWaiting for input…
Agility CMS MCP with 10 Tools
These tools allow you to analyze the entire CMS architecture, from sitemaps and routing graphs to specific module definitions and content item payloads.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Agility CMS on VinkiusGet Page Layout
Pulls the structural modules and layout definitions for one given page ID.
Get Site Flat Router
Gets the complete and exact flat list of all available CMS routes/pages.
Count Reference Items
Gets the total item count for any defined CMS reference list.
Get Media Gallery
Retrieves a specific media asset group mapping containing photos and galleries.
Get Single Item
Retrieves a full content item payload, such as an article body, using its unique...
Get Site Tree
Retrieves the nested sitemap architecture for a specified digital channel name.
List Content Items
Lists multiple content items, pulling them from an Agility CMS Reference list (e.g., blog posts).
Search Content Reference
Searches for specific keywords inside a designated Content Reference List.
Sync Incremental Items
Retrieves content items that have been updated since the last synchronization token...
Sync Incremental Pages
Gets all pages that were modified since the last sync token; start with 0 to fetch...
Connect to your AI in seconds. Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
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 Agility CMS, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ 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
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Agility CMS. 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 connection provides 10 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
Manually mapping out site structure takes hours of API guesswork.
Right now, if you want to know the full scope of your website—what pages exist and how they connect—you have to hit multiple APIs: one for the root sitemap, another for sub-channels, and yet another just to see what kind of modules each page uses. It’s a tedious process of copy-pasting IDs into different developer tools until you finally piece together the full picture.
With this MCP, your agent handles that complexity. You ask for the site's structure once, and it gives you the nested sitemap tree or the complete flat list of all routes. It’s instant architectural insight.
Get Page Layouts with get_page_layout
Previously, finding out if a page used a Hero Banner module or just basic text required logging into the CMS admin and manually checking the underlying template code. You'd have to jump between tabs: 'Modules,' 'Structure,' and 'Assets.'
Now, you ask your agent for the layout using get_page_layout. It immediately spits out a clean breakdown of exactly what modules are mapped to that page ID. That’s it.
What your AI can actually do with this
Connecting this MCP lets your agent treat the Agility CMS like a direct database interface—but without writing complex API calls. Instead of manually navigating sitemap APIs or digging through page ID documentation, you simply ask your AI client for what you need. You can map out how all your digital channels are structured using nested tree views, or pull up specific module definitions for any given page layout.
Need to audit content? Your agent handles that too; it can count total entries in a list of authors or products, search those lists by keyword, and even fetch the full payload for an article body if you know its ID. When working with complex CMS data like this, Vinkius makes sure your AI client gets access to all these architectural tools through one unified connection.
019d7549-c125-72dd-825d-0472cad1a35f Here's how it actually works
The bottom line is you don't write code to query the CMS; your agent does it on your behalf using this MCP.
Provide the MCP with your Agility GUID, target Locale, and API Key credentials.
Your AI agent issues a natural language command (e.g., 'Show me all routes for the primary channel').
The connection executes the necessary content operation tool and returns structured data describing sitemaps, layouts, or content payloads.
Who is this actually for?
This connector targets technical roles who spend time validating content architecture. If you're a developer struggling with API documentation, or an SEO needing site-wide visibility into routing, this is for you.
Uses the MCP to get an instant breakdown of page modules and sitemaps when building components, bypassing manual CMS inspection.
Analyzes the flat site router graph natively to map out content gaps and ensure all registered routes are accounted for.
Audits specific content lists, checks page structures, or searches for missing entries without needing admin console access.
What Changes When You Connect
Stop guessing how deep your sitemap goes. Use get_site_tree to visualize the nested architecture of any channel, so you always know where a route lives.
When building frontends, don't waste time on documentation. Call get_page_layout to immediately see the exact UI modules mapped to a page ID.
Need to audit content volume? Instead of manually counting records, call count_reference_items to instantly get the total size of any list (like authors or products).
When changes happen frequently, don't pull everything. Use sync_incremental_pages or sync_incremental_items to fetch only what’s changed since your last run.
If you need a specific article body, use get_single_item with the content ID. It gives you the full payload without needing context about where it lives.
See it in action
Checking Site Coverage
An SEO specialist needs to know if a new product category was correctly linked into the main site structure. They run get_site_flat_router and immediately see all registered routes, confirming that no necessary pages were missed.
Debugging Page Components
A frontend developer is integrating a custom page template but can't figure out the module mapping. They run get_page_layout for the target page ID and get a clear list of available UI components to use.
Finding Specific Content
A content manager needs to find all articles mentioning 'Q3 pricing' across 500 blog posts. They run search_content_reference on the 'blog_posts' list, narrowing down the results instantly.
Updating Data Pipelines
A data engineer is building a content ingestion pipeline and only wants to process records modified since yesterday. Running sync_incremental_items ensures the job runs quickly without downloading gigabytes of old data.
The honest tradeoffs
Pulling all sitemap routes blindly
Attempting to manually query every single possible route for a large site, resulting in rate limits or massive, unmanageable data dumps.
Use get_site_flat_router for an exhaustive list of all routes; if you only care about one section, use get_site_tree and specify the target channel name.
Assuming content IDs are sequential
Writing code that expects the 10th article to have ID 10. When Agility changes its internal ID structure, the process fails silently.
Always use get_single_item with the explicit content ID provided by CMS metadata; don't assume sequential numbering.
Over-fetching data
Downloading full content payloads for every item in a reference list just to check if an author exists. This is slow and wastes bandwidth.
First, use count_reference_items to confirm the volume; then, if needed, only fetch specific items using get_single_item or list_content_items.
When It Fits, When It Doesn't
Use this MCP if your workflow requires deep knowledge of a Headless CMS's content architecture. You need to interact with sitemap trees (get_site_tree), map page layouts (get_page_layout), or audit the underlying data structure via reference lists (list_content_items). Don't use it if you just need a simple list of names; then, a basic lookup tool will suffice. If your goal is only to check total record count, stick with count_reference_items. This MCP handles structural integrity and content retrieval; it isn't for user authentication or general messaging.
Questions you might have
How do I check if content exists in Agility CMS using list_content_items? +
You use list_content_items to fetch multiple records from a specific reference list. This retrieves the basic metadata for items like blog posts or authors, letting you see what's there.
What is the purpose of get_site_flat_router? +
get_site_flat_router provides a single, exhaustive list of every CMS route on your site. This is useful for SEO audits when you need to ensure no path has been forgotten.
How do I find out the total number of product entries? +
Run count_reference_items and specify 'products' as the reference type. It gives you a clean, immediate count without listing every single entry first.
Can get_site_tree help me understand channel structure? +
Yes, get_site_tree requires you to provide a target channel name and returns the nested sitemap architecture for that specific digital channel.
How do I use sync_incremental_pages to keep content fresh? +
It fetches pages that have changed since your last token. This mechanism prevents huge data dumps and keeps synchronization fast, which is perfect for large sites with frequent updates.
What specific details does get_page_layout retrieve for a page ID? +
It maps the entire structural framework of that page. You'll get to know exactly what UI modules are used, which template is running, and how many components fill out key zones.
How does get_media_gallery help me with site imagery? +
It retrieves specific media asset groups or galleries. Instead of listing every single photo, this tool gives you the mapping details for an entire collection, keeping your queries organized and focused on assets.
Can I use search_content_reference to narrow down my keyword searches? +
You specify the exact reference list first (like 'authors' or 'products'). The search runs only within that defined content pool, giving you highly accurate and targeted results immediately.
Can my agent keep track of incremental updates to my CMS items? +
Yes. The agent has tools specifically designed to fetch incremental updates using a sync token. It can request only the CMS items or pages that have changed (created, updated, or deleted) since the last automated sync, optimizing fetch latency.
How do I find the correct Reference Name to query content? +
Reference Names match the identifiers predefined in your Agility CMS Models architecture (such as 'articles', 'authors', or 'posts'). If you are unsure, ask the agent to scan common variables based on your company's naming conventions.
Can my agent preview unpublished drafting content? +
That depends on the API Token you supply during the integration. If you provide a Preview API Key, the agent will have read-access to the staging and drafted documents. If you provide a Fetch API key, it will only see published items.
We've already built the connector for Agility CMS. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 10 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.