How do I use Jsoncut MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Jsoncut MCP Server create an image config with a sunset background and inspirational quote" 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.

Jsoncut MCP Server

Official

by jsoncut

Overview Schema Related Servers Score Discussions

JavaScript

Hybrid

WARNING

⚠️ OUTDATED REPOSITORY - This repository is no longer maintained

A public MCP server is now available and this package is deprecated.
Please use the official public server instead: https://mcp.jsoncut.com/mcp

For more information, see: https://docs.jsoncut.com/docs/mcp/overview

🚀 Features

🎨 Image Generation: Create JSON configurations for image composition with layers, positioning, and effects
🎬 Video Generation: Create JSON configurations for video rendering with clips, transitions, and audio
✅ Configuration Validation: Validate configs against the Jsoncut API before submission
📋 Schema Resources: JSON schemas automatically available as MCP resources
🔑 Flexible Authentication: API key via environment variable or .env file

Related MCP server: RendShot MCP Server

📦 Quick Start

Using npx (Recommended for Local)

export JSONCUT_API_KEY=your_api_key_here
npx -y @jsoncut/mcp-server

Using Remote Server (Recommended)

A public MCP server is available at https://mcp.jsoncut.com. No installation needed - just configure your MCP client with your API key:

{
  "jsoncut": {
    "url": "https://mcp.jsoncut.com/mcp",
    "headers": {
      "x-api-key": "your_jsoncut_api_key_here"
    }
  }
}

Using Docker Locally (Optional)

You can also run your own local server using Docker:

# Pull and run from Docker Hub
docker run -d \
  --name jsoncut-mcp \
  -p 3210:3000 \
  centerbit/jsoncut-mcp-server:latest

# Access at: http://localhost:3210/mcp

Or use Docker Compose:

# Start the service
docker-compose up -d

# Access at: http://localhost:3210/mcp

📖 See DOCKER.md for complete Docker deployment guide

Get Your API Key

Get your Jsoncut API key at jsoncut.com

# Set as environment variable
export JSONCUT_API_KEY=your_api_key_here

# Or create .env file
cp .env.example .env
# Edit .env and add: JSONCUT_API_KEY=your_api_key_here

🎯 MCP Client Configuration

Remote Server (Recommended)

Use the public server at https://mcp.jsoncut.com:

Cursor IDE

Open Cursor Settings → Features → MCP Servers → "+ Add New MCP Server"

{
  "jsoncut": {
    "url": "https://mcp.jsoncut.com/mcp",
    "headers": {
      "X-API-Key": "your_jsoncut_api_key_here"
    }
  }
}

Claude Desktop

Add to your claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "jsoncut": {
      "url": "https://mcp.jsoncut.com/mcp",
      "headers": {
        "X-API-Key": "your_jsoncut_api_key_here"
      }
    }
  }
}

Local npx Mode

For local development without network access:

Cursor IDE

{
  "jsoncut": {
    "command": "npx",
    "args": ["-y", "@jsoncut/mcp-server"],
    "env": {
      "JSONCUT_API_KEY": "your_api_key_here"
    }
  }
}

Claude Desktop

{
  "mcpServers": {
    "jsoncut": {
      "command": "npx",
      "args": ["-y", "@jsoncut/mcp-server"],
      "env": {
        "JSONCUT_API_KEY": "your_api_key_here"
      }
    }
  }
}

Local Docker Server

If you're running your own local Docker server:

Cursor IDE

{
  "jsoncut": {
    "url": "http://localhost:3210/mcp",
    "headers": {
      "X-API-Key": "your_jsoncut_api_key_here"
    }
  }
}

Claude Desktop

{
  "mcpServers": {
    "jsoncut": {
      "url": "http://localhost:3210/mcp",
      "headers": {
        "X-API-Key": "your_jsoncut_api_key_here"
      }
    }
  }
}

📚 MCP Resources

The server automatically exposes JSON schemas as MCP resources:

schema://image - Complete image generation schema
schema://video - Complete video generation schema

AI agents can read these directly without tool calls for fast access to all configuration options.

🛠️ Available Tools

`create_image_config`

Create JSON configurations for image generation with a layer-based system.

Layer Types:

image: Display images with fit modes (cover, contain, fill, inside, outside)
text: Text with custom fonts, alignment, wrapping, and effects
rectangle: Rectangular shapes with fill, stroke, and rounded corners
circle: Circular and elliptical shapes
gradient: Linear or radial color gradients

Positioning:

Pixel coordinates: { x: 100, y: 50 }
Position strings: center, top, bottom, top-left, top-right, etc.
Position objects: { x: 0.5, y: 0.5, originX: "center", originY: "center" }

Example:

{
  "width": 1200,
  "height": 630,
  "layers": [
    {
      "type": "gradient",
      "x": 0, "y": 0, "width": 1200, "height": 630,
      "gradient": {
        "type": "linear",
        "colors": ["#667eea", "#764ba2"],
        "direction": "diagonal"
      }
    },
    {
      "type": "text",
      "text": "Welcome to Jsoncut",
      "position": "center",
      "fontSize": 64,
      "color": "#ffffff"
    }
  ]
}

`create_video_config`

Create JSON configurations for video generation with clips, layers, and transitions.

Key Features:

Clips: Sequential video segments with individual layers
Layer Types: video, image, title, subtitle, news-title, audio, gradients, and more
Transitions: 75+ effects (fade, wipe, circle, cube, glitch, zoom, etc.)
Audio: Background music, multiple tracks, normalization, and ducking

Example:

{
  "width": 1920,
  "height": 1080,
  "fps": 30,
  "defaults": {
    "duration": 3,
    "transition": { "name": "fade", "duration": 1 }
  },
  "clips": [
    {
      "layers": [
        { "type": "title", "text": "Welcome", "position": "center" }
      ]
    }
  ]
}

`validate_config`

Validate configurations against the Jsoncut API before submission.

Parameters:

type: "image" or "video"
config: Configuration object to validate
apiKey: Optional API key (uses environment if not provided)

Returns:

Validation status
Estimated token cost
Error details (if any)
Detected resources with sizes

`get_image_schema` / `get_video_schema`

Get complete JSON schemas for image or video generation.

Note: Schemas are also available as MCP resources (schema://image and schema://video) which AI agents can access directly without tool calls.

📖 Workflow

Create Configuration: Use create_image_config or create_video_config
Validate (optional): Call validate_config if you have actual file paths
Submit: Use the configuration with the Jsoncut API

The schemas are automatically available as MCP resources, so AI agents have instant access to all configuration options.

📁 File Paths

Use placeholder paths in configurations:

/image/2024-01-15/userXXX/photo.jpg
/video/2024-01-15/userXXX/video.mp4
/audio/2024-01-15/userXXX/music.mp3
/font/2024-01-15/userXXX/CustomFont.ttf

Supported formats:

Images: png, jpg, jpeg, gif, webp
Videos: mp4, mov, avi, webm
Audio: mp3, wav, m4a, aac
Fonts: ttf, otf, woff, woff2

🧪 Testing

Use the MCP Inspector for interactive testing:

export JSONCUT_API_KEY=your_api_key_here
npm run inspector

🔧 Development

Local Development

# Clone and install
git clone https://github.com/jsoncut/jsoncut-mcp-server.git
cd jsoncut-mcp-server
npm install

# Build
npm run build

# Watch mode
npm run watch

# Run locally
node dist/index.js

Configuration with Local Build

For Cursor/Claude Desktop, use the local build:

{
  "jsoncut": {
    "command": "node",
    "args": ["/absolute/path/to/jsoncut-mcp-server/dist/index.js"],
    "env": {
      "JSONCUT_API_KEY": "your_api_key_here"
    }
  }
}

📝 Examples

See the examples/ directory for complete configurations:

image-example.json - Image generation with multiple layer types
video-example.json - Video generation with clips and transitions

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

📄 License

MIT License - see LICENSE file for details.

🔗 Links

API Documentation: docs.jsoncut.com
Website: jsoncut.com
GitHub: github.com/jsoncut/jsoncut-mcp-server
npm: @jsoncut/mcp-server
Support: support@jsoncut.com

Available Tools

5 tools

create_image_configA

Create a JSON configuration for image generation based on jsoncut documentation.

Returns a complete configuration object that can be used with the validate_config tool or submitted directly to the jsoncut API.

WORKFLOW:

First get the schema (read resource schema://image or call get_image_schema) to understand all available options
Create the configuration with this tool
Call validate_config to verify the configuration (if user provided media file paths)

Image Structure:

Layer-based system (rendered bottom to top, max 50 layers)
Canvas with dimensions, background color, and output format
Support for defaults to avoid repetition

Layer Types:

image: Display uploaded images with fit modes (cover, contain, fill, inside, outside)
text: Text with custom fonts, alignment, wrapping, and effects
rectangle: Rectangular shapes with fill, stroke, and rounded corners
circle: Circular and elliptical shapes
gradient: Linear or radial color gradients

Positioning Options:

x, y coordinates (pixels from top-left)
position strings: center, top, bottom, top-left, top-right, center-left, center-right, bottom-left, bottom-right
position objects: { x: 0-1, y: 0-1, originX: left|center|right, originY: top|center|bottom }

Visual Effects:

opacity: 0-1 transparency
rotation: degrees
blur: pixel radius
borderRadius: rounded corners (image, rectangle)

Text Features:

Custom fonts via fontPath or Google Fonts via googleFont (format: 'FontName:weight' e.g. 'Roboto:600')
Text wrapping with width and lineHeight
Alignment: left, center, right
backgroundColor (single line only)

Output Formats:

png: Lossless with transparency (default)
jpeg: Lossy compression (use quality parameter)
webp: Modern format with transparency and compression

Defaults System:

defaults.layer: Properties for all layers
defaults.layerType.{type}: Properties for specific layer types

File paths should be placeholders like "/image/2024-01-15/userXXX/filename.ext" or "/font/2024-01-15/userXXX/font.ttf".

ParametersJSON Schema

Name	Required	Description	Default
`width`	No	Canvas width in pixels (max 4096px)
`height`	No	Canvas height in pixels (max 4096px)
`backgroundColor`	No	Background color (hex, rgb, or named). Default: transparent
`format`	No	Output format: png (default, transparent), jpeg (compressed), webp (modern)	png
`quality`	No	Quality for JPEG/WebP (1-100, default: 90)
`defaults`	No	Default properties for layers
`layers`	Yes	Array of layer objects (max 50). Layer types: - image: { type: "image", path, x/y/position, width, height, fit, opacity, rotation, blur, borderRadius } - text: { type: "text", text, x/y/position, fontSize, fontPath/googleFont, color, align, wrap, width, lineHeight, backgroundColor, opacity, rotation, blur } - rectangle: { type: "rectangle", x, y, width, height, fill, stroke, strokeWidth, opacity, rotation, blur, borderRadius } - circle: { type: "circle", x, y, width, height, fill, stroke, strokeWidth, opacity, blur } - gradient: { type: "gradient", x, y, width, height, gradient: { type: linear/radial, colors: [], direction: horizontal/vertical/diagonal }, opacity, rotation, blur }

TDQS

A4.1/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so description must carry the burden. It explains the config structure, layer types, positioning, effects, max layers (50), and file path conventions. However, it does not mention idempotency, authentication, or rate limits, leaving some gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Description is comprehensive but well-structured with clear sections (workflow, image structure, layer types, etc.) and front-loaded with purpose. It is slightly long but every section adds value; could be trimmed slightly but remains effective.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (nested objects, many options, no output schema), the description covers most aspects: layer types, effects, defaults, output formats, and workflow. It lacks some advanced details (e.g., error handling or limits enforcement) but is largely complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 100% description coverage, and the description adds significant detail beyond the schema, especially for complex parameters like 'layers' and 'defaults'. It explains layer types, positioning options, text features, and output formats, enriching the schema's basic descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states it creates a JSON configuration for image generation. It distinguishes from sibling tools like create_video_config and references the workflow involving get_image_schema and validate_config, making the tool's role unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description provides a workflow: get schema first, then create config, then validate if needed. It implicitly suggests when to use this tool versus siblings (e.g., get_image_schema for reading, validate_config for validation), though explicit exclusions are missing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

create_video_configA

Create a JSON configuration for video generation based on jsoncut documentation.

Returns a complete configuration object that can be used with the validate_config tool or submitted directly to the jsoncut API.

WORKFLOW:

First get the schema (read resource schema://video or call get_video_schema) to understand all available options
Create the configuration with this tool
Call validate_config to verify the configuration (if user provided media file paths)

Video Structure:

Built using clips (segments) that play sequentially
Each clip contains layers (rendered bottom to top)
Supports transitions between clips
Comprehensive audio system with multiple options

Layer Types:

video: Display video files with timing control, Ken Burns effects, and enhanced positioning
image: Static images with positioning and Ken Burns effects
image-overlay: Images positioned over other content with timing
title: Large headline text with animation styles (fade-in, word-by-word, letter-by-letter) and enhanced positioning
subtitle: Smaller text for captions
news-title: Breaking news style with colored backgrounds
title-background: Titles with full-screen backgrounds
slide-in-text: Animated text that slides in
audio: Audio tracks tied to clips (requires keepSourceAudio: true)
detached-audio: Audio with clip-relative timing
fill-color: Solid color backgrounds
linear-gradient: Linear gradient backgrounds
radial-gradient: Radial gradient backgrounds
rainbow-colors: Animated rainbow effects
pause: Black screen pauses

Audio Options:

audioFilePath + loopAudio: Background music throughout video
audioTracks: Multiple audio tracks with independent timing
audioNorm: Audio normalization with ducking
keepSourceAudio: Keep audio from video layers
Audio layers within clips

Video & title layer Positioning:

Position objects: { x: 0-1, y: 0-1, originX: left|center|right, originY: top|center|bottom }
Position strings: center, top, bottom, top-left, top-right, center-left, center-right, bottom-left, bottom-right
Video layers support both position objects and strings
Title layers support enhanced positioning with position objects

Title Layer Animation Styles:

fade-in: Smooth fade-in effect (default)
word-by-word: Words appear sequentially
letter-by-letter: Letters appear sequentially
Zoom effects automatically disabled for word-by-word and letter-by-letter styles

Transitions: 75+ transition effects including fade, wipe, circle, cube, glitch, zoom, etc.

File paths should be placeholders like "/input/userXXX/filename.ext".

ParametersJSON Schema

Name	Required	Description	Default
`width`	No	Width in pixels (default: 1280)
`height`	No	Height in pixels (default: 720)
`fps`	No	Frames per second (24, 25, 30, 50, 60, 120)
`format`	No	Output format: mp4 or mov	mp4
`fast`	No	Enable fast processing mode (for preview)
`audioFilePath`	No	Path to background audio file (plays throughout video)
`loopAudio`	No	Loop background audio if shorter than video
`outputVolume`	No	Final output volume (0-1)
`keepSourceAudio`	No	Keep audio from video layers (required for audio layers)
`clipsAudioVolume`	No	Volume for audio from clips relative to tracks (0-1)
`audioTracks`	No	Multiple audio tracks with independent timing
`audioNorm`	No	Audio normalization with ducking
`defaults`	No	Default properties for clips and layers
`clips`	Yes	Array of clip objects. Each clip has layers and optional duration/transition.

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It explains the tool creates a configuration object and describes the output in detail, including workflow and structure. It does not mention authorization, rate limits, or side effects, but for a non-destructive creation tool this is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but well-structured with clear sections (WORKFLOW, Video Structure, Layer Types, etc.). It is front-loaded with purpose and workflow. While every sentence contributes value, it could be slightly more concise, but the structure compensates.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (14 parameters, nested objects, many options), the description is comprehensive. It covers workflow, all layer types, audio options, positioning, transitions, and file path conventions. It also clarifies the return value and how to proceed with validation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

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 description adds significant context beyond the schema, explaining video structure, layer types, audio options, positioning, and transitions. This greatly enhances understanding of how to use the parameters correctly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool creates a JSON configuration for video generation based on jsoncut documentation. It distinguishes from siblings like create_image_config and mentions the returned config can be used with validate_config or the API.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes a WORKFLOW section that explicitly lists steps: first get schema, then create config, then validate config. It advises when to use validate_config (if user provided media file paths). However, it does not explicitly state when not to use this tool (e.g., for image configs), but sibling names imply the distinction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_image_schemaA

Get the complete JSON schema for image generation.

Returns the full JSON Schema document that defines all possible configuration options for image generation jobs. Use this to understand all available options, constraints, and examples.

NOTE: This schema is also available as a resource at schema://image which can be read directly without a tool call.

IMPORTANT: Get this schema FIRST when creating image configurations to understand the complete structure, available layer types, positioning options, and all properties. This ensures you create valid and complete configurations.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.6/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description adequately conveys a safe read-only operation returning schema JSON. Notes the resource alternative. Could mention that no side effects or permissions are needed, but it's sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a brief introduction then notes. Slightly wordy with the IMPORTANT section, but still clear and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers purpose, usage order, alternative access, and what is returned (full JSON schema). Complete for a simple retrieval tool with no output schema needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so the description need not add param info. The baseline of 4 applies as zero-param tools require no further detail.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Get' and the resource 'complete JSON schema for image generation'. It distinguishes from sibling tools like get_video_schema (different resource) and create_image_config (different action).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly advises to get this schema first when creating configurations, and mentions an alternative access method via resource. Provides clear when-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_video_schemaA

Get the complete JSON schema for video generation.

Returns the full JSON Schema document that defines all possible configuration options for video generation jobs. Use this to understand all available options, constraints, and examples.

NOTE: This schema is also available as a resource at schema://video which can be read directly without a tool call.

IMPORTANT: Get this schema FIRST when creating video configurations to understand the complete structure, available layer types, audio options, transitions, and all properties. This ensures you create valid and complete configurations.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A4.9/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Discloses that it returns the full JSON Schema document, with no side effects or hidden behaviors; the description carries full burden given no annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with purpose, then adds key details and usage notes; each sentence is informative and well-structured without redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters and no output schema, the description fully explains what the schema contains and why it's useful, meeting all contextual needs.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, baseline is 4; description adds context about the schema content without needing param details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states it gets the complete JSON schema for video generation, distinguishing it from get_image_schema and other siblings that create or validate configs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly recommends using this tool first when creating video configurations and notes an alternative resource method, providing clear when-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

validate_configA

Validate a job configuration against the jsoncut API.

This tool sends the configuration to the API's validation endpoint to check:

Schema compliance
Resource availability
Estimated token cost
Any configuration errors

WHEN TO USE:

ONLY call this tool if the user has provided actual media file paths (e.g., from uploaded files)
DO NOT validate configurations with placeholder paths like "/image/2024-01-15/userXXX/..."
Always call this after creating a configuration when real file paths are available

BENEFITS:

Catches errors before job submission
Provides accurate token cost estimates
Verifies that referenced files exist and are accessible

ParametersJSON Schema

Name	Required	Description
`type`	Yes	Job type: image or video
`config`	Yes	The configuration object to validate (from create_image_config or create_video_config)
`apiKey`	No	API key (optional if JSONCUT_API_KEY env var is set)

TDQS

A4.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses that the tool sends to API validation endpoint and checks various items, but does not mention side effects, rate limits, or potential cost implications beyond token estimation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with headings and bullet points, concise, and contains no unnecessary information. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has no output schema, and the description does not explain the return values or response format. It adequately describes the validation checks but lacks completeness regarding output.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds value by specifying that the 'config' parameter comes from create_image_config or create_video_config, and clarifies that apiKey is optional if env var is set (though schema already notes optional).

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states that the tool validates a job configuration against the jsoncut API, checking schema compliance, resource availability, estimated token cost, and errors. It distinguishes itself from sibling tools (create_image_config, etc.) by being a validation step.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says when to use: only when the user has provided actual media file paths, not placeholder paths. It also advises to always call after creating a configuration when real file paths are available.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.4/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: two for image config/schema, two for video config/schema, and one for validation. No overlap in functionality.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern in snake_case (create_, get_, validate_), with parallelism between image and video tools.

Tool Count5/5

5 tools is well-scoped for the server's purpose of handling image and video configuration creation, schema retrieval, and validation. No extraneous tools.

Completeness4/5

Core workflow is covered: schema retrieval, config creation, and validation. Minor gaps include lack of a tool to submit jobs or manage existing configs, but these may be out of scope.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

studio
io.kaitoi
Build and run visual creative-production workflows from your AI agent.
AI & Machine Learning Design Tools App Automation
2
mcp A
online.editclips
Video, audio, and image processing for AI agents: convert, transcribe, upscale - 150+ operations.
Multimedia Processing Audio Processing Image & Video Processing
51
KinoPipe
io.github.nicolascoutureau
FFmpeg as a service for AI agents: typed video editing tools, async jobs, downloadable outputs.
Multimedia Processing Image & Video Processing
1
mcp A
io.github.pictify-io
Generate images, GIFs, and PDFs from HTML, URLs, or templates — from your AI agent.
Image & Video Processing Multimedia Processing
262

Related MCP Servers

JianYing MCP
Multimedia Processing App Automation
hey-jian-wei
F
license
A
quality
F
maintenance
Enables AI assistants to create and edit professional videos through natural language by automating JianYing (CapCut) video production workflows. Supports adding media segments, effects, transitions, animations, and exporting editable project files.
Updated a year ago (2025-08-22 09:55 UTC)
20
279
RendShot MCP Server
Image & Video Processing Design Tools App Automation
RendShotTeam
F
license
Not graded
quality
D
maintenance
Enables AI agents to generate images from HTML/CSS, capture URL screenshots, and manage reusable templates through the RendShot API. Provides tools for rendering visual content programmatically within AI workflows.
Updated 5 months ago (2026-04-15 03:25 UTC)
14
canvas3d-mcp
Games & Gamification Image & Video Processing
eduardosm123
F
license
A
quality
B
maintenance
Enables AI agents to create, render, and validate 3D scenes, 2D art, and games in HTML canvas using Three.js, WebGL, or Canvas 2D, with multi-angle screenshots, structured validation reports, and interactive playtesting.
Updated 3 months ago (2026-06-13 11:04 UTC)
5
Enhanced Multimedia Analysis
Image & Video Processing Multimedia Processing AI & Machine Learning
traikdude
A
license
Not graded
quality
D
maintenance
Enables AI agents to analyze images and videos, and generate optimized prompts for AI video generation systems.
Updated 10 months ago (2025-11-03 20:05 UTC)
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jsoncut/jsoncut-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

🚀 Features

📦 Quick Start

Using npx (Recommended for Local)

Using Remote Server (Recommended)

Using Docker Locally (Optional)

Get Your API Key

🎯 MCP Client Configuration

Remote Server (Recommended)

Cursor IDE

Claude Desktop

Local npx Mode

Cursor IDE

Claude Desktop

Local Docker Server

Cursor IDE

Claude Desktop

📚 MCP Resources

🛠️ Available Tools

create_image_config

create_video_config

validate_config

get_image_schema / get_video_schema

📖 Workflow

📁 File Paths

🧪 Testing

🔧 Development

Local Development

Configuration with Local Build

📝 Examples

🤝 Contributing

📄 License

🔗 Links

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

`create_image_config`

`create_video_config`

`validate_config`

`get_image_schema` / `get_video_schema`