Provides GraphQL query capabilities for Contentful's Content Delivery API, enabling content retrieval, schema exploration, content type introspection, and example query generation with support for pagination and nested references.
Enables execution of custom GraphQL queries with variable support, schema introspection, and query validation against GraphQL schemas for efficient data fetching.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Contentful GraphQL MCP Server show me the schema for the Article content type"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server implementation that provides GraphQL query capabilities for Contentful's Content Delivery API, enabling efficient content retrieval and schema exploration.
Please note: if you are not interested in the code, and just want to use this MCP in Claude Desktop (or any other tool that is able to use MCP servers) you don't have to clone this repo, you can just set it up in Claude desktop, refer to the section "Usage with Claude Desktop" for instructions on how to install it.
GraphQL Query Execution: Execute custom GraphQL queries against Contentful's GraphQL API
Schema Exploration: Discover and understand your Contentful content model structure
GraphQL Collection Discovery: List all available GraphQL query collections in your space
Schema Introspection: Get detailed field information for specific content types
Example Query Generation: Generate example queries to help you get started
Smart Pagination: Efficient handling of large datasets with built-in pagination
Token Flexibility: Works with Content Delivery API (CDA) tokens for secure, read-only access
Related MCP server: Shopify MCP Server
This MCP server is specifically designed for GraphQL operations with Contentful, providing a more efficient and flexible way to query content compared to REST APIs.
Flexible Queries: Retrieve only the fields you need, reducing response size and improving performance
Nested References: Get related content in a single query without multiple API calls
Schema Validation: Queries are validated against the GraphQL schema when available
Efficient Data Fetching: Reduce over-fetching and under-fetching of data
Type Safety: Leverage GraphQL's strong typing system for better query construction
The MCP server provides four core GraphQL tools:
graphql_list_content_types)Discover all available GraphQL query collections in your Contentful space's GraphQL schema.
{
spaceId: string, // Required: Your Contentful space ID
environmentId?: string, // Optional, defaults to "master"
cdaToken: string // Required: Content Delivery API token
}graphql_get_content_type_schema)Get detailed schema information for a specific content type, including all fields, their types, and relationships.
{
contentType: string, // Required: The name of the content type to explore
spaceId: string, // Required: Your Contentful space ID
environmentId?: string, // Optional, defaults to "master"
cdaToken: string // Required: Content Delivery API token
}graphql_get_example)Generate example GraphQL queries for a specific content type to help you understand query structure.
{
contentType: string, // Required: The content type to generate an example for
includeRelations?: boolean, // Optional: Whether to include related content
spaceId: string, // Required: Your Contentful space ID
environmentId?: string, // Optional, defaults to "master"
cdaToken: string // Required: Content Delivery API token
}graphql_query)Execute custom GraphQL queries against Contentful's GraphQL API.
{
query: string, // Required: The GraphQL query to execute
variables?: object, // Optional: Variables for parameterized queries
spaceId: string, // Required: Your Contentful space ID
environmentId?: string, // Optional, defaults to "master"
cdaToken: string // Required: Content Delivery API token
}The MCP server includes two helpful prompts to guide GraphQL schema exploration:
explore-graphql-schema)Guides you through a systematic exploration of your GraphQL schema with a specific goal in mind.
explore-graphql-schema(goal: "articles about marketing")build-graphql-query)Helps you build a custom GraphQL query for a specific content type with specified fields, filters, and reference handling.
build-graphql-query(contentType: "Article", fields: "title,body,publishDate", filters: "publishDate > 2023-01-01", includeReferences: true)Create a Contentful account at Contentful
Generate a Content Delivery API (CDA) token from your space settings
CONTENTFUL_DELIVERY_ACCESS_TOKEN / --delivery-token: Your Content Delivery API token (required)
SPACE_ID / --space-id: Your Contentful space ID (required)
ENVIRONMENT_ID / --environment-id: Environment ID (defaults to "master")
ENABLE_HTTP_SERVER / --http: Set to "true" to enable HTTP/SSE mode
HTTP_PORT / --port: Port for HTTP server (default: 3000)
HTTP_HOST / --http-host: Host for HTTP server (default: localhost)
This MCP server uses Content Delivery API (CDA) tokens for secure, read-only access to your Contentful content. CDA tokens are preferred because:
Security: Read-only access reduces security risks
Performance: Optimized for content delivery
GraphQL Support: Native support for GraphQL operations
Caching: Better caching capabilities for improved performance
Important: All GraphQL tools require explicit spaceId and cdaToken parameters. Environment variables can be used for convenience during development, but the tools will always require these parameters to be passed explicitly for clarity and security.
You do not need to clone this repo to use this MCP, you can simply add it to
your claude_desktop_config.json:
Add or edit ~/Library/Application Support/Claude/claude_desktop_config.json
and add the following lines:
{
"mcpServers": {
"contentful-graphql": {
"command": "npx",
"args": ["-y", "@ivotoby/contentful-graphql-mcp-server"],
"env": {
"CONTENTFUL_DELIVERY_ACCESS_TOKEN": "<Your CDA token>",
"SPACE_ID": "<Your Space ID>",
"ENVIRONMENT_ID": "master"
}
}
}
}If your MCP client does not support setting environment variables, you can also set the tokens using arguments:
{
"mcpServers": {
"contentful-graphql": {
"command": "npx",
"args": [
"-y",
"@ivotoby/contentful-graphql-mcp-server",
"--delivery-token",
"<your CDA token>",
"--space-id",
"<your Space ID>",
"--environment-id",
"master"
]
}
}
}To install Contentful GraphQL MCP Server for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @ivotoby/contentful-graphql-mcp-server --client claudeIf you want to contribute and test with Claude Desktop:
Clone the repository and install dependencies:
git clone https://github.com/ivo-toby/contentful-mcp-graphql.git
cd contentful-mcp-graphql
npm installRun the development server:
npm run devUpdate claude_desktop_config.json to reference the project directly:
{
"mcpServers": {
"contentful-graphql": {
"command": "node",
"args": ["/path/to/contentful-mcp-graphql/bin/mcp-server.js"],
"env": {
"CONTENTFUL_DELIVERY_ACCESS_TOKEN": "<Your CDA Token>",
"SPACE_ID": "<Your Space ID>"
}
}
}
}This allows you to test modifications in the MCP server with Claude directly. If you add new tools or resources, you will need to restart Claude Desktop.
The project includes an MCP Inspector tool for development and debugging:
Inspect Mode: Run npm run inspect to start the inspector at http://localhost:5173
Watch Mode: Use npm run inspect-watch to automatically restart the inspector when files change
Visual Interface: Test and debug MCP tools through a web interface
Real-time Testing: Try out GraphQL queries and see responses immediately
npm run build: Build the project
npm run dev: Development mode with auto-rebuild on changes
npm run inspect: Start the MCP inspector
npm run inspect-watch: Start the inspector with file watching
npm run test: Run tests
npm run lint: Run ESLint
npm run typecheck: Run TypeScript type checking
The MCP server supports two transport modes:
The default transport mode uses standard input/output streams for communication, ideal for integration with MCP clients like Claude Desktop.
npx -y @ivotoby/contentful-graphql-mcp-server --delivery-token YOUR_TOKEN --space-id YOUR_SPACE_IDFor web-based integrations or standalone service deployment:
npx -y @ivotoby/contentful-graphql-mcp-server --delivery-token YOUR_TOKEN --space-id YOUR_SPACE_ID --http --port 3000The StreamableHTTP implementation follows the standard MCP protocol specification, allowing any MCP client to connect without special handling.
query {
entryCollection(limit: 5) {
items {
sys {
id
}
title
description
}
}
}query {
articleCollection(limit: 3) {
items {
title
body
author {
name
bio
}
tagsCollection {
items {
name
}
}
}
}
}query {
articleCollection(where: { publishDate_gte: "2023-01-01" }, order: publishDate_DESC, limit: 10) {
items {
title
publishDate
slug
}
}
}The server implements comprehensive error handling for:
Authentication failures with CDA tokens
Invalid GraphQL queries
Network connectivity issues
Schema introspection errors
Rate limiting from Contentful's API
This MCP server is designed with security in mind:
Read-only Access: Uses CDA tokens for content delivery only
No Write Operations: Cannot modify or delete content
Token Scoping: Tokens are scoped to specific spaces and environments
Input Validation: All queries are validated before execution
MIT License
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
This MCP server is community-maintained and not officially supported by Contentful. For issues and feature requests, please use the GitHub issue tracker.
Generate a GraphQL search query for a specific content type based on cached schema information. Returns the query string and variables needed to search text fields in the content type.
| Name | Required | Description | Default |
|---|---|---|---|
| contentType | Yes | The content type to build a search query for | |
| searchTerm | Yes | The term to search for | |
| fields | No | Optional: Specific fields to search (default: all searchable text fields) | |
| spaceId | No | Optional override for the space ID (defaults to SPACE_ID environment variable) | |
| environmentId | No | Optional override for the environment ID (defaults to ENVIRONMENT_ID environment variable or 'master') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the return type (query string and variables) and mentions reliance on cached schema. However, it does not discuss side effects (none expected), required permissions, or error conditions (e.g., missing schema). This is adequate but not fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no extraneous words. It front-loads the core purpose and output, achieving high conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters with complete schema descriptions and no output schema, the description adequately explains the tool's role and output. It could be improved by linking to the graphql_query sibling or clarifying default field behavior, but it is mostly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema coverage is 100%, so the description adds minimal value beyond the schema. It mentions 'search text fields' but does not elaborate on how searchTerm is processed (e.g., partial match, case sensitivity). The description does not compensate for missing schema documentation because none is missing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates a GraphQL search query for a specific content type, using cached schema, and returns the query string and variables. This is a specific verb+resource combination that differentiates it from sibling tools like graphql_query (which executes queries) and smart_search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (to build a search query) but does not explicitly state when to use this tool versus alternatives, such as using graphql_query for execution or smart_search for more advanced search. No exclusion criteria are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
IMPORTANT: Use this tool AFTER using graphql_list_content_types to get a detailed schema for a specific content type. This tool provides all fields, their types, and relationships for a content type. You should ALWAYS use this tool to understand the structure of a content type before creating a query for it. The space ID and CDA token are automatically retrieved from environment variables.
| Name | Required | Description | Default |
|---|---|---|---|
| contentType | Yes | The name of the content type to fetch schema for (e.g., 'BlogPost') | |
| spaceId | No | Optional override for the space ID (defaults to SPACE_ID environment variable) | |
| environmentId | No | Optional override for the environment ID (defaults to ENVIRONMENT_ID environment variable or 'master') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses it is a read-only schema fetch, auto-retrieves credentials, and requires prior content type selection. Lacks explicit non-destructive statement but is implied.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences with front-loaded 'IMPORTANT' emphasis, no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complete for a simple schema-fetch tool with no output schema: covers when, why, and how to use, and what it returns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds value beyond schema by stating contentType is required, spaceId and environmentId are optional overrides, and includes an example. Schema coverage is 100%.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it fetches a detailed schema for a specific content type after listing types, distinguishing it from sibling tools like graphql_list_content_types and graphql_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says to use after graphql_list_content_types and before creating a query, providing clear when-to-use guidance and prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
IMPORTANT: Use this tool AFTER using graphql_get_content_type_schema to see example GraphQL queries for a specific content type. Learning from these examples will help you construct valid queries. The space ID and CDA token are automatically retrieved from environment variables.
| Name | Required | Description | Default |
|---|---|---|---|
| contentType | Yes | The name of the content type for the example query | |
| includeRelations | No | Whether to include related content types in the example (defaults to false) | |
| spaceId | No | Optional override for the space ID (defaults to SPACE_ID environment variable) | |
| environmentId | No | Optional override for the environment ID (defaults to ENVIRONMENT_ID environment variable or 'master') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It discloses that space ID and CDA token are auto-retrieved from environment variables, indicating safe, non-destructive behavior. However, it does not describe return format or limitations, which is a gap for a tool with no output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loading the critical instruction with 'IMPORTANT'. Every sentence adds value, and there is no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description omits details about the return format (e.g., string or object). It does state the dependency and purpose, which is adequate but not fully complete for an agent to anticipate the output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all parameters with descriptions (100% coverage). The description adds value by explaining that spaceId and environmentId have default values from environment variables, beyond what the schema says.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to provide example GraphQL queries for a specific content type after using another tool. The verb 'see example' and the resource 'GraphQL queries' are specific, and the sibling tools list shows distinctiveness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to use this tool AFTER graphql_get_content_type_schema, providing clear sequential context. It does not mention when not to use or alternatives, but the sibling list offers implicit differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
IMPORTANT: Use this tool FIRST before attempting to write any GraphQL queries. This tool lists all available content types in the Contentful space's GraphQL schema. You should always use this tool to understand what content types are available before formulating GraphQL queries. The space ID and CDA token are automatically retrieved from environment variables.
| Name | Required | Description | Default |
|---|---|---|---|
| spaceId | No | Optional override for the space ID (defaults to SPACE_ID environment variable) | |
| environmentId | No | Optional override for the environment ID (defaults to ENVIRONMENT_ID environment variable or 'master') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description bears the burden. It discloses it is a discovery tool and that credentials are auto-retrieved, but omits details like whether it mutates state or rate limits. This is minimally adequate for a read-only list operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured paragraph with the critical instruction front-loaded. Every sentence adds value with no repetition or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool lacks an output schema but the core purpose is clear. It could mention the output format (e.g., list of names) but given sibling tools handle detailed schema, this is sufficient. Slight gap, but overall complete for its role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% coverage with descriptions for both optional parameters. The description adds only the context that these are overrides with defaults, which adds little beyond schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lists all available content types in the Contentful GraphQL schema, using the specific verb 'lists' and resource 'content types'. It is well-differentiated from siblings like graphql_get_content_type_schema which targets a single type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to use this tool FIRST before writing GraphQL queries, providing clear context. However, it does not mention when NOT to use it or alternatives, though siblings handle specific cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
IMPORTANT: Before using this tool, you MUST first use graphql_list_content_types and graphql_get_content_type_schema to understand the available content types and their structure. Execute a GraphQL query against the Contentful GraphQL API. This tool allows you to use Contentful's powerful GraphQL interface to retrieve content in a more flexible and efficient way than REST API calls. The space ID and CDA token are automatically retrieved from environment variables.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The GraphQL query string to execute (must be a valid GraphQL query) | |
| variables | No | Optional variables for the GraphQL query | |
| spaceId | No | Optional override for the space ID (defaults to SPACE_ID environment variable) | |
| environmentId | No | Optional override for the environment ID (defaults to ENVIRONMENT_ID environment variable or 'master') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided. The description does not disclose behavior beyond executing a query. It fails to mention error handling, rate limits, whether the query is read-only, or any side effects. With no annotations, the description carries full burden but adds minimal behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, which is efficient. The first sentence is crucial usage guidance, and the second explains the benefit. A bit more detail on what the GraphQL interface offers could improve, but overall it avoids unnecessary text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description should ideally hint at return structure, but it does not. The prerequisite guidance and parameter info are adequate for a query tool with 4 well-documented parameters. Missing details on response format or pagination limit completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the description adds little meaningful info beyond what is in the schema. It mentions that space ID and CDA token are auto-retrieved, which is helpful context but does not deepen understanding of parameter semantics beyond schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool executes GraphQL queries against Contentful API, emphasizing flexibility. The verb 'execute' and resource 'GraphQL query' are specific. However, it could differentiate more from sibling tools like smart_search or build_search_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to first use graphql_list_content_types and graphql_get_content_type_schema before using this tool. This provides clear, actionable guidance on when and how to use the tool, distinguishing it from alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Perform intelligent search across multiple content types using cached metadata. This tool automatically searches all text fields in your content types for the given query term. Much faster and easier than manually chaining multiple GraphQL calls.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | The search term to look for across content types | |
| contentTypes | No | Optional: Limit search to specific content types (default: search all) | |
| limit | No | Maximum number of results per content type (default: 5) | |
| spaceId | No | Optional override for the space ID (defaults to SPACE_ID environment variable) | |
| environmentId | No | Optional override for the environment ID (defaults to ENVIRONMENT_ID environment variable or 'master') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behavioral traits: it uses cached metadata and searches all text fields automatically. However, with no annotations, it lacks details on whether results are read-only, authorization requirements, rate limits, or response format. Some transparency but significant gaps remain.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the core action. Every sentence adds value: first defines purpose, second adds key features and benefits. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides the essential purpose and a key detail (cached metadata), but lacks information about output structure, pagination, error behavior, or limitations. For a search tool with no output schema, more contextual completeness would be expected.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The tool description adds no extra parameter meaning beyond what the schema already provides. It mentions searching all text fields, but that is not parameter-specific.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool performs intelligent search across multiple content types using cached metadata and automatically searches all text fields. It distinguishes from manually chaining GraphQL calls, making its purpose specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when cross-content-type search is needed by touting speed and ease over GraphQL chaining, but it does not explicitly state when not to use it or mention sibling alternatives like build_search_query or graphql_query. Guidance is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
build_search_querygraphql_get_content_type_schemagraphql_get_examplegraphql_list_content_typesgraphql_querysmart_searchEach tool has a clearly distinct purpose: listing content types, getting schema, getting examples, executing queries, generating a search query, and performing intelligent search. The descriptions explicitly outline the workflow, eliminating ambiguity.
Most tools follow a 'graphql_' prefix with verbs like list, get, and query. However, 'build_search_query' and 'smart_search' break the pattern, introducing inconsistency despite individual clarity.
With six tools, the set is well-scoped for a GraphQL content exploration and search server. Each tool provides core functionality without unnecessary bloat, making it easy to navigate.
The tools cover discovery, schema understanding, example learning, and query execution comprehensively. A minor gap is the lack of a direct tool for fetching a single entry by ID, but 'graphql_query' can handle it. The cached schema might not update automatically, but that's a design choice.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Query your OpsLevel internal developer portal: catalog, maturity data, and tech docs.
Read spaces, collections, pages and content; search docs and manage GitBook organization spaces.
Query Checkly synthetic monitoring — checks, statuses, results, alerts, reporting and dashboards.
The Grafbase MCP server sits in front of a GraphQL API and exposes an MCP protocol-compliant interface that allows AI agents and LLMs to explore and query GraphQL APIs using natural language. It provides tools to search schemas, introspect types and fields, and execute GraphQL queries while minimizing context bloat by returning only relevant schema subsets, with built-in support for authentication, authorization, and configurable access control.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ivo-toby/contentful-mcp-graphql'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
