Hygraph MCP. Control content and schemas 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.
Hygraph (Headless CMS) MCP Server. Connect your AI agent directly to your Hygraph project. Run GraphQL queries, inspect content models, and manage the full document lifecycle—from drafting to publishing—all via natural conversation.
This lets you treat your headless CMS like a programmable backend service.
What your AI agents can do
Create cms document
Creates a new CMS document after validating the required data model.
Execute graphql mutation
Writes data directly to the CMS schema using a structured JSON payload.
Execute graphql query
Reads structured content data from the CMS using pure GraphQL queries.
Execute complex GraphQL queries or mutations to read or write structured content data.
Inspect the CMS schema to list all available content models and their fields.
Create, update, or publish documents, controlling their state from Draft to Published.
List project locales, media assets, and content models to understand the full scope of the content repository.
Permanently remove specific content nodes or documents from the CMS.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
Hygraph (Headless CMS) MCP Server: 10 Tools for Content Ops
Execute queries, mutate documents, and inspect schema structures across your headless CMS using AI agents.
019d75b5create cms document
Creates a new CMS document after validating the required data model.
019d75b5execute graphql mutation
Writes data directly to the CMS schema using a structured JSON payload.
019d75b5execute graphql query
Reads structured content data from the CMS using pure GraphQL queries.
019d75b5get model fields
Inspects a specific content model to list its internal fields and configuration arrays.
019d75b5list media assets
Retrieves a list of all media assets attached to the project.
019d75b5list project locales
Identifies all active translation spaces and project locales.
019d75b5list schema introspection
Retrieves the full project schema, listing all available content models and types.
019d75b5publish cms document
Changes a document's state to live, making its properties visible to the public.
019d75b5update cms document
Modifies existing content fields, safely changing values from draft to update.
019d75b5wipe cms document
Permanently deletes content nodes or documents from the repository.
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 Hygraph (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
Yo, this server hooks your AI agent straight into your Hygraph project. You'll get full command over your headless CMS—you're talking to content models, not some crappy REST endpoint. It treats your CMS like a programmable backend service.
Run Queries and Mutations: You'll execute complex GraphQL queries and mutations, letting your agent read or write structured content data directly. You use execute_graphql_query to pull structured content, and execute_graphql_mutation writes data to the schema using a JSON payload.
Discover Content Structure: You can inspect the whole CMS schema using list_schema_introspection to list all content models and types. You'll check specific models and their fields with get_model_fields to see what's inside. You'll also get a list of all media assets attached to the project by calling list_media_assets.
Manage Document State: You can handle the full content lifecycle. You'll create new documents with create_cms_document after validating the data model. You'll modify existing content using update_cms_document, and you can push content live by calling publish_cms_document. If you gotta scrap something, you'll permanently delete content nodes or documents with wipe_cms_document.
Audit Content Metadata: You'll list all project locales and translation spaces with list_project_locales. You'll use these tools to understand the full scope of your content repository.
How Hygraph MCP Works
- 1 Subscribe to the server and provide your Hygraph API Endpoint and Auth Token.
- 2 Your AI client recognizes the available tools and allows you to query the CMS structure.
- 3 You issue a natural language command (e.g., 'List all content models') and the agent executes the necessary GraphQL tool calls.
The bottom line is you manage your content architecture using only natural conversation.
Who Is Hygraph MCP For?
This is for developers and content architects who run into the limitations of siloed tools. If you spend time switching between your IDE, a GraphQL playground, and a CMS dashboard, this is for you. It lets you control the full content lifecycle—from schema inspection to publishing—all through your agent.
Testing complex GraphQL queries and inspecting content models without leaving the IDE or opening the Hygraph Playground.
Auditing schema definitions and verifying field configurations across multiple content models through conversational prompts.
Creating and publishing draft content quickly by commanding the AI agent to update specific document fields.
What Changes When You Connect
- Execute complex queries and mutations using
execute_graphql_queryandexecute_graphql_mutation. You read and write structured content data without needing to write boilerplate REST calls. - Understand your data structure instantly. Use
list_schema_introspectionto map all content models and fields. This replaces manually digging through documentation. - Manage the content lifecycle completely. You can draft content using
create_cms_document, modify it withupdate_cms_document, and push it live withpublish_cms_document—all in one conversation. - Audit your content setup. Use
list_project_localesto verify all translation spaces are accounted for, orlist_media_assetsto get all secure URLs. - Keep your database clean. If content is obsolete, use
wipe_cms_documentto delete records, preventing data clutter and maintaining performance.
Real-World Use Cases
Need to check if a new content model is supported?
A developer wants to know what fields are available for a 'Product' model. Instead of opening the Hygraph Playground, they ask their agent to run list_schema_introspection. The agent responds by confirming the model exists and runs get_model_fields to list the available fields in the chat. They can start coding immediately.
The content needs to go live, but it's still in Draft.
An editor finishes a draft blog post. They command their agent: 'Publish this post.' The agent calls update_cms_document first, then publish_cms_document using the specific ID. The content moves from draft status to live, and the site reflects the change instantly.
Updating hundreds of articles across different languages.
A global content manager needs to update the 'Pricing' page content in Spanish and French. They instruct their agent to use list_project_locales to confirm the locales, and then run execute_graphql_mutation to push the updated data across all necessary language versions.
Testing a complex query before writing code.
A frontend developer needs the title and slug for the last three published posts. They ask their agent to execute a query. The agent uses execute_graphql_query and returns the exact data payload, allowing the developer to verify the query logic before committing any code.
The Tradeoffs
Hardcoding queries
The developer writes a complex GraphQL query string and pastes it into the agent prompt, hoping it works. If the CMS model changes a field name, the query breaks with a cryptic error, requiring manual code updates.
→
Don't write the query. First, run list_schema_introspection to see the current model structure. Then, ask the agent to run execute_graphql_query using the model names it discovered. This keeps your query dynamic and safe from schema changes.
Treating CMS like a simple database
The user tries to write a record by just giving it a title and body, ignoring the required content types. The mutation fails because it doesn't account for relationships or specific field formats.
→
Use the get_model_fields tool first. This shows you the required fields and their types (e.g., 'author' must be a Relation). Then, use execute_graphql_mutation with the correct, structured JSON payload.
Forgetting the content lifecycle
An editor updates a document using update_cms_document, but forgets to call publish_cms_document. The content remains in the 'Draft' state, and the public site shows nothing.
→
Always treat publishing as a two-step process. First, use update_cms_document to save the changes, and then immediately follow up with publish_cms_document to make the changes live.
When It Fits, When It Doesn't
Use this if you need to manage the full content lifecycle. Specifically, if your workflow requires reading complex, structured data (execute_graphql_query), validating the schema (list_schema_introspection), or moving content between states (Draft to Published). Don't use this if you only need to read simple, flat data from a basic database, or if your content doesn't use a headless CMS model. If you only need to check if a document exists, use execute_graphql_query with a basic query; don't run list_schema_introspection first, as that is overkill.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Hygraph. 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
Manually checking content status is a huge drag.
Right now, figuring out what content is available is a chore. You have to jump between the Hygraph dashboard, the API docs, and the GraphQL playground. You manually run queries just to list models, then check the schema docs to see if 'Product' even has a 'SKU' field, and finally, you have to copy the field names into your actual code.
With this MCP server, you ask your agent to list the schema. It uses `list_schema_introspection` and tells you everything—all content models, all fields—in the chat. You get the data structure directly, so you don't have to leave your IDE.
Hygraph MCP Server: Control the Content Flow
You no longer need to remember the exact sequence of API calls to move content. Instead of calling `update_cms_document` and then manually calling a separate endpoint to publish, you just tell your agent, 'Publish this article.' The agent handles the entire state transition, guaranteeing the content is both updated and live.
The system treats the content lifecycle as a single, reliable process. You just tell it what state you want, and it handles the mutations and publishing steps. It's clean.
Common Questions About Hygraph MCP
How do I list all the content models in my project using list_schema_introspection? +
Run the list_schema_introspection tool. This returns a list of all content models, like 'BlogPost' and 'Author'. It's the fastest way to see what data types your CMS supports.
What is the difference between update_cms_document and execute_graphql_mutation? +
Use update_cms_document when you want to change a document's fields in a safe, conversational way. Use execute_graphql_mutation when you need to write data using a raw, structured GraphQL payload.
How can I check if a field exists on a model? +
Run get_model_fields against the specific model name. This tool returns a precise list of all available fields and their data types, confirming if the field you need is there.
Does the Hygraph MCP Server support multiple languages? +
Yes. Use list_project_locales to list all active translation spaces. This tells you exactly which locales are mapped and ready for content updates.
Can I delete content permanently? +
Yes. Use the wipe_cms_document tool. This permanently removes content nodes and documents, ensuring the data is completely gone from the repository.
When should I use `get_model_fields` versus `list_schema_introspection`? +
Use list_schema_introspection to get a list of all available content models in your project. After you know which model you need, run get_model_fields to inspect that specific model and see all its fields and data types.
What happens if I try to publish a document using `publish_cms_document` when it's still in draft? +
The publish_cms_document tool attempts to finalize the content, moving it to a published state. If the content is incomplete or invalid, the tool will return an error detailing exactly which fields need attention before it can perform the live update.
How do I ensure my API calls are secure when updating content with `execute_graphql_mutation`? +
You must provide a valid Auth Token when calling execute_graphql_mutation. This token authorizes your AI client to write data to the CMS. Always treat your API endpoint and token like secrets.
Can I test complex GraphQL queries through my agent? +
Yes. Use the execute_graphql_query tool to run any valid GraphQL query block. Your agent will return the nested document results, making it an ideal way to verify content fetching without using the Hygraph Playground.
How do I publish a draft document using my agent? +
The publish_cms_document tool allows your agent to shift a document's stage from DRAFT to PUBLISHED. You just need to provide the Model Name and the Target UUID to make the content live on your frontend.
Can I see all available fields for a specific content model? +
Absolutely. Use the get_model_fields tool with the name of your Model (e.g., 'Post' or 'Product'). Your agent will perform a schema introspection and list all fields, types, and scalar parameters defined in that model.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Wemix Explorer
Explore Wemix blockchain data — query accounts, track token transfers, and inspect blocks or extrinsics directly from your AI agent.
TypeScript Excellence Prover
AI agents produce unsafe TypeScript loaded with `any` types, @ts-ignore overrides, empty catch blocks, and event-loop blocking operations. This prover enforces absolute type safety, zero-workaround policies, typed error schemas, decoupled architecture, and optimized async execution.
UserStack User-Agent Lookup
Universal User-Agent intelligence — detect devices, browsers, and OS via AI.
You might also like
FOSSA (License Compliance)
Manage license compliance and security vulnerabilities via FOSSA — list projects, inspect revisions, and track dependencies directly from your AI agent.
VineRadar
Search wine and vineyards — audit varietals and vintages via AI.
Open Finance Brasil
Connect Open Finance Brasil to any AI agent via MCP.