Skip to main content
Glama
duke0317

Image Processing MCP Server

by duke0317

adjust_gamma

Adjust image brightness and contrast by modifying gamma values to correct exposure or enhance visual details in digital images.

Instructions

调整图片伽马值

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
image_sourceYes图片源,可以是文件路径或base64编码的图片数据
gammaYes伽马值,1.0为原始,>1.0变亮,<1.0变暗

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
resultYes

Implementation Reference

  • Core handler function implementing the gamma adjustment logic. Validates inputs, loads image using ImageProcessor, applies gamma correction via lookup table and PIL's point() method for RGB/L/ other modes, processes output, and returns JSON result.
    async def adjust_gamma(image_source: str, gamma: float) -> list[TextContent]:
        """
        调整图片伽马值
        
        Args:
            image_source: 图片数据(base64编码)或文件路径
            gamma: 伽马值(0.1-3.0)
            
        Returns:
            调整后的图片数据
        """
        try:
            # 验证参数
            if not image_source:
                raise ValidationError("图片数据不能为空")
            
            if not validate_numeric_range(gamma, 0.1, 3.0):
                raise ValidationError(f"伽马值必须在0.1-3.0范围内: {gamma}")
            
            # 加载图片
            image = processor.load_image(image_source)
            
            # 创建伽马校正查找表
            gamma_table = [int(((i / 255.0) ** (1.0 / gamma)) * 255) for i in range(256)]
            
            # 应用伽马校正
            if image.mode == 'RGB':
                # 对RGB图片分别处理每个通道
                r, g, b = image.split()
                r = r.point(gamma_table)
                g = g.point(gamma_table)
                b = b.point(gamma_table)
                gamma_image = Image.merge('RGB', (r, g, b))
            elif image.mode == 'L':
                # 对灰度图直接处理
                gamma_image = image.point(gamma_table)
            else:
                # 其他模式先转换为RGB
                rgb_image = image.convert('RGB')
                r, g, b = rgb_image.split()
                r = r.point(gamma_table)
                g = g.point(gamma_table)
                b = b.point(gamma_table)
                gamma_image = Image.merge('RGB', (r, g, b))
            
            # 输出处理后的图片
            output_info = processor.output_image(gamma_image, "gamma")
            
            result = {
                "success": True,
                "message": f"伽马调整成功: 伽马值 {gamma}",
                "data": {
                    **output_info,
                    "gamma_value": gamma,
                    "original_mode": image.mode,
                    "size": image.size
                }
            }
            
            return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
            
        except ValidationError as e:
            error_result = {
                "success": False,
                "error": f"参数验证失败: {str(e)}"
            }
            return [TextContent(type="text", text=json.dumps(error_result, ensure_ascii=False))]
            
        except Exception as e:
            error_result = {
                "success": False,
                "error": f"伽马调整失败: {str(e)}"
            }
            return [TextContent(type="text", text=json.dumps(error_result, ensure_ascii=False))]
  • main.py:458-472 (registration)
    Tool registration via @mcp.tool() decorator in FastMCP server. Defines input schema using Pydantic Annotated fields and provides a synchronous wrapper that calls the async handler from color_adjust module using safe_run_async.
    @mcp.tool()
    def adjust_gamma(
        image_source: Annotated[str, Field(description="图片源,可以是文件路径或base64编码的图片数据")],
        gamma: Annotated[float, Field(description="伽马值,1.0为原始,>1.0变亮,<1.0变暗", gt=0)]
    ) -> str:
        """调整图片伽马值"""
        try:
            result = safe_run_async(color_adjust_gamma(image_source, gamma))
            return result[0].text
        except Exception as e:
            return json.dumps({
                "success": False,
                "error": f"调整伽马值失败: {str(e)}"
            }, ensure_ascii=False, indent=2)
  • Explicit Tool schema definition for adjust_gamma in get_color_adjust_tools(), matching the registered input parameters (though not directly used in MCP registration).
    Tool(
        name="adjust_gamma",
        description="调整图片伽马值",
        inputSchema={
            "type": "object",
            "properties": {
                "image_source": {
                    "type": "string",
                    "description": "图片数据(base64编码)或文件路径"
                },
                "gamma": {
                    "type": "number",
                    "description": "伽马值(0.1-3.0,1.0为原始值)",
                    "minimum": 0.1,
                    "maximum": 3.0
                }
            },
            "required": ["image_source", "gamma"]
        }
    ),
Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the action ('adjust') but doesn't describe what happens to the image (e.g., whether it modifies the original or creates a new image), output format, error conditions, or performance implications. This is inadequate for a mutation tool with zero annotation coverage.

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 a single, efficient phrase ('调整图片伽马值') that directly states the tool's purpose with zero wasted words. It is appropriately sized and front-loaded, making it easy to parse quickly.

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?

Given the tool has an output schema (which covers return values), 100% schema description coverage, and no annotations, the description is minimally complete for a simple image adjustment tool. However, it lacks behavioral context (e.g., mutation effects) and usage guidance, leaving gaps that could hinder an agent's understanding.

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

Parameters3/5

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

Schema description coverage is 100%, so the schema fully documents both parameters (image_source and gamma). The description adds no additional parameter information beyond what's in the schema, such as format details or examples. Baseline 3 is appropriate when the schema does all the work.

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

Purpose4/5

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

The description '调整图片伽马值' (adjust image gamma value) clearly states the verb ('adjust') and resource ('image gamma value'), making the purpose immediately understandable. It distinguishes from siblings like adjust_brightness or adjust_contrast by specifying gamma adjustment, though it doesn't explicitly contrast with them in the description text.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives like adjust_brightness or adjust_contrast, nor does it mention prerequisites or typical use cases. It states what the tool does but not when it's appropriate.

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

Install Server

Other Tools

Latest Blog Posts

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/duke0317/ps-mcp'

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