siliconflow-image-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,605 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/services/siliconflow.ts
+import * as fs from "fs";
+import * as path from "path";
+var SiliconFlowService = class {
+  static {
+    __name(this, "SiliconFlowService");
+  }
+  apiKey;
+  baseUrl;
+  constructor(apiKey) {
+    if (!apiKey || apiKey.trim() === "") {
+      throw new Error("SiliconFlow API key is required");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = "https://api.siliconflow.cn/v1";
+  }
+  /**
+   * Make API call to SiliconFlow
+   */
+  async makeApiCall(endpoint, body) {
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error (${response.status}): ${errorText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Make GET API call to SiliconFlow
+   */
+  async makeGetCall(endpoint, params) {
+    const url = new URL(`${this.baseUrl}${endpoint}`);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error (${response.status}): ${errorText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Generate images using SiliconFlow's image generation models
+   */
+  async generateImage(prompt, model = "black-forest-labs/FLUX.1-dev", aspectRatio, imageSize, count = 1, negativePrompt, seed) {
+    try {
+      const requestBody = {
+        model,
+        prompt,
+        batch_size: Math.min(count, 4)
+        // SiliconFlow max is 4
+      };
+      if (aspectRatio || imageSize) {
+        requestBody.image_size = this.mapAspectRatioToSize(aspectRatio, imageSize, model);
+      }
+      if (negativePrompt) {
+        requestBody.negative_prompt = negativePrompt;
+      }
+      if (seed !== void 0) {
+        requestBody.seed = seed;
+      }
+      const result = await this.makeApiCall("/images/generations", requestBody);
+      if (!result.images || result.images.length === 0) {
+        throw new Error("No images were generated");
+      }
+      const images = [];
+      for (const img of result.images) {
+        const imageUrl = img.url;
+        const imageResponse = await fetch(imageUrl);
+        if (!imageResponse.ok) {
+          throw new Error(`Failed to download image: ${imageResponse.status}`);
+        }
+        const imageBuffer = await imageResponse.arrayBuffer();
+        const base64Data = Buffer.from(imageBuffer).toString("base64");
+        const mimeType = imageUrl.includes(".png") ? "image/png" : imageUrl.includes(".jpg") || imageUrl.includes(".jpeg") ? "image/jpeg" : "image/png";
+        images.push({
+          data: base64Data,
+          mimeType
+        });
+      }
+      return images;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Image generation failed: ${error.message}`);
+      }
+      throw new Error("Image generation failed with unknown error");
+    }
+  }
+  /**
+   * Edit an existing image using SiliconFlow
+   */
+  async editImage(image, prompt, model = "Qwen/Qwen-Image-Edit-2509") {
+    try {
+      let imageContent;
+      if (image.startsWith("data:image/")) {
+        imageContent = image;
+      } else if (image.startsWith("http://") || image.startsWith("https://")) {
+        imageContent = image;
+      } else if (fs.existsSync(image) && fs.statSync(image).isFile()) {
+        const imageBuffer2 = fs.readFileSync(image);
+        const base64Data2 = imageBuffer2.toString("base64");
+        const ext = path.extname(image).toLowerCase();
+        const mimeType2 = ext === ".png" ? "image/png" : ext === ".jpg" || ext === ".jpeg" ? "image/jpeg" : ext === ".webp" ? "image/webp" : "image/png";
+        imageContent = `data:${mimeType2};base64,${base64Data2}`;
+      } else {
+        imageContent = `data:image/png;base64,${image}`;
+      }
+      const requestBody = {
+        model,
+        prompt,
+        image: imageContent
+      };
+      const result = await this.makeApiCall("/images/generations", requestBody);
+      if (!result.images || result.images.length === 0) {
+        throw new Error("No edited image was returned");
+      }
+      const img = result.images[0];
+      const imageUrl = img.url;
+      const imageResponse = await fetch(imageUrl);
+      if (!imageResponse.ok) {
+        throw new Error(`Failed to download edited image: ${imageResponse.status}`);
+      }
+      const imageBuffer = await imageResponse.arrayBuffer();
+      const base64Data = Buffer.from(imageBuffer).toString("base64");
+      const mimeType = imageUrl.includes(".png") ? "image/png" : imageUrl.includes(".jpg") || imageUrl.includes(".jpeg") ? "image/jpeg" : "image/png";
+      return {
+        data: base64Data,
+        mimeType
+      };
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Image editing failed: ${error.message}`);
+      }
+      throw new Error("Image editing failed with unknown error");
+    }
+  }
+  /**
+   * List all available image generation models
+   */
+  async listImageModels() {
+    try {
+      const result = await this.makeGetCall("/models", { type: "image" });
+      if (!result.data || result.data.length === 0) {
+        return [];
+      }
+      const imageModels = result.data.filter((model) => {
+        const modelId = model.id.toLowerCase();
+        return modelId.includes("flux") || modelId.includes("sd") || modelId.includes("stable-diffusion") || modelId.includes("qwen-image") || modelId.includes("kolors") || modelId.includes("dall") || modelId.includes("painting");
+      }).map((model) => ({
+        id: model.id,
+        name: model.id,
+        description: `Image generation model: ${model.id}`,
+        output_modalities: ["image"]
+      }));
+      return imageModels;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to list models: ${error.message}`);
+      }
+      throw new Error("Failed to list models with unknown error");
+    }
+  }
+  /**
+   * Test the API key validity
+   */
+  async testConnection() {
+    try {
+      await this.makeGetCall("/models");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Map aspect ratio and image size to SiliconFlow's image_size format
+   */
+  mapAspectRatioToSize(aspectRatio, imageSize, model) {
+    if (model && model.includes("qwen")) {
+      const qwenSizes = {
+        "1:1": "1328x1328",
+        "16:9": "1664x928",
+        "9:16": "928x1664",
+        "4:3": "1472x1140",
+        "3:4": "1140x1472",
+        "3:2": "1584x1056",
+        "2:3": "1056x1584"
+      };
+      if (aspectRatio && qwenSizes[aspectRatio]) {
+        return qwenSizes[aspectRatio];
+      }
+    }
+    const kolorsSizes = {
+      "1:1": "1024x1024",
+      "3:4": "960x1280",
+      "4:3": "1280x960",
+      "1:2": "720x1440",
+      "9:16": "720x1280",
+      "16:9": "1280x720"
+    };
+    if (aspectRatio && kolorsSizes[aspectRatio]) {
+      return kolorsSizes[aspectRatio];
+    }
+    if (imageSize === "4K") return "2048x2048";
+    if (imageSize === "2K") return "1536x1536";
+    return "1024x1024";
+  }
+};
+
+// src/types/index.ts
+import { z } from "zod";
+var GenerateImageInputSchema = z.object({
+  prompt: z.string().min(1, "Prompt is required").max(2e3, "Prompt must be 2000 characters or less").describe("Detailed description of the image to generate"),
+  model: z.string().optional().describe("Model to use for generation (defaults to black-forest-labs/FLUX.1-dev)"),
+  aspectRatio: z.enum(["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"]).optional().describe("Aspect ratio for generated images"),
+  imageSize: z.enum(["1K", "2K", "4K"]).optional().describe("Image size (higher resolution)"),
+  count: z.number().int().min(1).max(4).optional().default(1).describe("Number of images to generate (1-4)"),
+  negativePrompt: z.string().optional().describe("Negative prompt - what to avoid in the image"),
+  seed: z.number().int().min(0).max(9999999999).optional().describe("Seed for reproducible results")
+});
+var EditImageInputSchema = z.object({
+  image: z.string().min(1, "Image data is required").describe("Base64 encoded image data, image URL, or local file path to edit"),
+  prompt: z.string().min(1, "Edit prompt is required").max(2e3, "Edit prompt must be 2000 characters or less").describe("Instructions for editing the image"),
+  model: z.string().optional().describe("Model to use for editing (defaults to Qwen/Qwen-Image-Edit-2509)")
+});
+var ListModelsInputSchema = z.object({});
+
+// src/utils/file.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import os from "os";
+function getImageBaseDir() {
+  const customDir = process.env.SILICONFLOW_IMAGE_DIR;
+  if (customDir) {
+    return customDir;
+  }
+  return path2.join(os.tmpdir(), "siliconflow-images");
+}
+__name(getImageBaseDir, "getImageBaseDir");
+async function saveImageToFile(base64Data, prefix, mimeType) {
+  const tempDir = getImageBaseDir();
+  await fs2.mkdir(tempDir, { recursive: true });
+  const extension = mimeType === "image/jpeg" ? "jpg" : "png";
+  const timestamp = Date.now();
+  const filename = `${prefix}_${timestamp}.${extension}`;
+  const filepath = path2.join(tempDir, filename);
+  const buffer = Buffer.from(base64Data, "base64");
+  await fs2.writeFile(filepath, buffer);
+  return filepath;
+}
+__name(saveImageToFile, "saveImageToFile");
+function getTempDir() {
+  return getImageBaseDir();
+}
+__name(getTempDir, "getTempDir");
+
+// src/tools/generate.ts
+function createGenerateImageTool(service) {
+  return {
+    name: "generate_image",
+    description: "Generate images using SiliconFlow's AI models. Supports various aspect ratios, image sizes, negative prompts, and seeds for reproducible results. Images are saved to temporary files and paths are returned.",
+    inputSchema: GenerateImageInputSchema,
+    handler: /* @__PURE__ */ __name(async (input) => {
+      const parsed = GenerateImageInputSchema.safeParse(input);
+      if (!parsed.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Invalid input: ${parsed.error.errors.map((e) => e.message).join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const { prompt, model, aspectRatio, imageSize, count, negativePrompt, seed } = parsed.data;
+      try {
+        const images = await service.generateImage(
+          prompt,
+          model || "black-forest-labs/FLUX.1-dev",
+          aspectRatio,
+          imageSize,
+          count,
+          negativePrompt,
+          seed
+        );
+        if (images.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No images were generated. Please try a different prompt."
+              }
+            ],
+            isError: true
+          };
+        }
+        const savedFiles = [];
+        for (let i = 0; i < images.length; i++) {
+          const img = images[i];
+          const filepath = await saveImageToFile(img.data, `generated_${i + 1}`, img.mimeType);
+          savedFiles.push(filepath);
+        }
+        const tempDir = getTempDir();
+        const response = {
+          content: [
+            {
+              type: "text",
+              text: `Successfully generated ${images.length} image${images.length > 1 ? "s" : ""} for prompt: "${prompt}"
+Saved to:
+${savedFiles.map((f) => `- ${f}`).join("\n")}
+
+Temporary directory: ${tempDir}
+Note: These are temporary files. Use the file paths to access the images.`
+            }
+          ]
+        };
+        return response;
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Image generation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }, "handler")
+  };
+}
+__name(createGenerateImageTool, "createGenerateImageTool");
+
+// src/tools/edit.ts
+function createEditImageTool(service) {
+  return {
+    name: "edit_image",
+    description: "Edit existing images using SiliconFlow's AI models. Accepts base64 encoded image data, image URLs, or local file paths. Provide instructions for modifications. Uses Qwen/Qwen-Image-Edit-2509 by default. Images are saved to temporary files and paths are returned.",
+    inputSchema: EditImageInputSchema,
+    handler: /* @__PURE__ */ __name(async (input) => {
+      const parsed = EditImageInputSchema.safeParse(input);
+      if (!parsed.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Invalid input: ${parsed.error.errors.map((e) => e.message).join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const { image, prompt, model } = parsed.data;
+      try {
+        const editedImage = await service.editImage(
+          image,
+          prompt,
+          model || "Qwen/Qwen-Image-Edit-2509"
+        );
+        const filepath = await saveImageToFile(editedImage.data, "edited", editedImage.mimeType);
+        const tempDir = getTempDir();
+        const response = {
+          content: [
+            {
+              type: "text",
+              text: `Successfully edited image with prompt: "${prompt}"
+Saved to: ${filepath}
+
+Temporary directory: ${tempDir}
+Note: This is a temporary file. Use the file path to access the image.`
+            }
+          ]
+        };
+        return response;
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Image editing failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }, "handler")
+  };
+}
+__name(createEditImageTool, "createEditImageTool");
+
+// src/tools/list-models.ts
+function createListModelsTool(service) {
+  return {
+    name: "list_image_models",
+    description: "List all available image generation models from SiliconFlow. Shows model IDs and capabilities.",
+    inputSchema: ListModelsInputSchema,
+    handler: /* @__PURE__ */ __name(async (input) => {
+      const parsed = ListModelsInputSchema.safeParse(input);
+      if (!parsed.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Invalid input: ${parsed.error.errors.map((e) => e.message).join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      try {
+        const models = await service.listImageModels();
+        if (models.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No image generation models found. This might be a temporary issue with the API."
+              }
+            ],
+            isError: true
+          };
+        }
+        const modelList = models.map((model, index) => {
+          const parts = [
+            `${index + 1}. **${model.name}** (\`${model.id}\`)`,
+            model.description ? `   - ${model.description}` : null,
+            model.output_modalities ? `   - Capabilities: ${model.output_modalities.join(", ")}` : null
+          ].filter(Boolean);
+          return parts.join("\n");
+        }).join("\n\n");
+        const usageTips = `
+
+---
+
+**Usage:** Use the \`generate_image\` tool with the model ID to generate images.
+
+**SiliconFlow Tips:**
+- Recommended models: \`black-forest-labs/FLUX.1-dev\` (generation), \`Qwen/Qwen-Image-Edit-2509\` (editing)
+- Supports advanced options: negative prompts, seeds, CFG values
+- Image sizes: Use aspect ratios like "1:1", "16:9", "9:16"
+- Optimized for China users with fast local network access`;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `## Available Image Generation Models (SiliconFlow)
+
+Found ${models.length} model${models.length > 1 ? "s" : ""} that support image generation:
+
+${modelList}${usageTips}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to list models: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }, "handler")
+  };
+}
+__name(createListModelsTool, "createListModelsTool");
+
+// src/index.ts
+if (process.argv.includes("--build")) {
+  console.log('\u2705 Project structure is ready. Use "npm start" to run the server.');
+  console.log("\u{1F4DD} Note: This project uses tsx for runtime execution.");
+  process.exit(0);
+}
+var SILICONFLOW_API_KEY = process.env.SILICONFLOW_API_KEY;
+var MOCK_MODE = process.env.SILICONFLOW_MOCK === "true";
+if (!SILICONFLOW_API_KEY && !MOCK_MODE) {
+  console.error("\u274C Error: SILICONFLOW_API_KEY environment variable is required");
+  console.error("\nTo use this MCP server:");
+  console.error("1. Get your API key from https://siliconflow.cn");
+  console.error("2. Set it as an environment variable:");
+  console.error("   export SILICONFLOW_API_KEY=your-api-key-here");
+  console.error("\nFor Claude Desktop, add to your config.json:");
+  console.error(`{
+  "mcpServers": {
+    "siliconflow-image-mcp": {
+      "command": "npx",
+      "args": ["-y", "siliconflow-image-mcp"],
+      "env": {
+        "SILICONFLOW_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}`);
+  console.error("\nOptional configurations:");
+  console.error("   export SILICONFLOW_MOCK=true          # Use mock mode for testing");
+  console.error("   export SILICONFLOW_IMAGE_DIR=/path    # Custom directory for saved images");
+  process.exit(1);
+}
+async function main() {
+  console.error("\u{1F680} Starting SiliconFlow Image MCP Server...");
+  try {
+    let siliconFlowService;
+    if (MOCK_MODE) {
+      console.error("\u26A0\uFE0F  Running in MOCK mode - API calls will be simulated");
+      siliconFlowService = {
+        generateImage: /* @__PURE__ */ __name(async () => [{ data: "mock-base64-data", mimeType: "image/png" }], "generateImage"),
+        editImage: /* @__PURE__ */ __name(async () => ({ data: "mock-base64-data", mimeType: "image/png" }), "editImage"),
+        listImageModels: /* @__PURE__ */ __name(async () => [
+          { id: "black-forest-labs/FLUX.1-dev", name: "FLUX.1-dev", description: "Mock model", output_modalities: ["image"] }
+        ], "listImageModels"),
+        testConnection: /* @__PURE__ */ __name(async () => true, "testConnection")
+      };
+    } else {
+      siliconFlowService = new SiliconFlowService(SILICONFLOW_API_KEY);
+      const isConnected = await siliconFlowService.testConnection();
+      if (!isConnected) {
+        console.error("\u274C Failed to connect to SiliconFlow. Please check your API key.");
+        process.exit(1);
+      }
+      console.error("\u2705 Connected to SiliconFlow successfully");
+    }
+    const server = new McpServer({
+      name: "siliconflow-image-mcp",
+      version: "1.0.0",
+      capabilities: {
+        tools: {
+          listChanged: true
+        }
+      }
+    });
+    const generateTool = createGenerateImageTool(siliconFlowService);
+    const editTool = createEditImageTool(siliconFlowService);
+    const listModelsTool = createListModelsTool(siliconFlowService);
+    server.registerTool(
+      generateTool.name,
+      {
+        description: generateTool.description,
+        inputSchema: generateTool.inputSchema
+      },
+      generateTool.handler
+    );
+    server.registerTool(
+      editTool.name,
+      {
+        description: editTool.description,
+        inputSchema: editTool.inputSchema
+      },
+      editTool.handler
+    );
+    server.registerTool(
+      listModelsTool.name,
+      {
+        description: listModelsTool.description,
+        inputSchema: listModelsTool.inputSchema
+      },
+      listModelsTool.handler
+    );
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("\u2705 SiliconFlow Image MCP Server is running");
+    console.error("\u{1F4CB} Available tools: generate_image, edit_image, list_image_models");
+    console.error("\u{1F4DD} Waiting for requests...");
+    process.on("SIGINT", async () => {
+      console.error("\n\u{1F6D1} Shutting down gracefully...");
+      await server.close();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("\u274C Failed to start server:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+__name(main, "main");
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map