MCP Flux Studio

Instructions

Implementation Reference

• src/index.ts:341-358 (handler)

  MCP tool handler for 'inpaint': validates InpaintArgs, builds command line arguments for the Python CLI, executes via runPythonCommand, and returns the output.

  case 'inpaint': {
      const args = request.params.arguments as InpaintArgs;
      // Validate required fields
      const image = this.validateRequiredString(args.image, 'image');
      const prompt = this.validateRequiredString(args.prompt, 'prompt');
  
      const cmdArgs = ['inpaint'];
      cmdArgs.push('--image', image);
      cmdArgs.push('--prompt', prompt);
      if (args.mask_shape) cmdArgs.push('--mask-shape', args.mask_shape);
      if (args.position) cmdArgs.push('--position', args.position);
      if (args.output) cmdArgs.push('--output', args.output);
  
      const output = await this.runPythonCommand(cmdArgs);
      return {
          content: [{ type: 'text', text: output }],
      };
  }

• src/index.ts:215-249 (registration)

  Registration of the 'inpaint' tool in the ListTools response, including name, description, and JSON input schema.

  {
      name: 'inpaint',
      description: 'Inpaint an image using a mask',
      inputSchema: {
          type: 'object',
          properties: {
              image: {
                  type: 'string',
                  description: 'Input image path',
              },
              prompt: {
                  type: 'string',
                  description: 'Text prompt for inpainting',
              },
              mask_shape: {
                  type: 'string',
                  description: 'Shape of the mask',
                  enum: ['circle', 'rectangle'],
                  default: 'circle',
              },
              position: {
                  type: 'string',
                  description: 'Position of the mask',
                  enum: ['center', 'ground'],
                  default: 'center',
              },
              output: {
                  type: 'string',
                  description: 'Output filename',
                  default: 'inpainted.jpg',
              },
          },
          required: ['image', 'prompt'],
      },
  },

• src/types.ts:63-69 (schema)

  TypeScript interface InpaintArgs defining the typed arguments for the inpaint tool handler.

  export interface InpaintArgs {
    image: string;
    prompt: string;
    mask_shape?: MaskShape;
    position?: MaskPosition;
    output?: string;
  }

• src/cli/fluxcli.py:160-193 (helper)

  Core implementation of inpainting in FluxAPI: creates procedural mask, encodes image and mask, submits to BFL API /v1/flux-pro-1.0-fill, polls and returns result URL.

  def inpaint(self, image_path: str, prompt: str, mask_shape: str = 'circle', position: str = 'center') -> Optional[str]:
      """Inpaint an image using a mask."""
      base_image = Image.open(image_path)
      mask = self.create_mask(base_image.size, shape=mask_shape, position=position)
      
      mask_path = 'temp_mask.jpg'
      mask.save(mask_path)
      
      payload = {
          "image": self.encode_image(image_path),
          "mask": self.encode_image(mask_path),
          "prompt": prompt,
          "steps": 50,
          "guidance": 60,
          "output_format": "jpeg",
          "safety_tolerance": 2
      }
      
      response = requests.post(
          f"{self.base_url}/v1/flux-pro-1.0-fill",
          json=payload,
          headers=self.headers
      )
      
      os.remove(mask_path)
      
      task_id = response.json().get('id')
      if not task_id:
          return None
          
      result = self.get_task_result(task_id)
      if result and result.get('result', {}).get('sample'):
          return result['result']['sample']
      return None

• src/cli/fluxcli.py:127-158 (helper)

  Supporting utility to create procedural mask image for inpainting based on shape ('circle'/'rectangle') and position ('center'/'ground').

  def create_mask(self, size: tuple, shape: str = 'rectangle', position: str = 'center') -> Image:
      """Create a mask for inpainting."""
      mask = Image.new('L', size, 0)
      draw = ImageDraw.Draw(mask)
      
      width, height = size
      
      if position == 'ground':
          horizon_y = height * 0.65
          y_start = horizon_y - (height * 0.05)
          points = [
              (0, y_start),
              (0, height),
              (width, height),
              (width, y_start)
          ]
          draw.polygon(points, fill=255)
      else:
          x1 = width * 0.25
          y1 = height * 0.25
          x2 = width * 0.75
          y2 = height * 0.75
          
          if shape == 'rectangle':
              draw.rectangle([x1, y1, x2, y2], fill=255)
          else:  # circle
              center = (width // 2, height // 2)
              radius = min(width, height) // 4
              draw.ellipse([center[0] - radius, center[1] - radius,
                           center[0] + radius, center[1] + radius], fill=255)
      
      return mask