nvidia-nim-mcp 1.0.0

package/dist/tools.js

@@ -0,0 +1,240 @@
+import { z } from "zod";
+// ─── Shared Schemas ───────────────────────────────────────────────────────────
+export const ChatMessageSchema = z.object({
+    role: z.enum(["system", "user", "assistant"]),
+    content: z.string(),
+});
+export const ToolFunctionSchema = z.object({
+    name: z.string().min(1).max(64),
+    description: z.string(),
+    parameters: z.record(z.unknown()),
+});
+export const ToolSchema = z.object({
+    type: z.literal("function"),
+    function: ToolFunctionSchema,
+});
+// ─── Tool Schemas ─────────────────────────────────────────────────────────────
+export const ChatCompletionSchema = z.object({
+    model: z.string().optional().describe("NIM model ID. Defaults to configured default."),
+    messages: z.array(ChatMessageSchema).min(1).describe("Conversation messages"),
+    system_prompt: z.string().optional().describe("System prompt (prepended automatically)"),
+    temperature: z.number().min(0).max(2).optional().describe("Sampling temperature (0-2)"),
+    top_p: z.number().min(0).max(1).optional().describe("Nucleus sampling parameter"),
+    max_tokens: z.number().int().positive().max(131072).optional().describe("Max tokens to generate"),
+    stop: z.union([z.string(), z.array(z.string())]).optional().describe("Stop sequences"),
+    frequency_penalty: z.number().min(-2).max(2).optional(),
+    presence_penalty: z.number().min(-2).max(2).optional(),
+    seed: z.number().int().optional().describe("Seed for reproducibility"),
+});
+export const ChatStreamSchema = ChatCompletionSchema;
+export const TextGenerationSchema = z.object({
+    model: z.string().optional(),
+    prompt: z.string().min(1).describe("The text prompt to complete"),
+    system_prompt: z.string().optional().describe("Optional system context"),
+    temperature: z.number().min(0).max(2).optional(),
+    max_tokens: z.number().int().positive().max(131072).optional(),
+    stop: z.union([z.string(), z.array(z.string())]).optional(),
+});
+export const EmbeddingsSchema = z.object({
+    model: z.string().optional().describe("Embedding model ID"),
+    input: z.union([z.string(), z.array(z.string())]).describe("Text(s) to embed"),
+    encoding_format: z.enum(["float", "base64"]).optional().default("float"),
+    truncate: z.enum(["NONE", "START", "END"]).optional().default("END"),
+});
+export const RerankSchema = z.object({
+    model: z.string().optional().describe("Reranking model ID"),
+    query: z.string().min(1).describe("The search query"),
+    passages: z
+        .array(z.union([z.string(), z.object({ text: z.string() })]))
+        .min(1)
+        .max(100)
+        .describe("Passages to rerank"),
+    top_k: z.number().int().positive().optional().describe("Return top K results"),
+    truncate: z.enum(["NONE", "END"]).optional().default("END"),
+});
+export const FunctionCallingSchema = z.object({
+    model: z.string().optional(),
+    messages: z.array(ChatMessageSchema).min(1),
+    tools: z.array(ToolSchema).min(1).describe("Available tools/functions"),
+    tool_choice: z
+        .union([
+        z.enum(["auto", "none"]),
+        z.object({
+            type: z.literal("function"),
+            function: z.object({ name: z.string() }),
+        }),
+    ])
+        .optional()
+        .default("auto"),
+    temperature: z.number().min(0).max(2).optional(),
+    max_tokens: z.number().int().positive().optional(),
+});
+export const ListModelsSchema = z.object({
+    category: z
+        .enum(["language", "embedding", "reranking", "vision", "code", "multimodal", "all"])
+        .optional()
+        .default("all")
+        .describe("Filter models by category"),
+});
+export const ModelInfoSchema = z.object({
+    model_id: z.string().describe("The model ID to get info about"),
+});
+// ─── Tool Definitions ─────────────────────────────────────────────────────────
+export const TOOL_DEFINITIONS = [
+    {
+        name: "chat_completion",
+        description: "Send a multi-turn conversation to a NVIDIA NIM language model and receive a completion. Supports all major open-source LLMs including Llama 3.1, Mistral, Gemma, Qwen, and more.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model: { type: "string", description: "NIM model ID (optional, uses default if not set)" },
+                messages: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            role: { type: "string", enum: ["system", "user", "assistant"] },
+                            content: { type: "string" },
+                        },
+                        required: ["role", "content"],
+                    },
+                    minItems: 1,
+                },
+                system_prompt: { type: "string", description: "System prompt to prepend" },
+                temperature: { type: "number", minimum: 0, maximum: 2 },
+                top_p: { type: "number", minimum: 0, maximum: 1 },
+                max_tokens: { type: "integer", minimum: 1, maximum: 131072 },
+                stop: { oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
+                seed: { type: "integer" },
+            },
+            required: ["messages"],
+        },
+    },
+    {
+        name: "text_generation",
+        description: "Generate text from a single prompt (simplified interface). Ideal for one-shot tasks like summarization, translation, extraction, or Q&A.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model: { type: "string" },
+                prompt: { type: "string", description: "Text prompt" },
+                system_prompt: { type: "string" },
+                temperature: { type: "number", minimum: 0, maximum: 2 },
+                max_tokens: { type: "integer", minimum: 1, maximum: 131072 },
+                stop: { oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }] },
+            },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "create_embeddings",
+        description: "Convert text(s) into vector embeddings using NVIDIA NIM embedding models. Useful for semantic search, RAG, clustering, and similarity comparisons.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model: { type: "string", description: "Embedding model ID (e.g. nvidia/nv-embed-v1)" },
+                input: {
+                    oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }],
+                    description: "Text or list of texts to embed",
+                },
+                encoding_format: { type: "string", enum: ["float", "base64"] },
+                truncate: { type: "string", enum: ["NONE", "START", "END"] },
+            },
+            required: ["input"],
+        },
+    },
+    {
+        name: "rerank_passages",
+        description: "Rerank a list of passages by relevance to a query using NVIDIA NIM reranking models. Essential for RAG pipelines to improve retrieval quality.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model: { type: "string", description: "Reranking model ID" },
+                query: { type: "string", description: "Search query" },
+                passages: {
+                    type: "array",
+                    items: { oneOf: [{ type: "string" }, { type: "object", properties: { text: { type: "string" } }, required: ["text"] }] },
+                    minItems: 1,
+                    maxItems: 100,
+                },
+                top_k: { type: "integer", minimum: 1, description: "Return top K results" },
+                truncate: { type: "string", enum: ["NONE", "END"] },
+            },
+            required: ["query", "passages"],
+        },
+    },
+    {
+        name: "function_calling",
+        description: "Use NIM models with tool/function calling capabilities. The model will decide which function to call and with what arguments.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model: { type: "string" },
+                messages: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            role: { type: "string", enum: ["system", "user", "assistant"] },
+                            content: { type: "string" },
+                        },
+                        required: ["role", "content"],
+                    },
+                },
+                tools: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            type: { type: "string", enum: ["function"] },
+                            function: {
+                                type: "object",
+                                properties: {
+                                    name: { type: "string" },
+                                    description: { type: "string" },
+                                    parameters: { type: "object" },
+                                },
+                                required: ["name", "description", "parameters"],
+                            },
+                        },
+                        required: ["type", "function"],
+                    },
+                },
+                tool_choice: {
+                    oneOf: [
+                        { type: "string", enum: ["auto", "none"] },
+                        { type: "object", properties: { type: { type: "string" }, function: { type: "object" } } },
+                    ],
+                },
+                temperature: { type: "number" },
+                max_tokens: { type: "integer" },
+            },
+            required: ["messages", "tools"],
+        },
+    },
+    {
+        name: "list_models",
+        description: "List available NVIDIA NIM models, optionally filtered by category (language, embedding, reranking, vision, code).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                category: {
+                    type: "string",
+                    enum: ["language", "embedding", "reranking", "vision", "code", "multimodal", "all"],
+                    description: "Filter by model category",
+                },
+            },
+        },
+    },
+    {
+        name: "get_model_info",
+        description: "Get detailed information about a specific NVIDIA NIM model.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                model_id: { type: "string", description: "The model ID" },
+            },
+            required: ["model_id"],
+        },
+    },
+];

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "nvidia-nim-mcp",
+  "version": "1.0.0",
+  "description": "Production-ready MCP server for NVIDIA NIM models with GLM-5 specialization for software development and architecture",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "nvidia-nim-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "scripts": {
+    "build": "tsc src/index.ts --outDir dist --module NodeNext --moduleResolution NodeNext --target ES2022 --declaration --skipLibCheck && node scripts/add-shebang.js",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "lint": "eslint src/**/*.ts",
+    "test": "jest",
+    "check": "npm run lint && npm test",
+    "prepublishOnly": "npm run build",
+    "pack": "npm run build && npm pack",
+    "verify": "node scripts/verify-installation.js",
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "nvidia",
+    "nim",
+    "glm5",
+    "ai",
+    "llm",
+    "chat",
+    "embeddings",
+    "reranking",
+    "function-calling",
+    "code-generation",
+    "software-development"
+  ],
+  "author": "David Gonzalez <david.eve.za@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "bugs": {
+    "url": ""
+  },
+  "homepage": "",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.7.7",
+    "axios-retry": "^4.5.0",
+    "dotenv": "^16.4.5",
+    "winston": "^3.14.2",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
+    "@babel/preset-typescript": "^7.28.5",
+    "@eslint/js": "^10.0.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.56.1",
+    "@typescript-eslint/parser": "^8.56.1",
+    "babel-jest": "^30.2.0",
+    "eslint": "^10.0.2",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.56.1"
+  },
+  "peerDependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  }
+}

package/scripts/add-shebang.js

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+// Add shebang to the compiled index.js file
+const indexPath = join(process.cwd(), 'dist', 'index.js');
+
+// Wait for file to exist (up to 5 seconds)
+let attempts = 0;
+const maxAttempts = 50; // 5 seconds with 100ms intervals
+
+function waitForFile() {
+  if (existsSync(indexPath)) {
+    const content = readFileSync(indexPath, 'utf8');
+    if (!content.startsWith('#!/usr/bin/env node')) {
+      writeFileSync(indexPath, '#!/usr/bin/env node\n' + content);
+      console.log('Shebang added to dist/index.js');
+    } else {
+      console.log('Shebang already present in dist/index.js');
+    }
+  } else if (attempts < maxAttempts) {
+    attempts++;
+    setTimeout(waitForFile, 100);
+  } else {
+    console.error('dist/index.js not found after waiting');
+    process.exit(1);
+  }
+}
+
+waitForFile();

package/scripts/postinstall.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+/**
+ * Post-installation script for NVIDIA NIM MCP Server
+ * 
+ * This script runs after the package is installed and provides
+ * helpful information to the user.
+ */
+
+console.log(`
+🎉 Thank you for installing NVIDIA NIM MCP Server!
+
+🚀 Quick Start:
+   npx nvidia-nim-mcp
+
+🔐 Configuration:
+   1. Set your NVIDIA API key: NVIDIA_API_KEY=nvapi-your-key
+   2. See .env.example for all configuration options
+
+📚 Documentation:
+   - README.md for detailed usage instructions
+   - Visit https://build.nvidia.com for API key registration
+
+⚡ Next Steps:
+   npx nvidia-nim-mcp --help
+
+💡 Having trouble? Run:
+   npm run verify
+`);
+
+// Only show advanced tips if this is a global installation
+if (process.env.npm_config_global === 'true') {
+  console.log(`🔧 Global Installation Detected:
+   You can now run 'nvidia-nim-mcp' from anywhere!
+   For configuration, create a .env file in your working directory.
+`);
+}

package/scripts/verify-installation.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+/**
+ * Installation verification script for NVIDIA NIM MCP Server
+ * 
+ * This script checks if the environment is properly set up to run the server.
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+console.log('🔍 Verifying NVIDIA NIM MCP Server installation...\n');
+
+// Check Node.js version
+const nodeVersion = process.version;
+const nodeMajorVersion = parseInt(nodeVersion.split('.')[0].replace('v', ''));
+console.log(`✅ Node.js version: ${nodeVersion}`);
+
+if (nodeMajorVersion < 18) {
+  console.log('⚠️  Warning: Node.js 18+ is recommended for optimal performance');
+}
+
+// Check if we're running from source or installed package
+const isSource = existsSync(join(process.cwd(), 'src'));
+const isInstalled = existsSync(join(process.cwd(), 'dist')) || existsSync(join(process.cwd(), 'node_modules'));
+
+if (isSource) {
+  console.log('📁 Running from source directory');
+  console.log('📋 To build the project, run: npm run build');
+} else if (isInstalled) {
+  console.log('📦 Running from installed package');
+} else {
+  console.log('❓ Unknown installation type');
+}
+
+// Check required environment variables (don't actually validate values)
+const requiredEnvVars = ['NVIDIA_API_KEY'];
+const missingEnvVars = requiredEnvVars.filter(envVar => !process.env[envVar]);
+
+if (missingEnvVars.length > 0) {
+  console.log('\n⚠️  Warning: Missing required environment variables:');
+  missingEnvVars.forEach(envVar => console.log(`   - ${envVar}`));
+  console.log('\n📝 Please set these variables before running the server.');
+  console.log('   Example: NVIDIA_API_KEY=nvapi-your-key-here nvidia-nim-mcp');
+} else {
+  console.log('\n✅ All required environment variables are set');
+}
+
+console.log('\n✨ Installation verification complete!');
+console.log('\n🚀 To start the server, run one of:');
+console.log('   nvidia-nim-mcp');
+console.log('   npm start');
+console.log('   node dist/index.js');
+console.log('   docker run nvidia-nim-mcp');
+
+console.log('\n📖 For detailed configuration, see .env.example file');