Setup NVIDIA NIM Free API: Hướng dẫn chi tiết bảo mật & tối ưu cho dev

mkdir -p ~/.secrets
chmod 700 ~/.secrets
nano ~/.secrets/nvidia.env

NVIDIA_API_KEY=nvapi-REDACTED_YOUR_ACTUAL_KEY_HERE

chmod 600 ~/.secrets/nvidia.env

set -a
source ~/.secrets/nvidia.env
set +a

sudo mkdir -p /etc/nvidia-api
sudo nano /etc/nvidia-api/env.conf
# Nội dung: NVIDIA_API_KEY=nvapi-YOUR_KEY_HERE

sudo chmod 600 /etc/nvidia-api/env.conf
sudo chown root:root /etc/nvidia-api/env.conf

sudo nano /etc/systemd/system/my-ai-app.service

[Unit]
Description=My AI Application using NVIDIA NIM
After=network.target
StartLimitIntervalSec=0

[Service]
Type=simple
User=your_username
Group=your_username
WorkingDirectory=/home/your_username/projects/my-app
EnvironmentFile=/etc/nvidia-api/env.conf
ExecStart=/usr/bin/python3 /home/your_username/projects/my-app/app.py
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

source ~/.secrets/nvidia.env

curl -s https://integrate.api.nvidia.com/v1/models \
  -H "Authorization: Bearer $NVIDIA_API_KEY" | head -20

source ~/.secrets/nvidia.env

curl -s https://integrate.api.nvidia.com/v1/chat/completions \
  -H "Authorization: Bearer $NVIDIA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "moonshotai/kimi-k2.5",
    "messages": [
      {
        "role": "user",
        "content": "Ping. Trả lời 1 câu tiếng Việt."
      }
    ],
    "max_tokens": 256,
    "temperature": 0.3,
    "top_p": 0.95,
    "stream": false
  }' | head -c 1200

import os
import requests
import json
import time
from typing import Optional

INVOKE_URL = "https://integrate.api.nvidia.com/v1/chat/completions"

def get_api_key() -> str:
    """Lấy API key từ environment variable."""
    api_key = os.environ.get("NVIDIA_API_KEY")
    if not api_key:
        raise SystemExit(
            "Missing NVIDIA_API_KEY. Run: source ~/.secrets/nvidia.env"
        )
    return api_key

def call_nvidia_api(
    user_prompt: str,
    model: str = "moonshotai/kimi-k2.5",
    max_tokens: int = 800,
    temperature: float = 0.5,
    top_p: float = 0.95,
    timeout: int = 120
) -> str:
    """Gọi NVIDIA NIM API an toàn với error handling."""
    api_key = get_api_key()

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    payload = {
        "model": model,
        "messages": [{"role": "user", "content": user_prompt}],
        "max_tokens": max_tokens,
        "temperature": temperature,
        "top_p": top_p,
        "stream": False
    }

    try:
        print(f"[INFO] Gọi API với model: {model}")
        response = requests.post(
            INVOKE_URL,
            headers=headers,
            json=payload,
            timeout=timeout
        )

        # Xử lý HTTP error codes
        if response.status_code == 401:
            raise SystemExit("ERROR 401: Unauthorized - Key sai hoặc đã revoke")
        elif response.status_code == 404:
            raise SystemExit(f"ERROR 404: Model '{model}' không tìm thấy")
        elif response.status_code == 429:
            retry_after = response.headers.get('Retry-After', 'N/A')
            raise SystemExit(f"ERROR 429: Rate limit exceeded. Retry after: {retry_after}s")
        elif response.status_code >= 400:
            raise SystemExit(f"ERROR {response.status_code}: {response.text[:500]}")

        data = response.json()
        content = data["choices"][0]["message"]["content"]

        # Log token usage
        usage = data.get("usage", {})
        print(f"[INFO] Tokens used - Total: {usage.get('total_tokens', 0)}")

        return content

    except requests.exceptions.Timeout:
        raise SystemExit(f"TIMEOUT: Request timeout sau {timeout}s")
    except requests.exceptions.RequestException as e:
        raise SystemExit(f"REQUEST ERROR: {e}")

if __name__ == "__main__":
    try:
        prompt = "Viết 3 mẹo để tiết kiệm NVIDIA API credits"
        result = call_nvidia_api(prompt, model="moonshotai/kimi-k2.5")
        print("\n[RESPONSE]")
        print(result)
    except SystemExit as e:
        print(str(e))
        exit(1)

import os
from openai import OpenAI
from openai import APIError, APIConnectionError, RateLimitError

def call_nvidia_openai(user_prompt: str, model: str = "moonshotai/kimi-k2.5") -> str:
    api_key = os.environ.get("NVIDIA_API_KEY")
    if not api_key:
        raise SystemExit("Missing NVIDIA_API_KEY")

    client = OpenAI(
        base_url="https://integrate.api.nvidia.com/v1",
        api_key=api_key
    )

    try:
        print(f"[INFO] Gọi OpenAI SDK với model: {model}")
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": user_prompt}],
            max_tokens=800,
            temperature=0.5,
            top_p=0.95
        )
        return response.choices[0].message.content

    except RateLimitError:
        raise SystemExit("ERROR: Rate limit exceeded (429)")
    except Exception as e:
        raise SystemExit(f"ERROR: {e}")

if __name__ == "__main__":
    print(call_nvidia_openai("Hello NVIDIA NIM"))

import fetch from "node-fetch";

const INVOKE_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
const apiKey = process.env.NVIDIA_API_KEY;

if (!apiKey) {
  console.error("ERROR: Missing NVIDIA_API_KEY. Run: source ~/.secrets/nvidia.env");
  process.exit(1);
}

async function callNvidiaAPI(userPrompt, modelId = "z-ai/glm4.7") {
  const payload = {
    model: modelId,
    messages: [{ role: "user", content: userPrompt }],
    max_tokens: 600,
    temperature: 0.3,
    top_p: 0.95,
    stream: false
  };

  try {
    console.log(`[INFO] Calling NVIDIA API with model: ${modelId}`);

    const res = await fetch(INVOKE_URL, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify(payload),
      timeout: 120000
    });

    if (!res.ok) {
      const errorText = await res.text();
      console.error(`ERROR ${res.status}: ${errorText.substring(0, 200)}`);
      process.exit(1);
    }

    const data = await res.json();
    const content = data.choices?.[0]?.message?.content;

    // Log token usage
    const usage = data.usage || {};
    console.log(`[INFO] Tokens Total: ${usage.total_tokens}`);

    return content;

  } catch (error) {
    console.error(`ERROR: Request failed - ${error.message}`);
    process.exit(1);
  }
}

callNvidiaAPI("Nêu 5 lợi ích của AI trong giáo dục").then(result => {
  console.log("\n[RESPONSE]", result);
});

from tenacity import (
    retry,
    stop_after_attempt,
    wait_random_exponential,
    retry_if_exception_type,
    RetryError
)
import requests
import os

@retry(
    wait=wait_random_exponential(multiplier=1, min=1, max=60),
    stop=stop_after_attempt(6),
    retry=retry_if_exception_type((
        requests.exceptions.Timeout,
        requests.exceptions.ConnectionError,
        requests.exceptions.HTTPError
    ))
)
def call_nvidia_with_retry(prompt: str) -> dict:
    """
    Tự động retry với exponential backoff & jitter.
    Max 6 attempts.
    """
    response = requests.post(
        "https://integrate.api.nvidia.com/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {os.environ.get('NVIDIA_API_KEY')}"
        },
        json={
            "model": "moonshotai/kimi-k2.5",
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": 800
        },
        timeout=120
    )

    if response.status_code >= 400:
        response.raise_for_status()

    return response.json()