Recraft AI MCP Server

Instructions

Implementation Reference

• src/tools/GenerateImage.ts:29-67 (handler)

  The main execution logic for the generate_image tool: validates input args with Zod, calls the Recraft API to generate image, handles errors, and transforms response using helper.

  export const generateImageHandler = async (server: RecraftServer, args: Record<string, unknown>): Promise<CallToolResult> => {
    try {
      const { prompt, size, style, styleID, substyle, model, numberOfImages } = z.object({
        prompt: z.string(),
        size: z.nativeEnum(ImageSize).optional(),
        style: z.nativeEnum(ImageStyle).optional(),
        substyle: z.nativeEnum(ImageSubStyle).optional(),
        styleID: z.string().optional(),
        model: z.nativeEnum(TransformModel).optional(),
        numberOfImages: z.number().min(1).max(6).optional()
      }).parse(args)
  
      const result = await server.api.imageApi.generateImage({
        generateImageRequest: {
          prompt: prompt,
          size: size,
          style: styleID ? undefined : style,
          substyle: styleID ? undefined : substyle,
          styleId: styleID,
          model: model,
          responseFormat: 'url',
          n: numberOfImages,
          expire: server.isLocalResultsStorage,
        }
      })
  
      return await server.transformGenerateImageResponseToCallToolResult(result)
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error generating image: ${error}`
          }
        ],
        isError: true
      }
    }
  }

• src/tools/GenerateImage.ts:7-27 (schema)

  Tool metadata definition including name, description, and inputSchema (JSON Schema) for validation of tool parameters like prompt (required), size, style, etc.

  export const generateImageTool = {
    name: "generate_image",
    description: "Generate an image using Recraft from a text prompt.\n" +
        "You can specify the image size, style, model, and number of images to generate.\n" +
        "You don't need to change default parameters if you don't have any specific requirements.\n" +
        "You can use styles to refine the image generation, and also to generate raster or vector images.\n" +
        "Local paths or URLs to generated images and their previews will be returned in the response.",
    inputSchema: {
      type: "object",
      properties: {
        prompt: PARAMETERS.promptSimple,
        size: PARAMETERS.imageSize,
        style: PARAMETERS.imageStyle,
        substyle: PARAMETERS.imageSubStyle,
        styleID: PARAMETERS.imageStyleID,
        model: PARAMETERS.transformModel,
        numberOfImages: PARAMETERS.numberOfImages,
      },
      required: ["prompt"]
    }
  }

• src/index.ts:68-82 (registration)

  Registers the generate_image tool (via generateImageTool) in the list of available tools for ListTools requests.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        generateImageTool,
        createStyleTool,
        vectorizeImageTool,
        imageToImageTool,
        removeBackgroundTool,
        replaceBackgroundTool,
        crispUpscaleTool,
        creativeUpscaleTool,
        getUserTool,
      ],
    }
  })

• src/index.ts:102-103 (registration)

  In the CallTool request handler switch, dispatches to generateImageHandler when tool name is 'generate_image'.

  case generateImageTool.name:
    return await generateImageHandler(recraftServer, args ?? {})

• src/RecraftServer.ts:32-54 (helper)

  Helper method to transform API GenerateImageResponse into MCP CallToolResult by downloading images, generating previews, and formatting the content block.

  transformGenerateImageResponseToCallToolResult = async (result: GenerateImageResponse): Promise<CallToolResult> => {
    const {downloadedImages: images, previews} = await downloadImagesAndMakePreviews(this.imageStorageDirectory, result.data)
  
    const pathOrUrlDesc = this.isLocalResultsStorage ? 'path' : 'URL'
  
    const ending = `${images.length === 1 ? '' : 's'}`
    const message = `Generated ${images.length} image${ending}.\n` +
     `Original image${ending} ${images.length === 1 ? 'is' : 'are'} saved to:\n${images.map(({pathOrUrl}) => `- ${pathOrUrl}`).join('\n')}` +
     `\nBelow you can see lower quality preview${ending} of generated image${ending}.` +
     `${previews.length < images.length ? `\nNote: last ${images.length - previews.length} images are not shown due to message limit, but you can still find them by given ${pathOrUrlDesc}s.` : ''}`
  
    const content = []
    content.push({
      type: 'text',
      text: message,
    })
    content.push(...previews)
  
    return {
      content: content,
      isError: false
    } as CallToolResult
  }