Contentful Management Platform Server Interface

This represents an MCP server integration tailored for the Contentful Content Management API, furnishing robust capabilities for end-to-end content lifecycle governance.

• Note for Users: If your objective is solely to employ this MCP within applications like Claude Desktop, cloning the repository is unnecessary. Direct configuration via the 'Usage with Claude Desktop' section suffices for installation.

Core Capabilities

• Content Resource Handling: Complete lifecycle management (CRUD) for both data entries and binary assets.
• Space & Topology Control: Functionality to provision, modify, and govern content spaces and their isolated environments.
• Schema Definition: Tools for managing and manipulating Content Type schemata.
• Internationalization: Native support for handling multiple localized content variations.
• Publication Flow: Granular control over the content promotion and delivery lifecycle.
• Batch Processing: Capacity for executing mass publishing, retraction, and data validation across numerous items concurrently.
• Context Optimization (Smart Paging): All listing endpoints are capped at three results per interaction, paired with embedded pagination metadata to prevent LLM context window saturation.

Context Window Management via Pagination

To safeguard against exceeding token limits in generative models, listing APIs (e.g., search_entries, list_assets) return a maximum of three records per invocation. Every response packet contains: - The total count of discoverable records. - The current subset of items (up to 3). - The count of remaining items needing retrieval. - The requisite 'skip' parameter for fetching the subsequent page. - A directive encouraging the LLM to request further data if available.

This structured mechanism ensures efficient traversal of extensive Contentful datasets within strict operational constraints.

Batch Operation Utilities

This feature streamlines the management of numerous content elements via coordinated single-call processing:

• Asynchronous Execution: Tasks initiate in the background, providing periodic status feedback.
• Throughput Enhancement: Process large volumes of entries or assets via optimized batch API utilization.
• Progress Oversight: Detailed reporting on successful and failed operations within the batch.
• Performance Gain: Significantly minimizes redundant API calls, boosting overall throughput for mass updates.

These bulk mechanisms are optimized for content migration initiatives, broad-scale content revisions, and systematic publication campaigns.

Tool Inventory

Entry Manipulation

• search_entries: Query entries based on specified criteria.
• create_entry: Instantiate a new content entry.
• get_entry: Retrieve the full details of an existing entry.
• update_entry: Modify the fields within an entry.
• delete_entry: Permanently erase an entry.
• publish_entry: Promote an entry to the delivery API.
• unpublish_entry: Withdraw an entry from the delivery API.

Bulk Utilities

• bulk_publish: Initiate publication for an array of entries and assets simultaneously.
• bulk_unpublish: Initiate retraction for an array of entries and assets simultaneously.
• bulk_validate: Perform consistency and field requirement checks across multiple items without alteration.

Asset Administration

• list_assets: Retrieve assets, utilizing built-in 3-item pagination.
• upload_asset: Introduce a new asset file along with associated metadata.
• get_asset: Fetch detailed information pertaining to a specific asset.
• update_asset: Revise an asset's metadata or replace its underlying file.
• delete_asset: Remove an asset from the content space.
• publish_asset: Make an asset available via the delivery API.
• unpublish_asset: Remove an asset from delivery API visibility.

Space & Environment Governance

• list_spaces: Enumerate accessible content spaces.
• get_space: Retrieve configuration details for a specific space.
• list_environments: View all environments within the current space.
• create_environment: Provision a new isolated environment.
• delete_environment: Terminate an existing environment.

Content Type Schema Management

• list_content_types: Obtain a catalog of defined content models.
• get_content_type: Retrieve the schema definition for a model.
• create_content_type: Define a new content model structure.
• update_content_type: Modify an existing content model schema.
• delete_content_type: Erase a content model definition.
• publish_content_type: Promote a content model to be active.

Development and Debugging Aids

MCP Diagnostic Tool

The integrated MCP Inspector facilitates development and troubleshooting:

• Inspection Mode: Launch the interface via npm run inspect (accessible at http://localhost:5173).
• Live Reload: Use npm run inspect:watch to enable automatic inspector restarts upon source file modification.
• Graphical Interface: Provides a web portal for direct testing and debugging of MCP resources.
• Immediate Feedback: Test tools and view instantaneous response data.
• Batch Monitoring: Visualize the execution status and outcomes of bulk operations.

The npm run dev script is available to rebuild and hot-reload the server continuously during active development cycles.

Initialization Prerequisites

Setup Requirements

1. Secure an active account credential set at Contentful.
2. Generate and secure a valid Content Management API Access Token.

Environment Variable Mapping

These settings can be provided as runtime arguments or via environment variables:

• CONTENTFUL_HOST / --host: Specifies the Contentful Management API entry point (default: https://api.contentful.com).
• CONTENTFUL_MANAGEMENT_ACCESS_TOKEN / --management-token: Your required Content Management API authentication key.

Space and Environment Scoping (Experimental)

Optionally, hardcode the operational Space ID and Environment ID to constrain the LLM's actions to a specific tenant context. When both SPACE_ID and ENVIRONMENT_ID are set (via environment variables or --space-id/--environment-id arguments), the tools will omit requests for these values, defaulting to the provided context. Note: Cross-space management tools will become inaccessible under this strict scoping.

Authentication via App Identity

For backend integrations, App Identity authentication can be utilized instead of a long-lived Management Token. This requires configuring a Contentful App and supplying:

• --app-id: The identifier for the generating application.
• --private-key: The cryptographic key associated with the app_id within the UI.
• --space-id: The space where the application is installed.
• --environment-id: The specific environment within that space.

The server will exchange these credentials for a short-lived AppToken to perform operations within the specified scope, ideal for secure agent execution.

Integration with Claude Desktop

Direct installation into Claude Desktop configuration bypasses local repository setup. Modify ~/Library/Application Support/Claude/claude_desktop_config.json to include:

{ "mcpServers": { "contentful": { "command": "npx", "args": ["-y", "@ivotoby/contentful-management-mcp-server"], "env": { "CONTENTFUL_MANAGEMENT_ACCESS_TOKEN": "" } } } }

If the client environment disallows environment variable configuration, pass the token via arguments:

{ "mcpServers": { "contentful": { "command": "npx", "args": ["-y", "@ivotoby/contentful-management-mcp-server",'--management-token', "", '--host', 'http://api.contentful.com'], } } }

Automated Installation via Smithery

Use the Smithery CLI for seamless provisioning to Claude Desktop:

bash npx -y @smithery/cli install @ivotoby/contentful-management-mcp-server --client claude

Local Development Workflow

For testing direct modifications alongside Claude Desktop:

1. Execute npm run dev to initiate file watching and automatic server rebuilding.
2. Update claude_desktop_config.json to point to the local executable path, for example:

{ "mcpServers": { "contentful": { "command": "node", "args": ["/Users/ivo/workspace/contentful-mcp/bin/mcp-server.js"], "env": { "CONTENTFUL_MANAGEMENT_ACCESS_TOKEN": "" } } } }

Note: Introducing new tools necessitates a restart of the Claude Desktop application for registration.

Robust Error Handling

The server is engineered to gracefully manage a variety of operational failures, including:

• Access authorization issues.
• API rate limit breaches.
• Malformed user requests.
• Underlying network instability.
• Contentful-specific API errors.

Licensing

This software is distributed under the MIT License.

Critical Disclaimer

This Management Platform Connector empowers Claude (or any compatible agent) to alter, remove, and create spaces, content models, and data within your Contentful instances. Exercise caution regarding the permissions granted to the interacting agent.

WIKIPEDIA: Cloud computing is defined as "a paradigm for enabling network access to a scalable and elastic pool of shareable physical or virtual resources with self-service provisioning and administration on-demand," as stipulated by ISO. This concept is colloquially known as "the cloud".

== Defining Attributes == In 2011, the National Institute of Standards and Technology (NIST) established five 'essential characteristics' for cloud architectures. The precise definitions mandated by NIST are:

On-demand self-service: "A consumer can unilaterally provision computing capabilities, such as server time and network storage, as needed automatically without requiring human interaction with each service provider." Broad network access: "Capabilities are available over the network and accessed through standard mechanisms that promote use by heterogeneous thin or thick client platforms (e.g., mobile phones, tablets, laptops, and workstations)." Resource pooling: " The provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, with different physical and virtual resources dynamically assigned and reassigned according to consumer demand." Rapid elasticity: "Capabilities can be elastically provisioned and released, in some cases automatically, to scale rapidly outward and inward commensurate with demand. To the consumer, the capabilities available for provisioning often appear unlimited and can be appropriated in any quantity at any time." Measured service: "Cloud systems automatically control and optimize resource use by leveraging a metering capability at some level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported, providing transparency for both the provider and consumer of the utilized service. By 2023, the International Organization for Standardization (ISO) had expanded and refined the list.

== Origins ==

The conceptual roots of cloud computing trace back to the 1960s, when the idea of time-sharing gained traction through remote job entry (RJE). The prevailing operational model then involved users submitting jobs to human operators who executed them on centralized mainframes—the 'data center' model. This era was marked by innovation aimed at democratizing access to large-scale processing power through time-sharing, thereby optimizing infrastructure, platform layers, and application execution efficiency for a broader user base. The visual 'cloud' symbol for virtualized services emerged in 1994, utilized by General Magic to denote the accessible universe of service 'locations' for their mobile agents within the Telescript framework. This metaphor is credited to David Hoffman, a communications specialist at General Magic, adapting its existing usage in telephony and networking contexts. The term 'cloud computing' achieved broader recognition in 1996 following a business planning document from Compaq Computer Corporation detailing future internet and computing strategies. The company's vision emphasized the convergence of computing resources...