{"slug": "inside-nvidia-nemotron-3-5-lightning-building-a-local-mixture-of-experts", "title": "Inside NVIDIA Nemotron 3.5 Lightning: Building a (Local) Mixture-of-Experts Explorer", "summary": "A developer built nvidia-nemotron-lightning-35-test, an open local explorer and testing framework for running NVIDIA's Nemotron 3.5 Lightning Mixture-of-Experts model through Ollama. The project provides a sandbox for probing the model's sparse routing, speculative decoding with draft models (DSpark, MTP, DFlash), and serving via vLLM, llama.cpp, and LoRA, while separating measured backend telemetry from illustrative visual simulations. The 30B-parameter model activates only 3B parameters per token, trading dense compute for sparse expert routing.", "body_md": "A technical exploration ofthe Mixture-of-Experts (MoE) design of NVIDIA Nemotron 3.5 Lightning.\n\n# \n  Introduction\n\nModern AI systems face a fundamental tension: users demand the deep reasoning and multi-step planning of large frontier models, yet running dense 30B+ parameter architectures for high-frequency subtasks (like code routing, tool parsing, and syntax validation) imposes massive computational and financial overhead.\n\nTo solve this, NVIDIA introduced **Nemotron 3.5 Lightning**, an open-weight 30-billion parameter **Mixture-of-Experts (MoE)** model that activates only **3 billion parameters per token**.   \n\nThis article explores `nvidia-nemotron-lightning-35-test`, a production-grade local explorer and testing framework designed to interact with, monitor, and visualize Nemotron 3.5 Lightning locally via Ollama. Rather than just wrapping API endpoints, this project provides a clear architectural blueprint for building transparent, low-latency AI applications.\n\n# \n  Implementation\n\nThe `nvidia-nemotron-lightning-35-test` project provides a robust framework and sandbox to explore, serve, and evaluate NVIDIA Nemotron 3.5 Lightning. The repository architecture is structured around core demonstration modules, documentation sets, and utility scripts designed to test MoE behavior, speculative decoding, and application-level routing. At the heart of the system is a Mixture-of-Experts (MoE) transformer backbone. Unlike dense models where all parameters are activated for every token, Nemotron 3.5 Lightning routes tokens through sparse expert layers, ensuring high representational capacity (30B total) combined with rapid execution speed (3B active parameters).\n\n## \n  Architectural Philosophy: The MoE Paradigm & Efficiency\n\nUnlike dense models that utilize their entire parameter set for every token generated, Nemotron 3.5 Lightning routes tokens dynamically through sparse expert layers. This decoupled design provides the representational capacity of a 30B model with the execution speed of a 3B model.\n\n```\n+-------------------------------------------------------------------+\n|                        Client / User Input                        |\n+-------------------------------------------------------------------+\n                                  │\n                                  ▼\n+-------------------------------------------------------------------+\n|                   NeMo Switchyard / Router Layer                  |\n+-------------------------------------------------------------------+\n                                  │\n                                  ▼\n+-------------------------------------------------------------------+\n|               NVIDIA Nemotron 3.5 Lightning (MoE)                 |\n|  - 30B Total Parameters / 3B Active Parameters                    |\n|  - Multi-Token Prediction (MTP) & Speculative Decoding Support    |\n+-------------------------------------------------------------------+\n         │                                                 │\n         ▼                                                 ▼\n+-------------------------+                       +-------------------------+\n|      Draft Models       |                       |   Serving Frameworks    |\n| (DSpark / MTP / DFlash) |                       | (vLLM / llama.cpp / LoRA)|\n+-------------------------+                       +-------------------------+\n```\n\nTo maintain complete intellectual honesty, the project’s application architecture enforces a strict boundary between **hard telemetry** (data directly measured from backend inference) and **illustrative modeling** (educational visual simulations):\n\n```\n| Data Component                        | Origin                                                       | Status                           |\n| ------------------------------------- | ------------------------------------------------------------ | -------------------------------- |\n| **Connection State & Model Metadata** | Ollama `/api/version`, `/api/tags`, `/api/ps` blog-post-V2.md | **Measured** blog-post-V2.md     |\n| **Generation Speed & Token Counts**   | Ollama final streaming chunk (`eval_count`, `eval_duration`) blog-post-V2.md | **Measured** blog-post-V2.md     |\n| **Time to First Token (TTFT)**        | Client-side performance timer blog-post-V2.md                | **Measured** blog-post-V2.md     |\n| **Expert Activation Heatmap**         | `moe_demo/router_sim.py` (Deterministic BLAKE2b simulation) blog-post-V2.md+ 1 | **Illustrative** blog-post-V2.md |\n```\n\n⚠️ **Design Note on Ollama:** Ollama does not currently expose internal per-token router telemetry (e.g., revealing *exactly* which expert ID fired for a specific token). The application explicitly flags its expert heatmaps as simulated, preserving user trust and technical accuracy.   \n\n# \n  Core Project Structure\n\nThe codebase is organized around a clean separation of concerns, isolating the GUI layer from core business logic and state computation:\n\n```\nnvidia-nemotron-lightning-35-test/\n├── Docs/                  # System documentation and architectural references\n├── docs_tools/            # Automated document parsers and build scripts\n├── moe_demo/              # Core application packages\n│   ├── __init__.py\n│   ├── categories.py      # Task heuristic classifiers and expert affinities\n│   ├── config.py          # Environment-based configuration loader\n│   ├── engine.py          # UI-agnostic request builder and stream handler\n│   ├── metrics.py         # Nanosecond-to-throughput converters\n│   ├── ollama_client.py   # Robust REST wrapper for Ollama APIs\n│   ├── router_sim.py      # Deterministic top-6-of-128 routing simulator\n│   └── ui_components.py   # Streamlit visual cards and heatmaps\n└── app.py                 # Central Streamlit GUI entrypoint\n```\n\n## \n  Implementation Deep Dive\n\n## \n  Environment Configuration (`moe_demo/config.py`)\n\nConfiguration is managed via environment variables with fallback support for local `.env` files. Using a frozen dataclass ensures settings remain immutable throughout the application lifecycle:\n\n```\n\"\"\"Runtime configuration. Values come from the environment / `.env` (see `.env.example`).\"\"\"\nfrom __future__ import annotations\n\nimport os\nfrom dataclasses import dataclass\nfrom pathlib import Path\n\nROOT = Path(__file__).resolve().parent.parent\n\ndef load_env_file(path: Path | None = None) -> None:\n    \"\"\"Load KEY=VALUE lines from `.env` into os.environ without overriding real env vars.\n\n    A tiny parser is used on purpose so the app has no extra dependency and also works\n    when started with `streamlit run app.py` instead of `scripts/start.sh`.\n    \"\"\"\n    path = path or ROOT / \".env\"\n    if not path.is_file():\n        return\n    for raw in path.read_text(encoding=\"utf-8\").splitlines():\n        line = raw.strip()\n        if not line or line.startswith(\"#\") or \"=\" not in line:\n            continue\n        key, _, value = line.partition(\"=\")\n        value = value.strip().strip('\"').strip(\"'\")\n        os.environ.setdefault(key.strip(), value)\n\n@dataclass(frozen=True)\nclass Settings:\n    base_url: str\n    model: str\n    keep_alive: str\n    request_timeout: float\n\ndef get_settings() -> Settings:\n    \"\"\"Build settings from the environment (defaults only for non-sensitive values).\"\"\"\n    load_env_file()\n    return Settings(\n        base_url=os.environ.get(\"OLLAMA_BASE_URL\", \"http://localhost:11434\").rstrip(\"/\"),\n        model=os.environ.get(\"OLLAMA_MODEL\", \"nemotron-3.5-lightning:30b-a3b-mlx\"),\n        keep_alive=os.environ.get(\"OLLAMA_KEEP_ALIVE\", \"15m\"),\n        request_timeout=float(os.environ.get(\"OLLAMA_TIMEOUT\", \"600\")),\n    )\n```\n\nNote: The default `OLLAMA_TIMEOUT` is set to `600` seconds to gracefully handle cold-starting a massive ∼19 GB∼19 GB model artifact without throwing premature timeouts.   \n\n## \n  Resilient Ollama Client (`moe_demo/ollama_client.py`)\n\nThe client wraps Ollama's REST API (`/api/version`, `/api/tags`, `/api/ps`, `/api/generate`, and `/api/chat`), translating raw HTTP errors into a clean exception hierarchy:\n\n```\nclass OllamaError(Exception): ...\nclass OllamaConnectionError(OllamaError): ...\nclass OllamaModelNotFound(OllamaError): ...\nclass OllamaTimeout(OllamaError): ...\n```\n\nDuring streaming chat completions, NDJSON response streams are safely parsed into typed `StreamEvent` objects, separating thinking/reasoning blocks (`thinking`) from final generation tokens (` content`) and server statistics (` done`):\n\n```\nfor line in resp.iter_lines():\n    if not line:\n        continue\n    data = json.loads(line)\n    if \"error\" in data:\n        raise OllamaError(str(data[\"error\"]))\n    msg = data.get(\"message\") or {}\n    if msg.get(\"thinking\"):\n        yield StreamEvent(\"thinking\", msg[\"thinking\"])\n    if msg.get(\"content\"):\n        yield StreamEvent(\"content\", msg[\"content\"])\n    if data.get(\"done\"):\n        yield StreamEvent(\"done\", stats=data)\n```\n\n## \n  UI-Agnostic Generation Engine (`moe_demo/engine.py`)\n\nThe engine converts user parameters into validated option payloads and manages conversation window constraints:\n\n``` php\n\"\"\"UI-independent generation logic: parameters -> Ollama request -> live metrics.\n\nKeeping this separate from Streamlit makes it unit-testable against a stub Ollama server.\n\"\"\"\nfrom __future__ import annotations\n\nimport time\nfrom dataclasses import dataclass\nfrom typing import Iterator\n\nfrom .metrics import RunMetrics, from_stats\nfrom .ollama_client import OllamaClient\n\nTHINK_MODES = (\"Auto (per category)\", \"Off\", \"On\", \"Medium\")\n\ndef build_options(temperature: float, top_p: float, num_ctx: int, num_predict: int) -> dict:\n    \"\"\"Map UI values to Ollama `options`. These are re-read on every request, so changing a\n    slider affects the very next message.\"\"\"\n    if not 0.0 <= temperature <= 2.0:\n        raise ValueError(\"temperature must be within 0..2\")\n    if not 0.0 < top_p <= 1.0:\n        raise ValueError(\"top_p must be within (0, 1]\")\n    if num_ctx < 512:\n        raise ValueError(\"num_ctx must be at least 512\")\n    return {\"temperature\": temperature, \"top_p\": top_p, \"num_ctx\": int(num_ctx),\n            \"num_predict\": int(num_predict)}\n\ndef resolve_think(mode: str, category_think: str) -> bool | str:\n    \"\"\"Translate the UI reasoning selector into the value of Ollama's `think` field.\n\n    The model accepts False, True or \"medium\" (see `ollama show`).\"\"\"\n    chosen = category_think if mode.startswith(\"Auto\") else mode.lower()\n    if chosen == \"off\":\n        return False\n    if chosen == \"medium\":\n        return \"medium\"\n    if chosen == \"on\":\n        return True\n    raise ValueError(f\"unknown reasoning mode: {mode!r}\")\n\ndef build_messages(system_prompt: str, history: list[dict], prompt: str,\n                   use_history: bool, max_turns: int = 6) -> list[dict]:\n    \"\"\"System prompt + (optionally) the last `max_turns` turns of the conversation + new prompt.\"\"\"\n    messages: list[dict] = []\n    if system_prompt:\n        messages.append({\"role\": \"system\", \"content\": system_prompt})\n    if use_history:\n        for m in history[-max_turns * 2:]:\n            if m[\"role\"] in (\"user\", \"assistant\") and m.get(\"content\"):\n                messages.append({\"role\": m[\"role\"], \"content\": m[\"content\"]})\n    messages.append({\"role\": \"user\", \"content\": prompt})\n    return messages\n\n@dataclass\nclass LiveUpdate:\n    \"\"\"Snapshot yielded while streaming.\"\"\"\n    content: str\n    thinking: str\n    chunks: int                 # streamed chunks ~ tokens (live approximation)\n    elapsed: float\n    ttft: float\n    live_tps: float             # approximate until the final exact metrics arrive\n    final: RunMetrics | None = None\n\ndef stream_answer(client: OllamaClient, model: str, messages: list[dict], options: dict,\n                  think: bool | str, keep_alive: str) -> Iterator[LiveUpdate]:\n    \"\"\"Stream a reply and yield LiveUpdate objects; the last one carries exact `final` metrics.\"\"\"\n    start = time.perf_counter()\n    first: float | None = None\n    content, thinking, chunks = \"\", \"\", 0\n    for ev in client.chat_stream(model, messages, options=options, think=think, keep_alive=keep_alive):\n        now = time.perf_counter()\n        if ev.kind in (\"content\", \"thinking\"):\n            if first is None:\n                first = now - start\n            chunks += 1\n            if ev.kind == \"content\":\n                content += ev.text\n            else:\n                thinking += ev.text\n            gen_time = max(now - start - (first or 0), 1e-6)\n            yield LiveUpdate(content, thinking, chunks, now - start, first or 0.0,\n                             chunks / gen_time if chunks > 1 else 0.0)\n        elif ev.kind == \"done\":\n            wall = now - start\n            final = from_stats(ev.stats, ttft=first or wall, wall=wall)\n            yield LiveUpdate(content, thinking, chunks, wall, first or wall, final.tokens_per_second, final)\n\ndef reasoning_share(thinking: str, content: str) -> float:\n    \"\"\"Fraction of streamed characters that belong to the reasoning trace (0..1).\"\"\"\n    total = len(thinking) + len(content)\n    return len(thinking) / total if total else 0.0\n```\n\nTo prevent unbounded context bloat during long sessions, `build_messages()` automatically caps history to the last 6 turns while preserving system instructions.\n\n## \n  Exact Metric Conversion (`moe_demo/metrics.py`)\n\nOllama returns internal run durations natively in nanoseconds. The metrics module transforms these numbers into actionable engineering metrics, calculating decode speed exclusively over evaluation duration (`eval_duration`) to avoid diluting performance stats with prefill phase latencies:\n\n```\n\"\"\"Inference metrics derived from Ollama's final streaming chunk plus client-side timing.\n\nOllama reports durations in nanoseconds. All values here are *measured*, not estimated.\n\"\"\"\nfrom __future__ import annotations\n\nfrom dataclasses import asdict, dataclass\nfrom typing import Any\n\nNS = 1_000_000_000.0\n\n@dataclass\nclass RunMetrics:\n    prompt_tokens: int = 0\n    generated_tokens: int = 0          # includes reasoning (\"thinking\") tokens\n    load_seconds: float = 0.0          # time spent loading the model into memory\n    prompt_eval_seconds: float = 0.0\n    generation_seconds: float = 0.0\n    total_seconds: float = 0.0         # server-side total\n    ttft_seconds: float = 0.0          # client-side time to first streamed token\n    wall_seconds: float = 0.0          # client-side end-to-end\n\n    @property\n    def tokens_per_second(self) -> float:\n        \"\"\"Generation speed (decode phase).\"\"\"\n        return self.generated_tokens / self.generation_seconds if self.generation_seconds > 0 else 0.0\n\n    @property\n    def prompt_tokens_per_second(self) -> float:\n        return self.prompt_tokens / self.prompt_eval_seconds if self.prompt_eval_seconds > 0 else 0.0\n\n    @property\n    def total_tokens(self) -> int:\n        return self.prompt_tokens + self.generated_tokens\n\n    def to_dict(self) -> dict[str, Any]:\n        d = asdict(self)\n        d[\"tokens_per_second\"] = round(self.tokens_per_second, 2)\n        d[\"prompt_tokens_per_second\"] = round(self.prompt_tokens_per_second, 2)\n        d[\"total_tokens\"] = self.total_tokens\n        return d\n\ndef from_stats(stats: dict[str, Any], ttft: float = 0.0, wall: float = 0.0) -> RunMetrics:\n    \"\"\"Build RunMetrics from the `done` chunk of /api/chat.\"\"\"\n    return RunMetrics(\n        prompt_tokens=int(stats.get(\"prompt_eval_count\") or 0),\n        generated_tokens=int(stats.get(\"eval_count\") or 0),\n        load_seconds=(stats.get(\"load_duration\") or 0) / NS,\n        prompt_eval_seconds=(stats.get(\"prompt_eval_duration\") or 0) / NS,\n        generation_seconds=(stats.get(\"eval_duration\") or 0) / NS,\n        total_seconds=(stats.get(\"total_duration\") or 0) / NS,\n        ttft_seconds=ttft,\n        wall_seconds=wall,\n    )\n\ndef active_fractions(total_params_b: float = 30.0, active_params_b: float = 3.0,\n                     n_experts: int = 128, top_k: int = 6) -> dict[str, float]:\n    \"\"\"Sparsity facts from the published model card: share of weights / experts used per token.\"\"\"\n    return {\n        \"active_param_fraction\": active_params_b / total_params_b,\n        \"active_expert_fraction\": top_k / n_experts,\n    }\n```\n\n## \n  Deterministic Expert Routing Simulation (`moe_demo/router_sim.py`)\n\nTo visualize how sparsity behaves across different task types (e.g., Code vs. Creative Writing vs. Factual Q&A), the simulator models top-6 selections out of 128 total experts (grouped into 8 semantic categories).\n\nUsing `blake2b` hashing on individual token-expert pairs ensures the simulation is **completely deterministic**—the same prompt always produces identical heatmap visualizations—while maintaining realistic variance:\n\n```\n\"\"\"Deterministic *simulation* of top-k expert routing, for visualisation only.\n\nWhy a simulation?  Ollama gives no access to the router's per-token decisions. To still let users\n*see* the idea of sparse routing we mimic it:\n\n* 128 routed experts (as in the published Nemotron 3.5 Lightning card), 6 chosen per token.\n* The experts are arranged in 8 groups of 16 (see `categories.EXPERT_GROUPS`).\n* Each token gets a score for every expert = category affinity of the expert's group\n  + a deterministic pseudo-random \"token-specific\" component (hash of token and expert id).\n  The top-k scores win. That mimics a learned router: a soft preference for the right\n  specialists, but with token-level variety, so several groups are used per category.\n\nThe result is reproducible (same prompt -> same picture) and is NOT telemetry from the model.\n\"\"\"\nfrom __future__ import annotations\n\nimport hashlib\nimport re\nfrom dataclasses import dataclass\n\nfrom .categories import CATEGORIES, EXPERT_GROUPS\n\nN_EXPERTS = 128\nTOP_K = 6\nGROUP_SIZE = N_EXPERTS // len(EXPERT_GROUPS)  # 16\nAFFINITY_STRENGTH = 0.5   # how strongly category affinity biases the router vs. token noise\nMAX_TOKENS = 200          # cap simulated tokens so very long prompts stay cheap\n\n@dataclass\nclass RoutingResult:\n    category: str\n    n_tokens: int\n    expert_counts: list[int]            # length 128: how many tokens selected each expert\n    group_share: dict[str, float]       # group -> share of all expert selections (sums to 1)\n    top_experts: list[tuple[int, int]]  # (expert id, count), most used first\n\ndef group_of(expert_id: int) -> int:\n    return expert_id // GROUP_SIZE\n\ndef _noise(token: str, expert_id: int) -> float:\n    \"\"\"Deterministic pseudo-random value in [0, 1) for a (token, expert) pair.\"\"\"\n    digest = hashlib.blake2b(f\"{token}|{expert_id}\".encode(), digest_size=4).digest()\n    return int.from_bytes(digest, \"big\") / 2**32\n\ndef tokenize(text: str) -> list[str]:\n    \"\"\"Cheap word/punctuation tokenizer; only used to size the simulation.\"\"\"\n    return re.findall(r\"\\w+|[^\\w\\s]\", text.lower())[:MAX_TOKENS]\n\ndef route_token(token: str, category_key: str) -> list[int]:\n    \"\"\"Return the TOP_K expert ids chosen for one token under the given category.\"\"\"\n    affinity = CATEGORIES[category_key].expert_affinity\n    scores = []\n    for e in range(N_EXPERTS):\n        group_name = EXPERT_GROUPS[group_of(e)]\n        scores.append((AFFINITY_STRENGTH * affinity.get(group_name, 0.0) + _noise(token, e), e))\n    scores.sort(reverse=True)\n    return [e for _, e in scores[:TOP_K]]\n\ndef simulate(text: str, category_key: str) -> RoutingResult:\n    \"\"\"Simulate routing of every token of `text` and aggregate the selections.\"\"\"\n    if category_key not in CATEGORIES:\n        raise ValueError(f\"unknown category: {category_key}\")\n    tokens = tokenize(text) or [\"<empty>\"]\n    counts = [0] * N_EXPERTS\n    for tok in tokens:\n        for e in route_token(tok, category_key):\n            counts[e] += 1\n    total = sum(counts)\n    group_totals = [0] * len(EXPERT_GROUPS)\n    for e, c in enumerate(counts):\n        group_totals[group_of(e)] += c\n    share = {EXPERT_GROUPS[i]: group_totals[i] / total for i in range(len(EXPERT_GROUPS))}\n    top = sorted(((e, c) for e, c in enumerate(counts) if c), key=lambda x: (-x[1], x[0]))[:10]\n    return RoutingResult(category_key, len(tokens), counts, share, top)\ndef _noise(token: str, expert_id: int) -> float:\n    \"\"\"Deterministic pseudo-random value in [0, 1) for a (token, expert) pair.\"\"\"\n    digest = hashlib.blake2b(f\"{token}|{expert_id}\".encode(), digest_size=4).digest()\n    return int.from_bytes(digest, \"big\") / 2**32\n\ndef route_token(token: str, category_key: str) -> list[int]:\n    affinity = CATEGORIES[category_key].expert_affinity\n    scores = []\n    for e in range(N_EXPERTS):\n        group_name = EXPERT_GROUPS[group_of(e)]\n        scores.append((AFFINITY_STRENGTH * affinity.get(group_name, 0.0) + _noise(token, e), e))\n    scores.sort(reverse=True)\n    return [e for _, e in scores[:TOP_K]]\n```\n\n## \n  Conclusion & Key Takeaways\n\nThe `nvidia-nemotron-lightning-35-test` project demonstrates that local MoE applications can be robust, highly performant, and transparent. Key takeaways from this architecture include:   \n\n1. \n**Extreme Economic Viability:** Activating only 3B out of 30B parameters dramatically drops inference cost and latency, making high-frequency agentic loops viable on standard hardware.\n2. \n**Decoupled Architecture:** Cleanly separating Ollama API plumbing (`ollama_client.py` ) and parameter validation (`engine.py` ) from GUI code (`app.py` ) allows for comprehensive unit testing and flexible deployment.\n3. \n**Radical Transparency:** Explicitly separating measured backend metrics from illustrative routing simulations sets a gold standard for building trust in specialized AI tooling.\n\n**Thanks for reading** 👨🔧\n\n# \n  References & Links\n\n- **Code Repository:**[GitHub - aairom/nvidia-nemotron-lightning-35-test](https://www.google.com/search?q=https://github.com/aairom/nvidia-nemotron-lightning-35-test)\n- **Model on Hugging Face:**[nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4](https://huggingface.co/nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-NVFP4)\n- **NVIDIA Research:**[Nemotron 3.5 Super and Lightning](https://research.nvidia.com/labs/nemotron/Nemotron-3.5-Super-and-Lightning/)\n- **Ollama Library:**[Nemotron 3.5 Lightning on Ollama](https://ollama.com/library/nemotron-3.5-lightning)", "url": "https://wpnews.pro/news/inside-nvidia-nemotron-3-5-lightning-building-a-local-mixture-of-experts", "canonical_source": "https://dev.to/aairom/inside-nvidia-nemotron-35-lightning-building-a-local-mixture-of-experts-explorer-566h", "published_at": "2026-11-17 16:56:48+00:00", "updated_at": "2026-11-17 20:17:59.485285+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "large-language-models", "ai-tools", "mlops"], "entities": ["NVIDIA", "Nemotron 3.5 Lightning", "Ollama", "vLLM", "llama.cpp", "LoRA", "NeMo Switchyard"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/inside-nvidia-nemotron-3-5-lightning-building-a-local-mixture-of-experts", "markdown": "https://wpnews.pro/news/inside-nvidia-nemotron-3-5-lightning-building-a-local-mixture-of-experts.md", "text": "https://wpnews.pro/news/inside-nvidia-nemotron-3-5-lightning-building-a-local-mixture-of-experts.txt", "jsonld": "https://wpnews.pro/news/inside-nvidia-nemotron-3-5-lightning-building-a-local-mixture-of-experts.jsonld"}}