nvidia-nim-mcp 2.0.0 → 2.1.0

package/dist/client.d.ts

@@ -153,6 +153,21 @@ export declare class NIMClient {
     embeddings(request: EmbeddingRequest): Promise<EmbeddingResponse>;
     rerank(request: RerankRequest): Promise<RerankResponse>;
     generateImage(request: ImageGenerationRequest): Promise<ImageGenerationResponse>;
+    generateImageFluxSchnell(request: {
+        prompt: string;
+        width?: number;
+        height?: number;
+        seed?: number;
+        steps?: number;
+    }): Promise<ImageGenerationResponse>;
+    generateImageFluxKontext(request: {
+        prompt: string;
+        image: string;
+        aspect_ratio?: string;
+        steps?: number;
+        cfg_scale?: number;
+        seed?: number;
+    }): Promise<ImageGenerationResponse>;
     analyzeImage(request: ImageAnalysisRequest): Promise<ChatCompletionResponse>;
     listModels(): Promise<string[]>;
 }

package/dist/client.js

@@ -96,8 +96,13 @@ export class NIMClient {
             return new Error(`Authentication failed: ${apiMsg}`);
         if (status === 403)
             return new Error(`Authorization failed: ${apiMsg}`);
-        if (status === 404)
-            return new Error(`Model not found: ${apiMsg}`);
+        if (status === 404) {
+            const msg = `Model not found: ${apiMsg}. ` +
+                `Note: Image generation models (SDXL, FLUX, SD3) are not deployed on the free integration endpoint. ` +
+                `They require dedicated GPU instances (H100/B200). ` +
+                `Use a self-hosted NIM or check https://build.nvidia.com for available models.`;
+            return new Error(msg);
+        }
         if (status === 422)
             return new Error(`Invalid request: ${apiMsg}`);
         if (status === 429)
@@ -144,6 +149,91 @@ export class NIMClient {
         });
         return data;
     }
+    // ─── FLUX.1-schnell (AI Foundation Models) ──────────────────────────────────
+    async generateImageFluxSchnell(request) {
+        await this.httpClient.rateLimiter.acquire();
+        const payload = {
+            prompt: request.prompt,
+            width: request.width ?? 1024,
+            height: request.height ?? 1024,
+            seed: request.seed ?? 0,
+            steps: 4, // FLUX Schnell is fixed at 4 steps
+        };
+        const modelId = config.DEFAULT_FLUX_SCHNELL_MODEL;
+        const url = `${config.NVIDIA_AI_FOUNDATION_URL}/${modelId}`;
+        logger.debug("FLUX Schnell request", { prompt: request.prompt, width: payload.width, height: payload.height });
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${config.NVIDIA_API_KEY}`,
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(config.IMAGE_GENERATION_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.error("FLUX Schnell API error", { status: response.status, error: errorText });
+            throw new Error(`FLUX Schnell API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        logger.debug("FLUX Schnell response", { keys: Object.keys(data), hasImages: !!data.images, hasImage: !!data.image, hasData: !!data.data, hasArtifacts: !!data.artifacts, dataType: typeof data.data, imagesType: typeof data.images });
+        // Handle different response formats
+        const images = data.images ?? data.data ?? data.artifacts ?? (data.image ? [data.image] : []);
+        return {
+            created: Date.now(),
+            model: modelId,
+            data: images.map((img) => ({
+                b64_json: img.b64_json ?? img.base64,
+                revised_prompt: request.prompt,
+            })),
+            usage: { total_images: images.length },
+        };
+    }
+    // ─── FLUX.1-kontext-dev (AI Foundation Models) ──────────────────────────────
+    async generateImageFluxKontext(request) {
+        await this.httpClient.rateLimiter.acquire();
+        const payload = {
+            prompt: request.prompt,
+            image: request.image,
+            aspect_ratio: request.aspect_ratio ?? "match_input_image",
+            steps: request.steps ?? 30,
+            cfg_scale: request.cfg_scale ?? 3.5,
+            seed: request.seed ?? 0,
+        };
+        const modelId = config.DEFAULT_FLUX_KONTEXT_MODEL;
+        const url = `${config.NVIDIA_AI_FOUNDATION_URL}/${modelId}`;
+        logger.debug("FLUX Kontext request", { prompt: request.prompt, aspect_ratio: payload.aspect_ratio, steps: payload.steps });
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${config.NVIDIA_API_KEY}`,
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(config.IMAGE_GENERATION_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.error("FLUX Kontext API error", { status: response.status, error: errorText });
+            throw new Error(`FLUX Kontext API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        logger.debug("FLUX Kontext response", { keys: Object.keys(data), hasImages: !!data.images, hasImage: !!data.image, hasData: !!data.data, hasArtifacts: !!data.artifacts });
+        // Handle different response formats
+        const images = data.images ?? data.data ?? data.artifacts ?? (data.image ? [data.image] : []);
+        return {
+            created: Date.now(),
+            model: modelId,
+            data: images.map((img) => ({
+                b64_json: img.b64_json ?? img.base64,
+                revised_prompt: request.prompt,
+            })),
+            usage: { total_images: images.length },
+        };
+    }
     async analyzeImage(request) {
         await this.httpClient.rateLimiter.acquire();
         const payload = {

package/dist/config.d.ts

@@ -4,6 +4,7 @@ export declare class ConfigError extends Error {
 export declare function getConfig(): {
     NVIDIA_API_KEY?: string;
     NVIDIA_NIM_BASE_URL?: string;
+    NVIDIA_AI_FOUNDATION_URL?: string;
     MCP_SERVER_NAME?: string;
     MCP_SERVER_VERSION?: string;
     MCP_SERVER_PORT?: number;
@@ -18,6 +19,8 @@ export declare function getConfig(): {
     DEFAULT_TOP_P?: number;
     DEFAULT_MAX_TOKENS?: number;
     DEFAULT_IMAGE_MODEL?: string;
+    DEFAULT_FLUX_SCHNELL_MODEL?: string;
+    DEFAULT_FLUX_KONTEXT_MODEL?: string;
     IMAGE_GENERATION_TIMEOUT_MS?: number;
     ENABLE_IMAGE_GENERATION?: boolean;
     ENABLE_VISION?: boolean;

package/dist/config.js

@@ -1,11 +1,16 @@
 import { z } from "zod";
 const ConfigSchema = z.object({
-    // NVIDIA API - Primary connection
+    // NVIDIA API - Primary connection (self-hosted NIM)
     NVIDIA_API_KEY: z.string().min(1, "NVIDIA_API_KEY is required"),
     NVIDIA_NIM_BASE_URL: z
         .string()
         .url()
         .default("https://integrate.api.nvidia.com/v1"),
+    // NVIDIA AI Foundation Models (cloud, free tier available)
+    NVIDIA_AI_FOUNDATION_URL: z
+        .string()
+        .url()
+        .default("https://ai.api.nvidia.com/v1/genai"),
     // Server
     MCP_SERVER_NAME: z.string().default("nvidia-nim-mcp"),
     MCP_SERVER_VERSION: z.string().default("1.0.0"),
@@ -21,12 +26,14 @@ const ConfigSchema = z.object({
     MAX_RETRIES: z.coerce.number().int().min(0).max(10).default(3),
     RETRY_DELAY_MS: z.coerce.number().int().positive().default(1000),
     // Defaults
-    DEFAULT_MODEL: z.string().default("z-ai/glm5"),
+    DEFAULT_MODEL: z.string().default("meta/llama-3.1-8b-instruct"),
     DEFAULT_TEMPERATURE: z.coerce.number().min(0).max(2).default(0.3),
     DEFAULT_TOP_P: z.coerce.number().min(0).max(1).default(0.95),
     DEFAULT_MAX_TOKENS: z.coerce.number().int().positive().default(4096),
-    // Image Generation
-    DEFAULT_IMAGE_MODEL: z.string().default("black-forest-labs/flux.1-dev"),
+    // Image Generation - AI Foundation Models (free tier available)
+    DEFAULT_IMAGE_MODEL: z.string().default("black-forest-labs/flux.1-schnell"),
+    DEFAULT_FLUX_SCHNELL_MODEL: z.string().default("black-forest-labs/flux.1-schnell"),
+    DEFAULT_FLUX_KONTEXT_MODEL: z.string().default("black-forest-labs/flux.1-kontext-dev"),
     IMAGE_GENERATION_TIMEOUT_MS: z.coerce.number().int().positive().default(300000),
     // Feature flags
     ENABLE_IMAGE_GENERATION: z.coerce.boolean().default(true),

package/dist/handlers.js

@@ -2,6 +2,9 @@ import { NIM_MODELS, getModelsByCategory, getModel } from "./models.js";
 import { getConfig } from "./config.js";
 import { logger } from "./logger.js";
 import { ChatCompletionSchema, TextGenerationSchema, EmbeddingsSchema, RerankSchema, FunctionCallingSchema, ListModelsSchema, ModelInfoSchema, ImageGenerationSchema, ImageAnalysisSchema, MultimodalTaskSchema, CompareModelsSchema, } from "./tools.js";
+import { z } from "zod";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname, resolve } from "path";
 const config = getConfig();
 function ok(data) {
     return {
@@ -14,6 +17,42 @@ function err(message) {
         isError: true,
     };
 }
+// Extended schema for FLUX Kontext (image-to-image)
+const FluxKontextSchema = ImageGenerationSchema.extend({
+    image: z.string().optional().describe("Base64 data URL of input image (required for FLUX Kontext)"),
+    aspect_ratio: z.string().optional().describe("Aspect ratio for output (e.g., 'match_input_image', '1:1', '16:9')"),
+    // File save options
+    save_path: z.string().optional().describe("Optional file path to save the generated image as PNG (e.g., './output/image.png' or '/absolute/path/image.png')"),
+    save_filename: z.string().optional().describe("Optional filename (without extension) to auto-generate path in current directory"),
+});
+// Helper function to save base64 image as PNG file
+function saveBase64Image(base64, savePath, saveFilename) {
+    if (!savePath && !saveFilename) {
+        return null;
+    }
+    let filePath;
+    if (savePath) {
+        filePath = resolve(savePath);
+    }
+    else {
+        const timestamp = Date.now();
+        const filename = `${saveFilename || `generated_${timestamp}`}.png`;
+        filePath = resolve(process.cwd(), filename);
+    }
+    // Ensure directory exists
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    // Remove data URL prefix if present
+    const base64Data = base64.replace(/^data:image\/[a-z]+;base64,/, "");
+    const buffer = Buffer.from(base64Data, "base64");
+    writeFileSync(filePath, buffer);
+    return {
+        path: filePath,
+        absolutePath: filePath,
+    };
+}
 export class ToolHandlers {
     client;
     constructor(client) {
@@ -217,6 +256,69 @@ export class ToolHandlers {
         }
         const args = ImageGenerationSchema.parse(rawArgs);
         const model = args.model ?? config.DEFAULT_IMAGE_MODEL;
+        // Route to appropriate backend based on model
+        const isFluxSchnell = model === "black-forest-labs/flux.1-schnell" || model === config.DEFAULT_FLUX_SCHNELL_MODEL;
+        const isFluxKontext = model === "black-forest-labs/flux.1-kontext-dev" || model === config.DEFAULT_FLUX_KONTEXT_MODEL;
+        // FLUX.1-schnell: Fast text-to-image via AI Foundation
+        if (isFluxSchnell) {
+            const fluxArgs = FluxKontextSchema.parse(rawArgs); // Reuse schema, image is optional
+            const response = await this.client.generateImageFluxSchnell({
+                prompt: fluxArgs.prompt,
+                width: fluxArgs.width,
+                height: fluxArgs.height,
+                seed: fluxArgs.seed,
+            });
+            const images = response.data.map((img, idx) => {
+                const saved = saveBase64Image(img.b64_json, fluxArgs.save_path, fluxArgs.save_filename);
+                return {
+                    index: idx,
+                    b64_json: img.b64_json,
+                    revised_prompt: img.revised_prompt,
+                    saved_path: saved?.absolutePath,
+                };
+            });
+            return ok({
+                model: response.model,
+                created: response.created,
+                images,
+                usage: response.usage,
+            });
+        }
+        // FLUX.1-kontext-dev: Image-to-image editing via AI Foundation
+        if (isFluxKontext) {
+            const fluxArgs = FluxKontextSchema.parse(rawArgs);
+            if (!fluxArgs.image) {
+                return err("FLUX Kontext requires an 'image' parameter (base64 data URL of input image)");
+            }
+            const response = await this.client.generateImageFluxKontext({
+                prompt: fluxArgs.prompt,
+                image: fluxArgs.image,
+                aspect_ratio: fluxArgs.aspect_ratio,
+                steps: fluxArgs.steps,
+                cfg_scale: fluxArgs.cfg_scale,
+                seed: fluxArgs.seed,
+            });
+            const images = response.data.map((img, idx) => {
+                const saved = saveBase64Image(img.b64_json, fluxArgs.save_path, fluxArgs.save_filename);
+                return {
+                    index: idx,
+                    b64_json: img.b64_json,
+                    revised_prompt: img.revised_prompt,
+                    saved_path: saved?.absolutePath,
+                };
+            });
+            return ok({
+                model: response.model,
+                created: response.created,
+                images,
+                usage: response.usage,
+            });
+        }
+        // Self-hosted NIM (SDXL, SD3, flux.1-dev, etc.)
+        if (!config.DEFAULT_IMAGE_MODEL && !args.model) {
+            return err("No default image generation model configured for self-hosted NIM. " +
+                "Set DEFAULT_IMAGE_MODEL or specify a model explicitly.");
+        }
         const request = {
             model,
             prompt: args.prompt,
@@ -229,18 +331,23 @@ export class ToolHandlers {
             seed: args.seed,
             sampler: args.sampler,
             scheduler: args.scheduler,
-            response_format: args.response_format,
+            response_format: args.response_format ?? "b64_json",
         };
         const response = await this.client.generateImage(request);
-        return ok({
-            model: response.model ?? model,
-            created: response.created,
-            images: response.data.map((img, idx) => ({
+        const images = response.data.map((img, idx) => {
+            const saved = saveBase64Image(img.b64_json ?? "", args.save_path, args.save_filename);
+            return {
                 index: idx,
                 url: img.url,
                 b64_json: img.b64_json,
                 revised_prompt: img.revised_prompt,
-            })),
+                saved_path: saved?.absolutePath,
+            };
+        });
+        return ok({
+            model: response.model ?? model,
+            created: response.created,
+            images,
             usage: response.usage,
         });
     }

package/dist/logger.js

@@ -10,7 +10,7 @@ export let logger = winston.createLogger({
     },
     transports: [
         new winston.transports.Console({
-            stderrLevels: ["error", "warn"],
+            stderrLevels: ["error", "warn", "info", "debug", "silly"],
         }),
     ],
 });
@@ -27,7 +27,7 @@ export function initLogger(options) {
         },
         transports: [
             new winston.transports.Console({
-                stderrLevels: ["error", "warn"],
+                stderrLevels: ["error", "warn", "info", "debug", "silly"],
             }),
         ],
     });

package/dist/models.js

@@ -976,10 +976,49 @@ export const NIM_MODELS = {
         },
         tags: ["text-to-image", "photorealistic", "flux", "controlnet", "controlnet-canny", "controlnet-depth"],
     },
+    // === FLUX.1 AI Foundation Models (Free Tier) ===
+    "black-forest-labs/flux.1-schnell": {
+        id: "black-forest-labs/flux.1-schnell",
+        name: "FLUX.1 [schnell]",
+        description: "Fast text-to-image model (4 steps, distilled). Optimized for speed. Available on NVIDIA AI Foundation free tier.",
+        category: "image_generation",
+        contextLength: 512,
+        supportsStreaming: false,
+        supportsFunctionCalling: false,
+        supportsImageGeneration: true,
+        maxTokens: 512,
+        recommendedUseCases: [
+            "Fast text-to-image generation",
+            "Rapid prototyping",
+            "Real-time applications",
+            "Interactive image generation",
+        ],
+        license: "Apache 2.0 (non-commercial default, commercial via contact)",
+        commercialUse: false,
+        thirdPartyModel: true,
+        minGpuRequirements: ["N/A - Cloud API"],
+        supportedHardware: ["Cloud"],
+        runtimeEngines: ["NVIDIA AI Foundation"],
+        imageGenSpecs: {
+            supportedResolutions: ["1024x1024", "1152x896", "896x1152", "1344x768", "768x1344"],
+            supportedAspectRatios: ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21"],
+            maxImagesPerRequest: 1,
+            recommendedSamplers: ["euler"],
+            recommendedSchedulers: ["simple"],
+            defaultSteps: 4,
+            defaultCfgScale: 1.0,
+            supportsNegativePrompt: false,
+            supportsImageToImage: false,
+            supportsInpainting: false,
+            supportsControlNet: false,
+        },
+        tags: ["text-to-image", "fast", "schnell", "flux", "free-tier", "distilled"],
+        deploymentNotes: "Available via NVIDIA AI Foundation Models API (https://ai.api.nvidia.com/v1/genai/black-forest-labs/flux.1-schnell). 4-step distilled model for rapid generation.",
+    },
     "black-forest-labs/flux.1-kontext-dev": {
         id: "black-forest-labs/flux.1-kontext-dev",
         name: "FLUX.1 Kontext [dev]",
-        description: "FLUX.1 variant for image-to-image editing with context preservation. Supports inpainting, outpainting, style transfer with layout preservation.",
+        description: "Image-to-image editing with context preservation. Inpainting, outpainting, style transfer with layout preservation. Available on NVIDIA AI Foundation free tier.",
         category: "image_generation",
         contextLength: 512,
         supportsStreaming: false,
@@ -991,27 +1030,29 @@ export const NIM_MODELS = {
             "Inpainting and outpainting",
             "Style transfer with layout preservation",
             "Character consistency across images",
+            "Object replacement in images",
         ],
         license: "Apache 2.0 (non-commercial default, commercial via contact)",
         commercialUse: false,
         thirdPartyModel: true,
-        minGpuRequirements: ["1x H100 80GB", "1x B200"],
-        supportedHardware: ["Blackwell", "Hopper", "Lovelace"],
-        runtimeEngines: ["TensorRT"],
+        minGpuRequirements: ["N/A - Cloud API"],
+        supportedHardware: ["Cloud"],
+        runtimeEngines: ["NVIDIA AI Foundation"],
         imageGenSpecs: {
             supportedResolutions: ["1024x1024", "1152x896", "896x1152", "1344x768", "768x1344"],
-            supportedAspectRatios: ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21"],
+            supportedAspectRatios: ["1:1", "16:9", "9:16", "4:3", "3:4", "21:9", "9:21", "match_input_image"],
             maxImagesPerRequest: 1,
             recommendedSamplers: ["euler", "euler_a"],
             recommendedSchedulers: ["simple"],
-            defaultSteps: 20,
+            defaultSteps: 30,
             defaultCfgScale: 3.5,
             supportsNegativePrompt: true,
             supportsImageToImage: true,
             supportsInpainting: true,
             supportsControlNet: false,
         },
-        tags: ["image-to-image", "editing", "inpainting", "outpainting", "style-transfer", "flux", "character-consistency"],
+        tags: ["image-to-image", "editing", "inpainting", "outpainting", "style-transfer", "flux", "kontext", "free-tier", "character-consistency"],
+        deploymentNotes: "Available via NVIDIA AI Foundation Models API (https://ai.api.nvidia.com/v1/genai/black-forest-labs/flux.1-kontext-dev). Requires input image as base64 data URL.",
     },
     // === Multimodal ===
     "nvidia/neva-22b": {

package/dist/tools.d.ts

@@ -73,6 +73,7 @@ export declare const ChatCompletionSchema: z.ZodObject<{
     presence_penalty: z.ZodOptional<z.ZodNumber>;
     seed: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    seed?: number;
     model?: string;
     messages?: {
         role?: "system" | "user" | "assistant";
@@ -85,8 +86,8 @@ export declare const ChatCompletionSchema: z.ZodObject<{
     stop?: string | string[];
     frequency_penalty?: number;
     presence_penalty?: number;
-    seed?: number;
 }, {
+    seed?: number;
     model?: string;
     messages?: {
         role?: "system" | "user" | "assistant";
@@ -99,7 +100,6 @@ export declare const ChatCompletionSchema: z.ZodObject<{
     stop?: string | string[];
     frequency_penalty?: number;
     presence_penalty?: number;
-    seed?: number;
 }>;
 export declare const TextGenerationSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
@@ -290,9 +290,14 @@ export declare const ImageGenerationSchema: z.ZodObject<{
     sampler: z.ZodOptional<z.ZodString>;
     scheduler: z.ZodOptional<z.ZodString>;
     response_format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["url", "b64_json"]>>>;
+    image: z.ZodOptional<z.ZodString>;
+    aspect_ratio: z.ZodOptional<z.ZodString>;
+    save_path: z.ZodOptional<z.ZodString>;
+    save_filename: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    model?: string;
+    image?: string;
     seed?: number;
+    model?: string;
     prompt?: string;
     negative_prompt?: string;
     width?: number;
@@ -303,9 +308,13 @@ export declare const ImageGenerationSchema: z.ZodObject<{
     sampler?: string;
     scheduler?: string;
     response_format?: "url" | "b64_json";
+    aspect_ratio?: string;
+    save_path?: string;
+    save_filename?: string;
 }, {
-    model?: string;
+    image?: string;
     seed?: number;
+    model?: string;
     prompt?: string;
     negative_prompt?: string;
     width?: number;
@@ -316,6 +325,9 @@ export declare const ImageGenerationSchema: z.ZodObject<{
     sampler?: string;
     scheduler?: string;
     response_format?: "url" | "b64_json";
+    aspect_ratio?: string;
+    save_path?: string;
+    save_filename?: string;
 }>;
 export declare const ImageAnalysisSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
@@ -755,13 +767,13 @@ export declare const TOOL_DEFINITIONS: readonly [{
     };
 }, {
     readonly name: "generate_image";
-    readonly description: "Generate images from text prompts using NVIDIA NIM image generation models (Stable Diffusion XL, SDXL Turbo, SD3, FLUX.1). Supports various resolutions, samplers, and schedulers.";
+    readonly description: "Generate images from text prompts using NVIDIA NIM image generation models (Stable Diffusion XL, SDXL Turbo, SD3, FLUX.1). Supports various resolutions, samplers, and schedulers. FLUX.1-schnell and FLUX.1-kontext-dev are available on the free NVIDIA AI Foundation tier. Can save generated images as PNG files to disk.";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
             readonly model: {
                 readonly type: "string";
-                readonly description: "Image generation model ID (e.g., nvidia/stable-diffusion-xl, nvidia/sdxl-turbo, stabilityai/sd-3-medium, black-forest-labs/flux.1-dev)";
+                readonly description: "Image generation model ID (e.g., nvidia/stable-diffusion-xl, nvidia/sdxl-turbo, stabilityai/sd-3-medium, black-forest-labs/flux.1-dev, black-forest-labs/flux.1-schnell, black-forest-labs/flux.1-kontext-dev)";
             };
             readonly prompt: {
                 readonly type: "string";
@@ -797,7 +809,7 @@ export declare const TOOL_DEFINITIONS: readonly [{
                 readonly minimum: 1;
                 readonly maximum: 100;
                 readonly default: 20;
-                readonly description: "Number of diffusion steps";
+                readonly description: "Number of diffusion steps (ignored for FLUX Schnell, fixed at 4)";
             };
             readonly cfg_scale: {
                 readonly type: "number";
@@ -824,6 +836,22 @@ export declare const TOOL_DEFINITIONS: readonly [{
                 readonly default: "url";
                 readonly description: "Response format: URL or base64 JSON";
             };
+            readonly image: {
+                readonly type: "string";
+                readonly description: "Base64 data URL of input image (required for FLUX Kontext image-to-image editing, format: data:image/png;base64,...)";
+            };
+            readonly aspect_ratio: {
+                readonly type: "string";
+                readonly description: "Aspect ratio for output (e.g., 'match_input_image', '1:1', '16:9', '4:3', '3:4', '21:9')";
+            };
+            readonly save_path: {
+                readonly type: "string";
+                readonly description: "Optional file path to save the generated image as PNG (e.g., './output/image.png' or '/absolute/path/image.png')";
+            };
+            readonly save_filename: {
+                readonly type: "string";
+                readonly description: "Optional filename (without extension) to auto-generate path in current directory (e.g., 'my-image' creates './my-image.png')";
+            };
         };
         readonly required: readonly ["prompt"];
     };

package/dist/tools.js

@@ -81,6 +81,12 @@ export const ImageGenerationSchema = z.object({
     sampler: z.string().optional().describe("Sampler algorithm (e.g., euler, euler_a, dpmpp_2m)"),
     scheduler: z.string().optional().describe("Scheduler type (e.g., karras, exponential, simple)"),
     response_format: z.enum(["url", "b64_json"]).optional().default("url").describe("Response format"),
+    // FLUX Kontext specific parameters
+    image: z.string().optional().describe("Base64 data URL of input image (required for FLUX Kontext image-to-image editing)"),
+    aspect_ratio: z.string().optional().describe("Aspect ratio for output (e.g., 'match_input_image', '1:1', '16:9', '4:3')"),
+    // File save options
+    save_path: z.string().optional().describe("Optional file path to save the generated image as PNG (e.g., './output/image.png' or '/absolute/path/image.png')"),
+    save_filename: z.string().optional().describe("Optional filename (without extension) to auto-generate path in current directory"),
 });
 export const ImageAnalysisSchema = z.object({
     model: z.string().optional().describe("Vision/multimodal model ID"),
@@ -281,22 +287,28 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "generate_image",
-        description: "Generate images from text prompts using NVIDIA NIM image generation models (Stable Diffusion XL, SDXL Turbo, SD3, FLUX.1). Supports various resolutions, samplers, and schedulers.",
+        description: "Generate images from text prompts using NVIDIA NIM image generation models (Stable Diffusion XL, SDXL Turbo, SD3, FLUX.1). Supports various resolutions, samplers, and schedulers. FLUX.1-schnell and FLUX.1-kontext-dev are available on the free NVIDIA AI Foundation tier. Can save generated images as PNG files to disk.",
         inputSchema: {
             type: "object",
             properties: {
-                model: { type: "string", description: "Image generation model ID (e.g., nvidia/stable-diffusion-xl, nvidia/sdxl-turbo, stabilityai/sd-3-medium, black-forest-labs/flux.1-dev)" },
+                model: { type: "string", description: "Image generation model ID (e.g., nvidia/stable-diffusion-xl, nvidia/sdxl-turbo, stabilityai/sd-3-medium, black-forest-labs/flux.1-dev, black-forest-labs/flux.1-schnell, black-forest-labs/flux.1-kontext-dev)" },
                 prompt: { type: "string", description: "Text prompt describing the image to generate" },
                 negative_prompt: { type: "string", description: "Negative prompt to avoid unwanted features" },
                 width: { type: "integer", minimum: 64, maximum: 2048, default: 1024, description: "Image width in pixels" },
                 height: { type: "integer", minimum: 64, maximum: 2048, default: 1024, description: "Image height in pixels" },
                 num_images: { type: "integer", minimum: 1, maximum: 4, default: 1, description: "Number of images to generate" },
-                steps: { type: "integer", minimum: 1, maximum: 100, default: 20, description: "Number of diffusion steps" },
+                steps: { type: "integer", minimum: 1, maximum: 100, default: 20, description: "Number of diffusion steps (ignored for FLUX Schnell, fixed at 4)" },
                 cfg_scale: { type: "number", minimum: 1, maximum: 20, default: 7.0, description: "Classifier-free guidance scale" },
                 seed: { type: "integer", description: "Random seed for reproducibility" },
                 sampler: { type: "string", description: "Sampler algorithm (e.g., euler, euler_a, dpmpp_2m, dpmpp_sde, ddim)" },
                 scheduler: { type: "string", description: "Scheduler type (e.g., karras, exponential, simple, ddim_uniform)" },
                 response_format: { type: "string", enum: ["url", "b64_json"], default: "url", description: "Response format: URL or base64 JSON" },
+                // FLUX Kontext specific parameters
+                image: { type: "string", description: "Base64 data URL of input image (required for FLUX Kontext image-to-image editing, format: data:image/png;base64,...)" },
+                aspect_ratio: { type: "string", description: "Aspect ratio for output (e.g., 'match_input_image', '1:1', '16:9', '4:3', '3:4', '21:9')" },
+                // File save options
+                save_path: { type: "string", description: "Optional file path to save the generated image as PNG (e.g., './output/image.png' or '/absolute/path/image.png')" },
+                save_filename: { type: "string", description: "Optional filename (without extension) to auto-generate path in current directory (e.g., 'my-image' creates './my-image.png')" },
             },
             required: ["prompt"],
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvidia-nim-mcp",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Production-ready MCP server for NVIDIA NIM models - 50+ LLMs, multimodal, image generation, embeddings, reranking with rich metadata for agent selection",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",