Update README.md

README.md

@@ -6,7 +6,9 @@ license: apache-2.0
 tags:
 - code
 - reasoning
-- moe
+- gguf
+- ollama
+- llama-cpp
 - code-generation
 - instruction-tuned
 - nim-ai
@@ -19,20 +21,30 @@ inference: false
 
 <p align="center">
   <b>Developed by NIM-AI</b><br>
-  <i>A Sparse Mixture-of-Experts (MoE) Reasoning Model Built for Advanced Software Engineering</i>
+  <i>A Sparse Mixture-of-Experts (MoE) Reasoning Engine for Production Software Engineering</i>
 </p>
 
 ---
 
 ## Overview
 
-**NIM 3 - Coder - 30B** is NIM-AI's flagship 30-billion-parameter coding model. Built around a high-efficiency **Sparse Mixture-of-Experts (MoE)** architecture, the model dynamically routes token predictions through specialized expert pathways—activating only **~3 billion parameters per token**. This design provides the knowledge capacity, architectural comprehension, and multi-file reasoning of a 30B-scale system while delivering the token generation speeds and hardware efficiency of a compact model.
+**NIM 3 - Coder - 30B** is NIM-AI's high-efficiency coding and reasoning model, packaged in optimized **GGUF format** for fast local execution. Built on a **Sparse Mixture-of-Experts (MoE)** architecture, the model routes token predictions dynamically through dedicated expert networks, activating approximately **3 billion parameters per token** out of its total 30.5-billion-parameter pool.
 
-NIM 3 - Coder is trained with an explicit **Chain-of-Thought (CoT)** reasoning objective. Before synthesizing code, the model outputs structured `<think>...</think>` traces to systematically evaluate:
-- Edge cases, boundary conditions, and race conditions
-- Time and space complexity trade-offs
-- Concurrency patterns (async IO, locks, channels, thread-pool safety)
-- Architectural integrity and clean idiomatic idioms across systems and web stacks
+This provides the architectural reasoning and comprehension of a 30B-class model while preserving the execution speed, low latency, and memory footprint of a lightweight system.
+
+NIM 3 - Coder is trained with an explicit **Chain-of-Thought (CoT)** objective. Prior to synthesizing code, the engine outputs deliberative `<think>...</think>` traces to systematically evaluate:
+- Concurrency patterns, async runtimes, and thread safety
+- Boundary conditions, resource allocation, and edge cases
+- Algorithmic complexity and execution bottlenecks
+- Clean, idiomatic implementation patterns across production stacks
+
+---
+
+## Available Files
+
+| Filename | Quantization | Size | Description |
+| :--- | :--- | :--- | :--- |
+| `Qwen3-30B-A3B.Q4_K_M.gguf` | Q4_K_M | ~18.6 GB | Balanced 4-bit medium quantization. Recommended balance of reasoning fidelity and speed. |
 
 ---
 
@@ -41,38 +53,70 @@ NIM 3 - Coder is trained with an explicit **Chain-of-Thought (CoT)** reasoning o
 | Parameter | Specification |
 | :--- | :--- |
 | **Total Parameters** | 30.5 Billion |
-| **Active Parameters per Token** | ~3.0 Billion (Sparse Dynamic Routing) |
-| **Architecture** | Causal Language Model with Fine-Grained MoE Routing |
-| **Context Window** | 4,096 tokens (Expandable via RoPE scaling to 32k) |
-| **Primary Focus** | Systems Programming, High-Concurrency Architectures, Full-Stack Optimization |
+| **Active Parameters / Token** | ~3.0 Billion (Sparse Dynamic Routing) |
+| **Format** | GGUF (Ready for Ollama, llama.cpp, and LM Studio) |
+| **Context Window** | 4,096 tokens (Native, scalable via RoPE) |
 | **Primary Languages** | Rust, Python, Go, TypeScript/JavaScript, C++, SQL, Bash |
-| **Quantization Formats** | BF16, FP8, Q4_K_M GGUF |
+| **Specialization** | Systems Architecture, Concurrency, Algorithmic Optimization, Backend Pipelines |
 
 ---
 
-## Training & Alignment Methodology
-
-NIM 3 - Coder was developed using targeted response-based knowledge distillation from frontier reasoning engines, combined with senior-engineer synthetic curation across complex development scenarios:
-1. **Algorithmic Edge-Case Synthesis:** Verification-driven problem sets covering dynamic programming, graph invariants, memory-safe data structures, and custom allocators.
-2. **Production Systems & Concurrency:** Real-world workloads including distributed consensus protocols, deadlock resolution, zero-copy buffer networking, and database indexing/query planning.
-3. **Reasoning Trace Supervision:** Supervised fine-tuning (SFT) enforcing strict `<think>` token boundaries, ensuring the model internally plans algorithmic steps before outputting executable code.
-
----
+## Quickstart Guide
 
-## Prompt Template
+### 1. Run Instantly with Ollama
 
-NIM 3 - Coder utilizes the **ChatML** prompt format. To elicit deliberate reasoning, maintain the system instruction instructing the model to use thinking tags:
+You can pull and launch NIM 3 - Coder directly using Ollama without manual file downloads:
 
-<|im_start|>system You are NIM 3 - Coder, a world-class software engineer. Always think step-by-step inside ... tags before writing clean, high-performance code.<|im_end|> <|im_start|>user {instruction}<|im_end|> <|im_start|>assistant {reasoning}
-{code}
+```bash
+ollama run hf.co/NIM-AI/NIM-3-Coder-30B:Q4_K_M
+
+To create a custom local alias in Ollama, create a file named Modelfile:
+FROM ./Qwen3-30B-A3B.Q4_K_M.gguf
+
+TEMPLATE """<|im_start|>system
+{{ .System }}<|im_end|>
+<|im_start|>user
+{{ .Prompt }}<|im_end|>
+<|im_start|>assistant
+"""
+
+PARAMETER stop "<|im_start|>"
+PARAMETER stop "<|im_end|>"
+PARAMETER temperature 0.6
+
+Then build and launch:
+ollama create nim-3-coder -f Modelfile
+ollama run nim-3-coder
+
+Run an OpenAI-compatible API server on your local machine or cloud GPU:
+./llama-server \
+    -m Qwen3-30B-A3B.Q4_K_M.gguf \
+    --port 8000 \
+    --ctx-size 4096 \
+    --n-gpu-layers 99 \
+    --host 0.0.0.0
+
+Desktop Inference via LM Studio
+Open LM Studio.
+Search for NIM-AI/NIM-3-Coder-30B in the search bar.
+Download the Q4_K_M file and load it into the local chat interface.
+
+Prompt Template
+NIM 3 - Coder utilizes the standard ChatML format. Maintain the system prompt to trigger reasoning blocks:
+<|im_start|>system
+You are NIM 3 - Coder, a world-class software engineer. Always think step-by-step inside <think>...</think> tags before writing clean, high-performance code.<|im_end|>
+<|im_start|>user
+{prompt}<|im_end|>
+<|im_start|>assistant
+<think>
+{reasoning}
+</think>
+
+{solution}
 <|im_end|>
 
----
-
-## Quickstart & Deployment
-
-### 1. Run Locally via Ollama (Recommended)
-You can run the official 4-bit quantized GGUF directly using Ollama:
-
-```bash
-ollama run hf.co/NIM-AI/NIM-3-Coder-30B-GGUF:Q4_K_M
+Usage Guidelines & Notes
+Thinking Output: The model generates reasoning traces inside <think>...</think>. If integrating with an IDE agent or terminal pipe, ensure your interface supports streaming or extracts the content past </think>.
+Hardware Sizing: Because the full 30.5B expert weights reside in memory, running the Q4_K_M binary requires ~19 GB of memory headroom (GPU VRAM or shared unified memory on Apple Silicon).
+Organization & Contact
+Engineered and maintained by NIM-AI. For enterprise configurations, updates, and ecosystem tooling, visit the NIM-AI Organization Hub.