fix: added

Dockerfile

@@ -1,19 +1,12 @@
-FROM python:3.11-slim
+FROM node:20-slim
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    git \
-    libgl1 \
-    libglib2.0-0 \
-    && rm -rf /var/lib/apt/lists/*
+COPY package.json .
+RUN npm install
 
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY app.py .
+COPY server.js .
 
 EXPOSE 7860
 
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["node", "server.js"]

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "imgvlm",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "next",
+    "express": "^4.21.0",
+    "multer": "^1.4.5-lts.1",
+    "swagger-ui-express": "^5.0.0"
+  }
+}

server.js

@@ -0,0 +1,193 @@
+import express from "express";
+import multer from "multer";
+import swaggerUi from "swagger-ui-express";
+import {
+  AutoProcessor,
+  Qwen3_5ForConditionalGeneration,
+  RawImage,
+} from "@huggingface/transformers";
+
+const app = express();
+const upload = multer({ storage: multer.memoryStorage() });
+const PORT = 7860;
+const MODEL_ID = "huggingworld/Qwen3.5-0.8B-ONNX";
+
+let model = null;
+let processor = null;
+
+async function loadModel() {
+  console.log(`Loading model ${MODEL_ID}...`);
+  processor = await AutoProcessor.from_pretrained(MODEL_ID);
+  model = await Qwen3_5ForConditionalGeneration.from_pretrained(MODEL_ID, {
+    dtype: {
+      embed_tokens: "q4",
+      vision_encoder: "fp16",
+      decoder_model_merged: "q4",
+    },
+  });
+  console.log("Model loaded successfully.");
+}
+
+async function runInference(imageBuffer, prompt, maxTokens) {
+  const blob = new Blob([imageBuffer]);
+  const image = await (await RawImage.fromBlob(blob)).resize(448, 448);
+
+  const conversation = [
+    {
+      role: "user",
+      content: [
+        { type: "image" },
+        { type: "text", text: prompt },
+      ],
+    },
+  ];
+
+  const text = processor.apply_chat_template(conversation, {
+    add_generation_prompt: true,
+  });
+
+  const inputs = await processor(text, image);
+  const output = await model.generate({
+    ...inputs,
+    max_new_tokens: maxTokens,
+  });
+
+  const promptLength = inputs.input_ids.dims.at(-1);
+  const decoded = processor.batch_decode(
+    output.slice(null, [promptLength, null]),
+    { skip_special_tokens: true },
+  );
+  return decoded[0];
+}
+
+const swaggerDoc = {
+  openapi: "3.0.0",
+  info: {
+    title: "Qwen3.5-0.8B Vision API (ONNX)",
+    version: "1.0.0",
+    description: "Vision-language model API using Qwen3.5-0.8B ONNX with transformers.js",
+  },
+  paths: {
+    "/": {
+      get: {
+        summary: "Root",
+        responses: { 200: { description: "API status" } },
+      },
+    },
+    "/health": {
+      get: {
+        summary: "Health check",
+        responses: { 200: { description: "Model load status" } },
+      },
+    },
+    "/inference": {
+      post: {
+        summary: "Image inference (multipart upload)",
+        requestBody: {
+          required: true,
+          content: {
+            "multipart/form-data": {
+              schema: {
+                type: "object",
+                required: ["file"],
+                properties: {
+                  file: { type: "string", format: "binary", description: "Image file" },
+                  prompt: { type: "string", default: "Describe this image in detail." },
+                  max_tokens: { type: "integer", default: 512 },
+                },
+              },
+            },
+          },
+        },
+        responses: {
+          200: { description: "Inference result" },
+          400: { description: "Invalid input" },
+          503: { description: "Model not loaded" },
+        },
+      },
+    },
+    "/inference/base64": {
+      post: {
+        summary: "Image inference (base64)",
+        requestBody: {
+          required: true,
+          content: {
+            "application/x-www-form-urlencoded": {
+              schema: {
+                type: "object",
+                required: ["image_base64"],
+                properties: {
+                  image_base64: { type: "string", description: "Base64 encoded image" },
+                  prompt: { type: "string", default: "Describe this image in detail." },
+                  max_tokens: { type: "integer", default: 512 },
+                },
+              },
+            },
+          },
+        },
+        responses: {
+          200: { description: "Inference result" },
+          400: { description: "Invalid input" },
+          503: { description: "Model not loaded" },
+        },
+      },
+    },
+  },
+};
+
+app.use("/docs", swaggerUi.serve, swaggerUi.setup(swaggerDoc));
+
+app.get("/", (_req, res) => {
+  res.json({ status: "ok", model: MODEL_ID });
+});
+
+app.get("/health", (_req, res) => {
+  res.json({ status: "healthy", model_loaded: model !== null });
+});
+
+app.post("/inference", upload.single("file"), async (req, res) => {
+  if (!model || !processor) {
+    return res.status(503).json({ detail: "Model not loaded yet." });
+  }
+  if (!req.file) {
+    return res.status(400).json({ detail: "No image file provided." });
+  }
+
+  const prompt = req.body.prompt || "Describe this image in detail.";
+  const maxTokens = parseInt(req.body.max_tokens) || 512;
+
+  try {
+    const response = await runInference(req.file.buffer, prompt, maxTokens);
+    res.json({ response });
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ detail: "Inference failed.", error: err.message });
+  }
+});
+
+app.post("/inference/base64", express.urlencoded({ extended: true, limit: "50mb" }), async (req, res) => {
+  if (!model || !processor) {
+    return res.status(503).json({ detail: "Model not loaded yet." });
+  }
+  if (!req.body.image_base64) {
+    return res.status(400).json({ detail: "No base64 image provided." });
+  }
+
+  const prompt = req.body.prompt || "Describe this image in detail.";
+  const maxTokens = parseInt(req.body.max_tokens) || 512;
+
+  try {
+    const imageBuffer = Buffer.from(req.body.image_base64, "base64");
+    const response = await runInference(imageBuffer, prompt, maxTokens);
+    res.json({ response });
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ detail: "Inference failed.", error: err.message });
+  }
+});
+
+loadModel().then(() => {
+  app.listen(PORT, "0.0.0.0", () => {
+    console.log(`Server running on http://0.0.0.0:${PORT}`);
+  });
+});