Updated AI21-Jamba-Reasoning-3B-GGUF model card content

This PR updates the AI21-Jamba-Reasoning-3B-GGUF model card with the latest images for the graphs.

Note: I’ve left placeholders for the following items:
- Graphs (waiting for approval of the images added here)
- Code snippet
- Link to the related blog

Please review and approve the images before we fill in the remaining placeholders.
Once approved, I will update the card with the final code snippet and blog link.

README.md

@@ -5,3 +5,240 @@ license_link: https://www.ai21.com/jamba-open-model-license/
 pipeline_tag: text-generation
 library_name: transformers
 ---
+## Introduction
+
+AI21’s Jamba Reasoning 3B is a top-performing reasoning model that packs leading scores on intelligence benchmarks and highly-efficient processing into a compact 3B build. 
+
+### Key Advantages
+
+**Fast: Optimized for efficient sequence processing**
+
+The hybrid design combines Transformer attention with Mamba (a state-space model). Mamba layers are more efficient for sequence processing, while attention layers capture complex dependencies. This mix reduces memory overhead, improves throughput, and makes the model run smoothly on laptops, GPUs, and even mobile devices, while maintainig impressive quality. 
+
+*Placeholder graph: Intelligence vs Speed*
+
+
+
+**Smart: Leading intelligence scores** 
+The model outperforms competitors, such as Gemma 3 4B, Llama 3.2 3B, and Granite 4.0 Micro, on a combined intelligence score that averages 6 standard benchmarks.  
+
+*Placeholder graph: MMLU + HLE + IFBench*
+
+
+
+**Scalable: Handles very long contexts**
+
+Unlike most compact models, Jamba Reasoning 3B supports extremely long contexts. Mamba layers allow the model to process inputs without storing massive attention caches, so it scales to **256K tokens** while keeping inference practical. This makes it suitable for edge deployment as well as datacenter workloads.
+*Placeholder graph: On-Device Speed as Context Scales*
+
+
+
+## Model Details
+
+- Number of Parameters: 3B
+- Number of Layers: 28 (26 Mamba, 2 Attention)
+- Number of Attention Heads: 20 MQA (20 for Q, 1 for KV)
+- Vocabulary Size: 64K
+- Context Length: **256k**
+- Architecture: Hybrid Transformer–Mamba with efficient attention and long-context support
+- **Developed by:** [**AI21**](https://www.ai21.com/)
+- **Supported languages:** English, Spanish, French, Portuguese, Italian, Dutch, German, Arabic and Hebrew
+- Intelligence benchmark results:
+
+|  | **MMLU-Pro** | **Humanity’s Last Exam** | **IFBench** |
+| --- | --- | --- | --- |
+| DeepSeek R1 Distill Qwen 1.5B | 27.0% | 3.3% | 13.0% |
+| Phi-4 mini | 47.0% | 4.2% | 21.0% |
+| Granite 4.0 Micro | 44.7% | 5.1% | 24.8% |
+| Llama 3.2 3B | 35.0% | 5.2% | 26.0% |
+| Gemma 3 4B | 42.0% | 5.2% | 28.0% |
+| Qwen 3 1.7B | 57.0% | 4.8% | 27.0% |
+| Qwen 3 4B | 70% | 5.1% | 0.33 |
+| **Jamba Reasoning 3B** | **61.0%** | **6.0%** | **52.0%** |
+
+## Quickstart
+
+**Extended version** – reasoning mode example with `<think>` block and recommended sampling params.
+Code Snippet Placeholder
+
+### **Run the model with vLLM**
+
+For best results, we recommend using vLLM version 0.10.2 or higher and enabling `--mamba-ssm-cache-dtype=float32` 
+
+```jsx
+pip install vllm>=0.10.2
+```
+
+Using vllm in online server mode:
+
+```jsx
+vllm serve "ai21labs/AI21-Jamba-Reasoning-3B" --mamba-ssm-cache-dtype float32 --reasoning-parser deepseek_r1 --enable-auto-tool-choice --tool-call-parser hermes
+```
+
+Using vllm in offline mode:
+
+```jsx
+from vllm import LLM, SamplingParams
+from transformers import AutoTokenizer
+
+model = "ai21labs/AI21-Jamba-Reasoning-3B"
+number_gpus = 1
+
+llm = LLM(model=model,
+          tensor_parallel_size=number_gpus,
+          mamba_ssm_cache_dtype="float32")
+
+tokenizer = AutoTokenizer.from_pretrained(model)
+
+messages = [
+    {"role": "user", "content": "Hello!"},
+]
+
+prompts = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+
+sampling_params = SamplingParams(temperature=0.6, max_tokens=4096)
+outputs = llm.generate(prompts, sampling_params)
+
+generated_text = outputs[0].outputs[0].text
+print(generated_text)
+
+```
+
+### **Run the model with Transformers**
+
+```jsx
+pip install transformers>= 4.54.0
+pip install flash-attn --no-build-isolation
+pip install causal-conv1d>=1.2.0
+pip install mamba-ssm
+```
+
+```jsx
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = AutoModelForCausalLM.from_pretrained("ai21labs/AI21-Jamba-Reasoning-3B",
+                                             dtype=torch.bfloat16,
+                                             attn_implementation="flash_attention_2",
+                                             device_map="auto")
+
+tokenizer = AutoTokenizer.from_pretrained("ai21labs/AI21-Jamba-Reasoning-3B")
+
+messages = [
+    {"role": "user", "content": "Hello!"},
+]
+
+prompts = tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+
+outputs = model.generate(**tokenizer(prompts, return_tensors="pt").to(model.device), do_sample=True, temperature=0.6, max_new_tokens=4096)
+
+generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+print(generated_text)
+```
+
+## **How to Run This Model Locally**
+
+You can run Jamba Reasoning 3B on your own machine using popular lightweight runtimes. This makes it possible to experiment with long-context reasoning without relying on cloud infrastructure.
+
+- **Supported runtimes**: [llama.cpp](https://github.com/ggml-org/llama.cpp), [LM Studio](https://lmstudio.ai/), and [Ollama](https://ollama.com/).
+- **Quantizations**: Multiple quantization levels  are provided to shrink the model size.
+    - Full precision FP16 GGUF - **5.96** GB
+    - 4 bit quantization using Q4-K-M GGUF - **1.80** GB
+    - More GGUF quantizations - TBD
+
+## Deployment
+
+- Support for **Ollama** , **LMStudio** and **llama.cpp** (for local use)
+    1. llama.cpp using llama.cpp Python sdk run example:
+        
+        
+        ```python
+        pip install --upgrade llama-cpp-python
+        ```
+        
+        ```python
+        from llama_cpp import Llama
+        
+        llm = Llama(
+            model_path="path-to-Jamba-Reasoning-3B-gguf",
+            n_ctx=128000,
+            n_threads=10,        # CPU threads
+            n_gpu_layers=-1,     # -1 = all layers on GPU (Metal/CUDA if available)
+            flash_attn=True,
+        )
+        
+        prompt =  """<think>
+        You are analyzing a stream of customer support tickets to decide which ones require escalation.
+        
+        Ticket 1: "The new update caused our app to crash whenever users upload a file larger than 50MB."
+        Ticket 2: "I can't log in because I forgot my password."
+        Ticket 3: "The billing page is missing the new enterprise pricing option."
+        
+        Classify each ticket as 'Critical', 'Medium', or 'Low' priority and explain your reasoning.
+        </think>"""
+        res = llm(
+            prompt,
+            max_tokens=128,
+            temperature=0.6,
+        )
+        
+        print(res["choices"][0]["text"])
+        ```
+        
+        2. llama.cpp using llama.cpp server:
+        
+        ```bash
+        git clone https://github.com/ggerganov/llama.cpp.git
+        cd llama.cpp
+        cmake -S . -B build \
+          -DGGML_METAL=ON \
+          -DGGML_METAL_EMBED_LIBRARY=ON
+        cmake --build build --config Release -j
+        ```
+        
+        Start llama.cpp server with Jamba-Reasoning-3B gguf:
+        
+        ```python
+        ./build/bin/llama-server \
+          -m "ai21labs/AI21-Jamba-Reasoning-3B-GGUF" \
+          -c 8192 \
+          -ngl 99 \
+          --host 127.0.0.1 \
+          --port 8000
+        ```
+        
+        Quick sanity test using curl:
+        
+        ```bash
+        curl -s http://127.0.0.1:8000/v1/completions \
+          -H "Content-Type: application/json" \
+          -d '{
+            "model": "Jamba-Reasoning-3B",
+            "prompt": "<think>\nYou are analyzing customer support tickets to decide which need escalation.\nTicket 1: 'App crashes when uploading files >50MB.'\nTicket 2: 'Forgot password, can’t log in.'\nTicket 3: 'Billing page missing enterprise pricing.'\nClassify each ticket as Critical, Medium, or Low and explain your reasoning.\n</think>",
+            "max_tokens": 64,
+            "temperature": 0.6
+          }' | jq -r '.choices[0].text'
+        ```
+        
+
+## Training Details
+
+We trained the model in multiple stages, each designed to strengthen reasoning and long-context performance. The process began with large-scale pre-training on a diverse corpus of natural documents. We then mid-trained on ~0.5T tokens of math and code, while extending the context length to 32K tokens. During this stage we also applied a [Mamba-specific long-context method](https://arxiv.org/abs/2507.02782), which we found to significantly improve long-context abilities.
+
+To improve reasoning, tool use, and instruction following, we applied cold-start distillation: supervised fine-tuning with a 32K window and direct preference optimization with a 64K window. Finally, we enhanced reasoning performance further through online reinforcement learning with RLVR, targeting tasks such as code generation, mathematical problem solving, structured output, and information extraction.
+
+## Reinforcement “Fine-Tuning”
+
+Full support for training Jamba through VeRL will be available soon. AI21 has introduced several improvements to the VeRL framework (https://github.com/volcengine/verl), including new capabilities for training hybrid models, and stability improvements for GRPO training. These improvements will soon be available to the open source community. 
+
+---
+
+## License
+
+- `Apache 2.0`
+
+---
+
+## Citation
+
+- Blog post- Placeholder