Initial release: SecurityGPT 14B

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gguf filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

DEPLOYMENT.md

@@ -0,0 +1,760 @@
+# SecurityGPT Deployment Guide
+
+Comprehensive guide for deploying SecurityGPT in various environments.
+
+## Table of Contents
+
+1. [Quick Start](#quick-start)
+2. [Hugging Face Hub](#hugging-face-hub)
+3. [Ollama Deployment](#ollama-deployment)
+4. [Docker Deployment](#docker-deployment)
+5. [API Server](#api-server)
+6. [Cloud Deployment](#cloud-deployment)
+7. [Production Considerations](#production-considerations)
+
+---
+
+## Quick Start
+
+### Option 1: Hugging Face Transformers (Simplest)
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "pki/securitygpt-14b"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+# Generate
+messages = [{"role": "user", "content": "Create a FastAPI endpoint"}]
+inputs = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True)
+outputs = model.generate(inputs.to("cuda"), max_new_tokens=512)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+```
+
+### Option 2: Ollama (Recommended for Production)
+
+```bash
+# Download GGUF model
+wget https://huggingface.co/pki/securitygpt-14b/resolve/main/securitygpt-14b-q8.gguf
+
+# Create Modelfile
+cat > Modelfile <<EOF
+FROM ./securitygpt-14b-q8.gguf
+PARAMETER temperature 0.7
+PARAMETER num_ctx 32768
+EOF
+
+# Deploy
+ollama create securitygpt:14b -f Modelfile
+ollama run securitygpt:14b
+```
+
+---
+
+## Hugging Face Hub
+
+### Upload Model to Hub
+
+**Prerequisites:**
+- Hugging Face account
+- Hub token with write access
+- git-lfs installed
+
+**Step 1: Install Requirements**
+```bash
+pip install huggingface_hub
+huggingface-cli login
+```
+
+**Step 2: Prepare Model Files**
+```bash
+cd llm-training-repo/models
+cp merged_gguf_q4/* ../huggingface/
+
+# Or upload merged PyTorch model
+cp -r merged_model/* ../huggingface/
+```
+
+**Step 3: Create Repository**
+```python
+from huggingface_hub import HfApi, create_repo
+
+api = HfApi()
+
+# Create repo
+repo_id = "pki/securitygpt-14b"
+create_repo(repo_id, private=False, repo_type="model")
+
+# Upload model files
+api.upload_folder(
+    folder_path="./huggingface",
+    repo_id=repo_id,
+    repo_type="model"
+)
+```
+
+**Step 4: Test Download**
+```python
+from transformers import AutoModelForCausalLM
+
+model = AutoModelForCausalLM.from_pretrained("pki/securitygpt-14b")
+```
+
+### Model Card on Hub
+
+The `MODEL_CARD.md` should be renamed to `README.md` in your Hub repo:
+
+```bash
+cp huggingface/MODEL_CARD.md huggingface/README.md
+```
+
+---
+
+## Ollama Deployment
+
+Ollama provides the easiest deployment for local and production use.
+
+### Local Deployment
+
+**Step 1: Install Ollama**
+```bash
+# Linux
+curl -fsSL https://ollama.com/install.sh | sh
+
+# macOS
+brew install ollama
+
+# Windows
+# Download from https://ollama.com/download
+```
+
+**Step 2: Get GGUF Model**
+
+Option A: Download from Hugging Face
+```bash
+wget https://huggingface.co/pki/securitygpt-14b/resolve/main/securitygpt-14b-q8.gguf
+```
+
+Option B: Convert locally (if you have PyTorch model)
+```bash
+# Clone llama.cpp
+git clone https://github.com/ggerganov/llama.cpp
+cd llama.cpp
+make
+
+# Convert
+python convert_hf_to_gguf.py /path/to/merged_model \
+  --outfile securitygpt-14b-f16.gguf --outtype f16
+
+# Quantize
+./llama-quantize securitygpt-14b-f16.gguf securitygpt-14b-q8.gguf Q8_0
+```
+
+**Step 3: Create Modelfile**
+```dockerfile
+FROM ./securitygpt-14b-q8.gguf
+
+PARAMETER temperature 0.7
+PARAMETER top_p 0.9
+PARAMETER top_k 50
+PARAMETER num_ctx 32768
+PARAMETER num_predict 2048
+PARAMETER stop "<|im_start|>"
+PARAMETER stop "<|im_end|>"
+
+TEMPLATE """<|im_start|>system
+{{ .System }}<|im_end|>
+<|im_start|>user
+{{ .Prompt }}<|im_end|>
+<|im_start|>assistant
+"""
+
+SYSTEM """You are SecurityGPT, a specialized AI assistant for secure software development. You follow security best practices including: argon2 password hashing (NEVER bcrypt), input validation, SQL injection prevention, XSS protection, proper authentication, and comprehensive error handling."""
+
+MESSAGE user "Create a FastAPI endpoint for user authentication"
+MESSAGE assistant "I'll create a secure FastAPI authentication endpoint with argon2 password hashing, JWT tokens, and proper validation..."
+```
+
+**Step 4: Deploy**
+```bash
+ollama create securitygpt:14b -f Modelfile
+ollama list  # Verify it's listed
+
+# Test
+ollama run securitygpt:14b "Create a secure login endpoint"
+```
+
+### Remote Deployment
+
+**Deploy to Remote Server:**
+```bash
+# Copy GGUF to server
+scp securitygpt-14b-q8.gguf user@server:/models/
+scp Modelfile user@server:/models/
+
+# SSH to server
+ssh user@server
+
+# Create model
+cd /models
+ollama create securitygpt:14b -f Modelfile
+
+# Serve (if not running)
+ollama serve
+```
+
+**Access remotely:**
+```bash
+# Set Ollama host
+export OLLAMA_HOST=http://server-ip:11434
+
+# Use
+ollama run securitygpt:14b "Your prompt"
+```
+
+### Ollama with Docker
+
+```bash
+# Run Ollama in container
+docker run -d \
+  --name ollama \
+  --gpus all \
+  -v ollama-data:/root/.ollama \
+  -p 11434:11434 \
+  ollama/ollama
+
+# Create model inside container
+docker exec -it ollama ollama create securitygpt:14b -f /path/to/Modelfile
+```
+
+---
+
+## Docker Deployment
+
+### Custom Docker Image
+
+**Dockerfile:**
+```dockerfile
+FROM nvidia/cuda:12.4.0-runtime-ubuntu22.04
+
+# Install Python
+RUN apt-get update && apt-get install -y \
+    python3.11 \
+    python3-pip \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# Copy model (or download in entrypoint)
+COPY merged_model /app/model
+
+# API server
+COPY api_server.py /app/
+WORKDIR /app
+
+EXPOSE 8000
+
+CMD ["python3", "api_server.py"]
+```
+
+**requirements.txt:**
+```
+transformers==4.57.3
+torch==2.5.0
+fastapi==0.110.0
+uvicorn[standard]==0.27.0
+pydantic==2.10.0
+```
+
+**api_server.py:**
+```python
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+app = FastAPI(title="SecurityGPT API")
+
+# Load model on startup
+@app.on_event("startup")
+async def load_model():
+    global model, tokenizer
+    model = AutoModelForCausalLM.from_pretrained(
+        "/app/model",
+        torch_dtype=torch.bfloat16,
+        device_map="auto"
+    )
+    tokenizer = AutoTokenizer.from_pretrained("/app/model")
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    max_tokens: int = 512
+    temperature: float = 0.7
+
+@app.post("/generate")
+async def generate(request: GenerateRequest):
+    try:
+        messages = [{"role": "user", "content": request.prompt}]
+        text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+        inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=request.max_tokens,
+            temperature=request.temperature
+        )
+
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return {"response": response}
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy"}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+```
+
+**Build and Run:**
+```bash
+docker build -t securitygpt:14b .
+
+docker run -d \
+  --name securitygpt-api \
+  --gpus all \
+  -p 8000:8000 \
+  securitygpt:14b
+```
+
+**Test:**
+```bash
+curl -X POST http://localhost:8000/generate \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "Create a FastAPI endpoint", "max_tokens": 512}'
+```
+
+---
+
+## API Server
+
+### FastAPI Server (Production-Ready)
+
+**server.py:**
+```python
+from fastapi import FastAPI, HTTPException, Depends, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel, Field
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Security
+security = HTTPBearer()
+
+app = FastAPI(
+    title="SecurityGPT API",
+    description="Secure code generation API",
+    version="1.0.0"
+)
+
+# Global model storage
+model = None
+tokenizer = None
+
+@app.on_event("startup")
+async def startup_event():
+    global model, tokenizer
+    logger.info("Loading SecurityGPT model...")
+
+    model = AutoModelForCausalLM.from_pretrained(
+        "pki/securitygpt-14b",
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        "pki/securitygpt-14b",
+        trust_remote_code=True
+    )
+
+    logger.info("Model loaded successfully")
+
+class GenerateRequest(BaseModel):
+    prompt: str = Field(..., min_length=1, max_length=8000)
+    system_prompt: str = Field(
+        default="You are a security-focused coding assistant.",
+        max_length=500
+    )
+    max_tokens: int = Field(default=512, ge=1, le=2048)
+    temperature: float = Field(default=0.7, ge=0.0, le=2.0)
+    top_p: float = Field(default=0.9, ge=0.0, le=1.0)
+
+class GenerateResponse(BaseModel):
+    response: str
+    tokens_generated: int
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)):
+    """Verify API token (implement your auth logic)."""
+    token = credentials.credentials
+    # TODO: Implement actual token verification
+    if token != "your-secret-token":
+        raise HTTPException(401, "Invalid token")
+    return token
+
+@app.post("/api/v1/generate", response_model=GenerateResponse)
+async def generate(
+    request: GenerateRequest,
+    token: str = Depends(verify_token)
+):
+    """Generate code based on prompt."""
+    try:
+        messages = [
+            {"role": "system", "content": request.system_prompt},
+            {"role": "user", "content": request.prompt}
+        ]
+
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True
+        )
+
+        inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=request.max_tokens,
+            temperature=request.temperature,
+            top_p=request.top_p,
+            do_sample=True
+        )
+
+        response_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        tokens_generated = len(outputs[0]) - len(inputs['input_ids'][0])
+
+        return GenerateResponse(
+            response=response_text,
+            tokens_generated=tokens_generated
+        )
+
+    except Exception as e:
+        logger.error(f"Generation error: {str(e)}")
+        raise HTTPException(500, f"Generation failed: {str(e)}")
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=8000,
+        log_level="info"
+    )
+```
+
+**Run:**
+```bash
+python server.py
+```
+
+**Client Example:**
+```python
+import requests
+
+response = requests.post(
+    "http://localhost:8000/api/v1/generate",
+    headers={"Authorization": "Bearer your-secret-token"},
+    json={
+        "prompt": "Create a FastAPI user signup endpoint",
+        "max_tokens": 512,
+        "temperature": 0.7
+    }
+)
+
+print(response.json()['response'])
+```
+
+---
+
+## Cloud Deployment
+
+### AWS EC2
+
+**Instance Recommendations:**
+- **g5.xlarge** - 1x A10G (24GB VRAM) - $1.006/hr
+- **g5.2xlarge** - 1x A10G (24GB VRAM) + more CPU/RAM - $1.212/hr
+- **p3.2xlarge** - 1x V100 (16GB VRAM) - needs Q4 quantization
+
+**Setup:**
+```bash
+# Launch instance with Deep Learning AMI
+# SSH to instance
+
+# Install Ollama
+curl -fsSL https://ollama.com/install.sh | sh
+
+# Download model
+wget https://huggingface.co/pki/securitygpt-14b/resolve/main/securitygpt-14b-q8.gguf
+
+# Deploy
+ollama create securitygpt:14b -f Modelfile
+ollama serve
+```
+
+### Google Cloud Platform
+
+**Instance Recommendations:**
+- **n1-standard-4 + 1x NVIDIA T4** - $0.35/hr + $0.35/hr
+- **n1-standard-8 + 1x NVIDIA A100** - Better performance
+
+**Setup:**
+```bash
+# Create instance with GPU
+gcloud compute instances create securitygpt \
+  --zone=us-central1-a \
+  --machine-type=n1-standard-4 \
+  --accelerator=type=nvidia-tesla-t4,count=1 \
+  --image-family=pytorch-latest-gpu \
+  --image-project=deeplearning-platform-release
+
+# SSH and deploy
+gcloud compute ssh securitygpt
+# ... install Ollama and model
+```
+
+### Azure
+
+**VM Recommendations:**
+- **NC6s_v3** - 1x V100 (16GB) - Q4 quantization required
+- **NC24ads_A100_v4** - 1x A100 (80GB) - Full model + headroom
+
+### Runpod / Lambda Labs / Vast.ai
+
+**Budget GPU Cloud Options:**
+
+```bash
+# Runpod example
+# 1. Create pod with RTX 4090
+# 2. Use Jupyter or SSH template
+# 3. Deploy Ollama
+
+pip install runpod
+# ... follow Runpod deployment docs
+```
+
+---
+
+## Production Considerations
+
+### Performance Optimization
+
+**1. Quantization Choice**
+
+| Quantization | Size | VRAM | Quality | Speed |
+|--------------|------|------|---------|-------|
+| FP16         | 28GB | 28GB | Best    | Slowest |
+| Q8_0         | 15GB | 16GB | Excellent | Fast |
+| Q5_K_M       | 10GB | 12GB | Good | Faster |
+| Q4_K_M       | 8GB  | 10GB | Acceptable | Fastest |
+
+**Recommendation:** Q8_0 for production (best quality/speed trade-off)
+
+**2. Batching**
+
+```python
+# Process multiple prompts efficiently
+prompts = ["prompt1", "prompt2", "prompt3"]
+
+# Tokenize all at once
+inputs = tokenizer(prompts, return_tensors="pt", padding=True).to("cuda")
+
+# Generate batch
+outputs = model.generate(**inputs, max_new_tokens=512)
+
+# Decode all
+responses = tokenizer.batch_decode(outputs, skip_special_tokens=True)
+```
+
+**3. Caching**
+
+```python
+import redis
+import hashlib
+
+redis_client = redis.Redis(host='localhost', port=6379)
+
+def generate_cached(prompt: str):
+    # Check cache
+    cache_key = hashlib.sha256(prompt.encode()).hexdigest()
+    cached = redis_client.get(cache_key)
+
+    if cached:
+        return cached.decode()
+
+    # Generate
+    response = generate(prompt)
+
+    # Cache for 1 hour
+    redis_client.setex(cache_key, 3600, response)
+
+    return response
+```
+
+### Monitoring
+
+**Prometheus Metrics:**
+```python
+from prometheus_client import Counter, Histogram, Gauge
+import time
+
+requests_total = Counter('securitygpt_requests_total', 'Total requests')
+request_duration = Histogram('securitygpt_request_duration_seconds', 'Request duration')
+tokens_generated = Counter('securitygpt_tokens_generated_total', 'Total tokens generated')
+gpu_memory = Gauge('securitygpt_gpu_memory_bytes', 'GPU memory usage')
+
+@app.post("/generate")
+async def generate(request: GenerateRequest):
+    requests_total.inc()
+
+    start_time = time.time()
+
+    # ... generation logic ...
+
+    request_duration.observe(time.time() - start_time)
+    tokens_generated.inc(num_tokens)
+
+    # Update GPU memory
+    if torch.cuda.is_available():
+        gpu_memory.set(torch.cuda.memory_allocated())
+
+    return response
+```
+
+### Security
+
+**API Authentication:**
+```python
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import jwt
+
+SECRET_KEY = "your-secret-key"
+
+def verify_jwt(credentials: HTTPAuthorizationCredentials):
+    try:
+        payload = jwt.decode(credentials.credentials, SECRET_KEY, algorithms=["HS256"])
+        return payload
+    except:
+        raise HTTPException(401, "Invalid token")
+```
+
+**Rate Limiting:**
+```python
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+
+@app.post("/generate")
+@limiter.limit("10/minute")
+async def generate(request: Request, ...):
+    ...
+```
+
+### Scaling
+
+**Horizontal Scaling with Load Balancer:**
+
+```
+                    ┌─────────────┐
+                    │   Nginx LB  │
+                    └──────┬──────┘
+                           │
+        ┌─────────┬────────┼────────┬─────────┐
+        │         │        │        │         │
+   ┌────▼───┐ ┌──▼────┐ ┌─▼─────┐ ┌▼────────┐
+   │ API 1  │ │ API 2 │ │ API 3 │ │ API N   │
+   │+ Model │ │+ Model│ │+ Model│ │+ Model  │
+   └────────┘ └───────┘ └───────┘ └─────────┘
+```
+
+**Nginx config:**
+```nginx
+upstream securitygpt_backend {
+    server 10.0.1.10:8000;
+    server 10.0.1.11:8000;
+    server 10.0.1.12:8000;
+}
+
+server {
+    listen 80;
+    location /api {
+        proxy_pass http://securitygpt_backend;
+    }
+}
+```
+
+---
+
+## Troubleshooting
+
+### Model Won't Load
+
+**Check:**
+1. GPU availability: `nvidia-smi`
+2. VRAM sufficient for model size
+3. CUDA version compatible with PyTorch
+4. Model files not corrupted
+
+### Slow Inference
+
+**Check:**
+1. GPU utilization (`nvidia-smi`)
+2. Using CUDA (`model.device`)
+3. Quantization applied
+4. Batch size not too large
+
+### Out of Memory
+
+**Solutions:**
+1. Use smaller quantization (Q4 instead of Q8)
+2. Reduce context length
+3. Use gradient checkpointing
+4. Clear CUDA cache: `torch.cuda.empty_cache()`
+
+---
+
+## Support
+
+- **Issues:** GitHub/GitLab repository
+- **Discussions:** Hugging Face model page
+- **Documentation:** This deployment guide
+
+---
+
+**Ready to deploy!** Choose deployment method based on your needs:
+- **Development:** Local Ollama
+- **Production:** API server with Docker/K8s
+- **Cloud:** AWS/GCP/Azure with Ollama

README.md

@@ -0,0 +1,379 @@
+---
+language:
+- en
+license: apache-2.0
+base_model: Qwen/Qwen2.5-Coder-14B-Instruct
+tags:
+- security
+- code-generation
+- cybersecurity
+- fastapi
+- python
+- typescript
+- react
+- qlora
+- unsloth
+model_type: qwen2
+pipeline_tag: text-generation
+inference: true
+---
+
+# SecurityGPT 14B
+
+**SecurityGPT** is a 14-billion parameter code generation model fine-tuned for security-focused development tasks. Built on Qwen2.5-Coder-14B-Instruct, it specializes in generating secure, production-ready code with emphasis on best practices for web applications, API development, and cybersecurity.
+
+## Model Description
+
+- **Developed by:** [email protected]
+- **Model type:** Causal Language Model (Decoder-only Transformer)
+- **Language(s):** English
+- **Base model:** [Qwen/Qwen2.5-Coder-14B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-14B-Instruct)
+- **License:** Apache 2.0 (same as base model)
+- **Finetuned from:** Qwen2.5-Coder-14B-Instruct
+- **Context length:** 32,768 tokens
+- **Parameters:** 14 billion
+
+### Model Architecture
+
+```
+Architecture: Qwen2ForCausalLM
+- Hidden size: 5,120
+- Num layers: 48
+- Attention heads: 40
+- KV heads: 8 (GQA)
+- Intermediate size: 13,824
+- Vocab size: 152,064
+- RoPE theta: 1,000,000
+- Activation: SiLU
+```
+
+### Key Features
+
+✅ **Security-First Design**
+- Secure password hashing (argon2, NEVER bcrypt)
+- SQL injection prevention
+- XSS protection patterns
+- Input validation & sanitization
+- Proper authentication flows
+
+✅ **Best Practice Enforcement**
+- RESTful API design (`/api/v1/` versioning)
+- Modern dependency management (Poetry for Python)
+- Production-ready error handling
+- Comprehensive audit logging
+
+✅ **Technology Stack Coverage**
+- **Backend:** Python, FastAPI, Flask, SQLAlchemy
+- **Frontend:** React, TypeScript, Tailwind CSS
+- **Databases:** PostgreSQL, Redis, OpenSearch
+- **DevOps:** Docker, FreeBSD, GitLab CI/CD
+
+## Intended Use
+
+### Primary Use Cases
+
+1. **Secure API Development** - Generate FastAPI/Flask endpoints with proper authentication, validation, and error handling
+2. **Web Application Development** - Create React/TypeScript components following modern patterns
+3. **Security Code Review** - Identify and fix security vulnerabilities in existing code
+4. **Infrastructure as Code** - Generate secure deployment configurations
+5. **DevOps Automation** - Create CI/CD pipelines and automation scripts
+
+### Out-of-Scope Use
+
+⚠️ This model is NOT intended for:
+- Malicious code generation or exploit development
+- Production security auditing (use professional security tools)
+- Medical, legal, or financial advice
+- Real-time critical systems without human review
+
+## Training Details
+
+### Training Method
+
+**QLoRA (Quantized Low-Rank Adaptation)** using [Unsloth](https://github.com/unslothai/unsloth) for optimization.
+
+**LoRA Configuration:**
+```python
+Rank (r): 128
+Alpha: 256
+Dropout: 0 (Unsloth optimized)
+Target modules: q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj
+Quantization: 4-bit (QLoRA)
+```
+
+**Training Hyperparameters:**
+```python
+Batch size: 8 per device
+Gradient accumulation: 4 steps (effective batch = 32)
+Learning rate: 1e-4
+Epochs: 5
+Max sequence length: 2,048 tokens
+Optimizer: AdamW 8-bit
+LR scheduler: Cosine
+Weight decay: 0.01
+Precision: BF16 
+
+```
+
+### Training Data
+
+The model was fine-tuned on 16,000 instruction-output pairs focused on:
+- Secure coding patterns and practices
+- Web application development (FastAPI, React)
+- Database operations and security
+- Authentication and authorization
+- API design and implementation
+- DevOps and infrastructure configuration
+
+**Data composition:**
+- Security-focused coding examples
+- Real-world application patterns
+- Best practice demonstrations
+- Common vulnerability mitigations
+
+
+### Training Loss
+
+Final training loss: **0.026**
+
+## Usage
+
+### Quick Start with Transformers
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+
+# Load model and tokenizer
+model_name = "pki/securitygpt-14b"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+# Format prompt with Qwen chat template
+messages = [
+    {"role": "system", "content": "You are a helpful AI coding assistant specialized in secure software development."},
+    {"role": "user", "content": "Create a FastAPI endpoint for user signup with email and password validation."}
+]
+
+text = tokenizer.apply_chat_template(
+    messages,
+    tokenize=False,
+    add_generation_prompt=True
+)
+
+# Generate
+inputs = tokenizer([text], return_tensors="pt").to(model.device)
+outputs = model.generate(
+    **inputs,
+    max_new_tokens=1024,
+    temperature=0.4,
+    top_p=0.9,
+    do_sample=True
+)
+
+response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+print(response)
+```
+
+### Using with Ollama (Recommended for Deployment)
+
+**Step 1: Convert to GGUF** (if not already converted)
+```bash
+# Convert merged model to GGUF
+python llama.cpp/convert_hf_to_gguf.py merged_model/ \
+  --outfile securitygpt-14b-f16.gguf --outtype f16
+
+# Quantize for deployment (Q8 recommended)
+llama.cpp/llama-quantize \
+  securitygpt-14b-f16.gguf \
+  securitygpt-14b-q8.gguf Q8_0
+```
+
+**Step 2: Create Modelfile**
+```dockerfile
+FROM ./securitygpt-14b-q8.gguf
+
+PARAMETER temperature 0.5
+PARAMETER top_p 0.9
+PARAMETER num_ctx 32768
+PARAMETER stop "<|im_start|>"
+PARAMETER stop "<|im_end|>"
+
+TEMPLATE """<|im_start|>system
+You are a helpful AI coding assistant specialized in secure software development.<|im_end|>
+<|im_start|>user
+{{ .Prompt }}<|im_end|>
+<|im_start|>assistant
+"""
+
+SYSTEM """You are SecurityGPT, a specialized AI assistant for secure software development. You follow security best practices including: argon2 password hashing, input validation, SQL injection prevention, XSS protection, proper authentication, and comprehensive error handling."""
+```
+
+**Step 3: Deploy with Ollama**
+```bash
+ollama create securitygpt:14b -f Modelfile
+ollama run securitygpt:14b
+```
+
+### Example Prompts
+
+**1. Secure Authentication Endpoint**
+```
+Create a FastAPI endpoint for user login with JWT token generation.
+Use argon2 for password hashing and include proper error handling.
+```
+
+**2. React Component with Security**
+```
+Create a React login form component with email validation,
+password strength checking, and CSRF protection.
+```
+
+**3. Database Security**
+```
+Write a SQLAlchemy model for user authentication with
+secure password storage and audit logging.
+```
+
+**4. API Security Review**
+```
+Review this API endpoint for security vulnerabilities:
+[paste code]
+```
+
+## Performance & Benchmarks
+
+### Response Quality
+- **Code correctness:** High (generates syntactically correct code)
+- **Security adherence:** Excellent (consistently applies security best practices)
+- **Best practice compliance:** Excellent (follows modern development patterns)
+
+
+## Limitations & Biases
+
+### Known Limitations
+
+1. **Domain Specificity**
+   - Optimized for web development (FastAPI, React)
+   - May be less effective for other domains (embedded systems, game development)
+
+2. **Training Data Constraints**
+   - Trained on patterns up to knowledge cutoff
+   - May not reflect latest framework versions
+   - Limited to English language code and documentation
+
+3. **Context Length**
+   - Maximum 32,768 tokens (though effectively handles ~16-24K for quality)
+   - Very large codebases may need chunking
+
+4. **Security Limitations**
+   - Code generation should ALWAYS be reviewed by humans
+   - Not a replacement for professional security audits
+   - May not catch all edge cases or vulnerabilities
+
+### Potential Biases
+
+- **Technology stack bias:** Strong preference for specific tech stack (FastAPI, React, PostgreSQL)
+- **Pattern repetition:** May favor certain code patterns from training data
+- **Verbosity:** Sometimes generates more comprehensive solutions than requested
+
+### Mitigation Strategies
+
+✅ **Always review generated code** before production use
+✅ **Run security scanners** on generated code
+✅ **Test thoroughly** including edge cases
+✅ **Use alongside** professional security tools
+✅ **Keep dependencies updated** as model may reference older versions
+
+## Ethical Considerations
+
+### Responsible Use
+
+This model should be used responsibly:
+
+- ✅ **DO:** Use for learning, prototyping, and accelerating development
+- ✅ **DO:** Review and test all generated code
+- ✅ **DO:** Follow applicable security standards and regulations
+- ⚠️ **DON'T:** Use for malicious purposes or exploit development
+- ⚠️ **DON'T:** Deploy generated code without human review
+- ⚠️ **DON'T:** Rely solely on AI for security-critical systems
+
+### Environmental Impact
+
+- **Inference efficiency:** QLoRA and quantization reduce deployment costs
+- **Optimization:** Unsloth reduces training time and energy consumption
+
+## Citation
+
+If you use SecurityGPT in your research or projects, please cite:
+
+```bibtex
+@misc{securitygpt2026,
+  title={SecurityGPT: A Security-Focused Code Generation Model},
+  author={[email protected]},
+  year={2026},
+  publisher={Hugging Face},
+  howpublished={\url{https://huggingface.co/pki/securitygpt-14b}},
+  note={Fine-tuned from Qwen2.5-Coder-14B-Instruct}
+}
+```
+
+**Base model citation:**
+```bibtex
+@article{qwen2.5,
+  title={Qwen2.5-Coder Technical Report},
+  author={Qwen Team},
+  journal={arXiv preprint},
+  year={2024}
+}
+```
+
+## Model Card Contact
+
+For questions, issues, or collaboration:
+- **Issues:** Open an issue on the model repository
+- **Discussions:** Use Hugging Face discussions tab
+- **Email:** Contact through Hugging Face profile
+
+## Changelog
+
+### v1.0.0 (2025-12)
+- Initial release
+- Fine-tuned on 16,000 security-focused examples
+- Supports 32K context window
+- Optimized for FastAPI, React, and security best practices
+
+## Acknowledgments
+
+- **Base model:** [Qwen Team](https://huggingface.co/Qwen) for Qwen2.5-Coder-14B-Instruct
+- **Training framework:** [Unsloth AI](https://github.com/unslothai/unsloth) for optimization
+- **Quantization:** [llama.cpp](https://github.com/ggerganov/llama.cpp) for GGUF conversion
+- **Deployment:** [Ollama](https://ollama.ai) for inference serving
+
+## License
+
+This model is released under the **Apache 2.0 License**, same as the base Qwen2.5-Coder model.
+
+```
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+**Disclaimer:** This model is provided as-is for research and development purposes. Always review and test generated code before production deployment. The authors are not responsible for any damages resulting from the use of this model.

USAGE_EXAMPLES.md

@@ -0,0 +1,657 @@
+# SecurityGPT Usage Examples
+
+Practical examples for using SecurityGPT in various development scenarios.
+
+## Table of Contents
+
+1. [Basic Usage](#basic-usage)
+2. [Secure API Development](#secure-api-development)
+3. [Frontend Development](#frontend-development)
+4. [Database Operations](#database-operations)
+5. [Security Reviews](#security-reviews)
+6. [DevOps & Infrastructure](#devops--infrastructure)
+7. [Advanced Patterns](#advanced-patterns)
+
+---
+
+## Basic Usage
+
+### Example 1: Simple Code Generation
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_name = "pki/securitygpt-14b"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+# Simple prompt
+prompt = "Write a Python function to validate email addresses using regex"
+
+messages = [
+    {"role": "system", "content": "You are a helpful coding assistant."},
+    {"role": "user", "content": prompt}
+]
+
+text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.7)
+response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+print(response)
+```
+
+### Example 2: Using Ollama CLI
+
+```bash
+# Simple query
+ollama run securitygpt:14b "Create a FastAPI health check endpoint"
+
+# With context
+ollama run securitygpt:14b "Create a user authentication endpoint with JWT tokens and argon2 password hashing"
+
+# Code review
+ollama run securitygpt:14b "Review this code for security issues: $(cat auth.py)"
+```
+
+---
+
+## Secure API Development
+
+### Example 3: FastAPI User Authentication
+
+**Prompt:**
+```
+Create a complete FastAPI authentication system with:
+- User signup endpoint with email validation
+- Login endpoint with JWT token generation
+- Password hashing using argon2
+- Proper error handling
+- Input validation using Pydantic
+```
+
+**Expected Output Pattern:**
+```python
+from fastapi import APIRouter, HTTPException, Depends
+from pydantic import BaseModel, EmailStr, Field
+from passlib.context import CryptContext
+from datetime import datetime, timedelta
+import jwt
+
+router = APIRouter(prefix="/api/v1/auth", tags=["authentication"])
+
+# Password hashing with argon2 (NEVER bcrypt)
+pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+
+class UserSignup(BaseModel):
+    email: EmailStr
+    password: str = Field(..., min_length=8)
+    full_name: str = Field(..., min_length=2)
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+@router.post("/signup")
+async def signup(user: UserSignup):
+    """Create new user with secure password hashing."""
+    # Validate password strength
+    if len(user.password) < 8:
+        raise HTTPException(400, "Password must be at least 8 characters")
+
+    # Hash password with argon2
+    hashed_password = pwd_context.hash(user.password)
+
+    # Store user in database
+    # ... (database logic)
+
+    return {"message": "User created successfully"}
+
+@router.post("/login")
+async def login(credentials: UserLogin):
+    """Authenticate user and return JWT token."""
+    # Get user from database
+    # user = get_user_by_email(credentials.email)
+
+    # Verify password
+    if not pwd_context.verify(credentials.password, user.hashed_password):
+        raise HTTPException(401, "Invalid credentials")
+
+    # Generate JWT token
+    token_data = {
+        "sub": user.email,
+        "exp": datetime.utcnow() + timedelta(hours=24)
+    }
+    token = jwt.encode(token_data, SECRET_KEY, algorithm="HS256")
+
+    return {"access_token": token, "token_type": "bearer"}
+```
+
+### Example 4: API with Input Validation
+
+**Prompt:**
+```
+Create a FastAPI endpoint for creating blog posts with:
+- Title validation (max 200 chars)
+- Content validation
+- Tag validation (max 5 tags)
+- SQL injection prevention
+- Proper error responses
+```
+
+---
+
+## Frontend Development
+
+### Example 5: Secure React Login Form
+
+**Prompt:**
+```
+Create a React login component with:
+- Email and password inputs
+- Client-side validation
+- XSS protection
+- CSRF token handling
+- Loading states
+- Error display
+- TypeScript types
+```
+
+**Expected Output Pattern:**
+```typescript
+import React, { useState } from 'react';
+import DOMPurify from 'dompurify';
+
+interface LoginFormProps {
+  onSubmit: (email: string, password: string) => Promise<void>;
+  csrfToken: string;
+}
+
+interface FormErrors {
+  email?: string;
+  password?: string;
+  general?: string;
+}
+
+export const LoginForm: React.FC<LoginFormProps> = ({ onSubmit, csrfToken }) => {
+  const [email, setEmail] = useState('');
+  const [password, setPassword] = useState('');
+  const [errors, setErrors] = useState<FormErrors>({});
+  const [loading, setLoading] = useState(false);
+
+  const validateEmail = (email: string): boolean => {
+    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return regex.test(email);
+  };
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+
+    // Clear previous errors
+    setErrors({});
+
+    // Validate inputs
+    const newErrors: FormErrors = {};
+
+    if (!validateEmail(email)) {
+      newErrors.email = 'Invalid email address';
+    }
+
+    if (password.length < 8) {
+      newErrors.password = 'Password must be at least 8 characters';
+    }
+
+    if (Object.keys(newErrors).length > 0) {
+      setErrors(newErrors);
+      return;
+    }
+
+    // Sanitize inputs (XSS protection)
+    const cleanEmail = DOMPurify.sanitize(email);
+
+    try {
+      setLoading(true);
+      await onSubmit(cleanEmail, password);
+    } catch (error) {
+      setErrors({ general: 'Login failed. Please try again.' });
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <input type="hidden" name="csrf_token" value={csrfToken} />
+
+      <div>
+        <label htmlFor="email">Email</label>
+        <input
+          id="email"
+          type="email"
+          value={email}
+          onChange={(e) => setEmail(e.target.value)}
+          disabled={loading}
+          required
+        />
+        {errors.email && <span className="error">{errors.email}</span>}
+      </div>
+
+      <div>
+        <label htmlFor="password">Password</label>
+        <input
+          id="password"
+          type="password"
+          value={password}
+          onChange={(e) => setPassword(e.target.value)}
+          disabled={loading}
+          required
+        />
+        {errors.password && <span className="error">{errors.password}</span>}
+      </div>
+
+      {errors.general && <div className="error">{errors.general}</div>}
+
+      <button type="submit" disabled={loading}>
+        {loading ? 'Logging in...' : 'Login'}
+      </button>
+    </form>
+  );
+};
+```
+
+### Example 6: API Client with Error Handling
+
+**Prompt:**
+```
+Create a TypeScript API client class with:
+- Axios integration
+- JWT token management
+- Request interceptors
+- Error handling
+- Retry logic
+- Type safety
+```
+
+---
+
+## Database Operations
+
+### Example 7: Secure SQLAlchemy Model
+
+**Prompt:**
+```
+Create a SQLAlchemy User model with:
+- Secure password storage
+- Email uniqueness constraint
+- Timestamps (created_at, updated_at)
+- Soft delete support
+- Audit logging
+```
+
+**Expected Output:**
+```python
+from sqlalchemy import Column, Integer, String, DateTime, Boolean
+from sqlalchemy.ext.declarative import declarative_base
+from datetime import datetime
+from passlib.context import CryptContext
+
+Base = declarative_base()
+pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String(255), unique=True, index=True, nullable=False)
+    hashed_password = Column(String(255), nullable=False)
+    full_name = Column(String(255))
+    is_active = Column(Boolean, default=True)
+    is_deleted = Column(Boolean, default=False)
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def set_password(self, password: str):
+        """Hash and set user password using argon2."""
+        self.hashed_password = pwd_context.hash(password)
+
+    def verify_password(self, password: str) -> bool:
+        """Verify password against stored hash."""
+        return pwd_context.verify(password, self.hashed_password)
+
+    def soft_delete(self):
+        """Mark user as deleted without removing from database."""
+        self.is_deleted = True
+        self.is_active = False
+```
+
+### Example 8: Database Migration
+
+**Prompt:**
+```
+Create an Alembic migration script to add user authentication table with proper indexes
+```
+
+---
+
+## Security Reviews
+
+### Example 9: Code Security Audit
+
+**Prompt:**
+```
+Review this authentication code for security vulnerabilities:
+
+def login(username, password):
+    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
+    result = db.execute(query)
+    if result:
+        return create_token(username)
+    return None
+```
+
+**Expected Output:**
+```
+SECURITY VULNERABILITIES FOUND:
+
+1. SQL INJECTION (CRITICAL)
+   - Line 2: Raw string concatenation in SQL query
+   - Attack vector: username = "admin' OR '1'='1"
+   - Fix: Use parameterized queries or ORM
+
+2. PLAINTEXT PASSWORDS (CRITICAL)
+   - Line 2: Password stored/compared in plaintext
+   - Fix: Use argon2 password hashing
+
+3. TIMING ATTACK (MEDIUM)
+   - Different execution paths for valid/invalid users
+   - Fix: Use constant-time comparison
+
+SECURE IMPLEMENTATION:
+
+from sqlalchemy.orm import Session
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+
+def login(username: str, password: str, db: Session):
+    """Secure login with parameterized query and password hashing."""
+    # Parameterized query (SQL injection prevention)
+    user = db.query(User).filter(User.username == username).first()
+
+    # Constant-time check to prevent timing attacks
+    if user is None:
+        # Perform dummy hash to maintain constant time
+        pwd_context.hash("dummy")
+        return None
+
+    # Verify password with argon2
+    if not pwd_context.verify(password, user.hashed_password):
+        return None
+
+    return create_token(user.id)
+```
+
+---
+
+## DevOps & Infrastructure
+
+### Example 10: Docker Compose with Security
+
+**Prompt:**
+```
+Create a secure docker-compose.yml for a FastAPI app with PostgreSQL including:
+- Non-root users
+- Environment variables from secrets
+- Network isolation
+- Health checks
+- Resource limits
+```
+
+### Example 11: GitLab CI/CD Pipeline
+
+**Prompt:**
+```
+Create a GitLab CI pipeline for a Python FastAPI app with:
+- Linting (flake8)
+- Testing (pytest)
+- Security scanning
+- Docker build
+- Deployment to production
+```
+
+---
+
+## Advanced Patterns
+
+### Example 12: Rate Limiting Middleware
+
+**Prompt:**
+```
+Create FastAPI rate limiting middleware using Redis with:
+- IP-based limiting
+- Token bucket algorithm
+- Configurable limits
+- Custom error responses
+```
+
+### Example 13: API Key Management
+
+**Prompt:**
+```
+Create an API key management system with:
+- Key generation with secure random
+- Key hashing for storage
+- Rate limiting per key
+- Key expiration
+- Usage tracking
+```
+
+### Example 14: Multi-factor Authentication
+
+**Prompt:**
+```
+Implement TOTP-based 2FA for FastAPI with:
+- QR code generation
+- Token verification
+- Backup codes
+- Account recovery
+```
+
+---
+
+## Integration Examples
+
+### Example 15: Using with LangChain
+
+```python
+from langchain.llms import HuggingFacePipeline
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+
+model_name = "pki/securitygpt-14b"
+tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    device_map="auto",
+    trust_remote_code=True
+)
+
+pipe = pipeline(
+    "text-generation",
+    model=model,
+    tokenizer=tokenizer,
+    max_new_tokens=1024,
+    temperature=0.7
+)
+
+llm = HuggingFacePipeline(pipeline=pipe)
+
+# Use with LangChain
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+template = """Create a secure {feature} for a {framework} application.
+Include proper error handling and security best practices.
+
+Feature: {feature}
+Framework: {framework}
+"""
+
+prompt = PromptTemplate(template=template, input_variables=["feature", "framework"])
+chain = LLMChain(llm=llm, prompt=prompt)
+
+result = chain.run(feature="user authentication", framework="FastAPI")
+print(result)
+```
+
+### Example 16: Batch Processing
+
+```python
+# Process multiple code generation tasks
+prompts = [
+    "Create a FastAPI endpoint for user registration",
+    "Create a React form component for login",
+    "Create a PostgreSQL schema for user management"
+]
+
+for prompt in prompts:
+    messages = [
+        {"role": "system", "content": "You are a secure coding assistant."},
+        {"role": "user", "content": prompt}
+    ]
+
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer([text], return_tensors="pt").to(model.device)
+
+    outputs = model.generate(**inputs, max_new_tokens=512)
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    print(f"\n{'='*60}\nPrompt: {prompt}\n{'='*60}")
+    print(response)
+```
+
+---
+
+## Tips for Best Results
+
+### 1. Be Specific in Prompts
+
+❌ Bad: "Create an API endpoint"
+✅ Good: "Create a FastAPI POST endpoint at /api/v1/users for user registration with email validation and argon2 password hashing"
+
+### 2. Specify Technology Stack
+
+Include framework versions and specific libraries when relevant:
+```
+Create a React 18 component using TypeScript and Tailwind CSS for...
+```
+
+### 3. Request Security Features
+
+Explicitly ask for security features:
+```
+Create a login endpoint with argon2 password hashing, rate limiting, and CSRF protection
+```
+
+### 4. Use System Prompts
+
+Customize the system prompt for your use case:
+```python
+messages = [
+    {"role": "system", "content": "You are a senior security engineer reviewing code for vulnerabilities."},
+    {"role": "user", "content": "Review this authentication code..."}
+]
+```
+
+### 5. Adjust Temperature
+
+- **Low (0.1-0.3):** Deterministic, consistent code generation
+- **Medium (0.5-0.7):** Balanced creativity and consistency
+- **High (0.8-1.0):** More creative solutions, less predictable
+
+### 6. Iterate and Refine
+
+Use follow-up prompts to refine output:
+```
+1st prompt: "Create a user authentication endpoint"
+2nd prompt: "Add rate limiting to prevent brute force attacks"
+3rd prompt: "Add logging for security audit trail"
+```
+
+---
+
+## Common Patterns
+
+### Pattern 1: Full-Stack Feature
+
+```
+Create a complete user profile feature including:
+- Backend: FastAPI endpoint with SQLAlchemy model
+- Frontend: React component with TypeScript
+- Database: PostgreSQL migration script
+- Tests: pytest for backend, Jest for frontend
+```
+
+### Pattern 2: Security Hardening
+
+```
+Review and harden this [component] for production:
+- Add input validation
+- Implement rate limiting
+- Add security headers
+- Add audit logging
+- Fix any SQL injection or XSS vulnerabilities
+```
+
+### Pattern 3: Migration/Upgrade
+
+```
+Migrate this Flask endpoint to FastAPI:
+- Use Pydantic for validation
+- Add async/await
+- Update to /api/v1 versioning
+- Add OpenAPI documentation
+[paste code]
+```
+
+---
+
+## Troubleshooting
+
+### Issue: Model generating outdated patterns
+
+**Solution:** Explicitly specify modern versions in prompt
+```
+Create a FastAPI endpoint using FastAPI 0.110+ with Pydantic v2
+```
+
+### Issue: Output too verbose
+
+**Solution:** Lower temperature and add conciseness requirement
+```python
+outputs = model.generate(..., temperature=0.3)
+# Add to prompt: "Provide concise implementation without extensive comments"
+```
+
+### Issue: Missing security features
+
+**Solution:** Explicitly list required security features in prompt
+```
+Include: input validation, SQL injection prevention, XSS protection, rate limiting
+```
+
+---
+
+## Additional Resources
+
+- [Model Card](./MODEL_CARD.md) - Full model documentation
+- [Training Details](./TRAINING.md) - Training methodology
+- [Deployment Guide](./DEPLOYMENT.md) - Production deployment
+- [Hugging Face Model Hub](https://huggingface.co/pki/securitygpt-14b)
+
+---
+
+**Need help?** Open an issue on the model repository or use the Hugging Face discussions tab.

added_tokens.json

@@ -0,0 +1,24 @@
+{
+  "</tool_call>": 151658,
+  "<tool_call>": 151657,
+  "<|box_end|>": 151649,
+  "<|box_start|>": 151648,
+  "<|endoftext|>": 151643,
+  "<|file_sep|>": 151664,
+  "<|fim_middle|>": 151660,
+  "<|fim_pad|>": 151662,
+  "<|fim_prefix|>": 151659,
+  "<|fim_suffix|>": 151661,
+  "<|im_end|>": 151645,
+  "<|im_start|>": 151644,
+  "<|image_pad|>": 151655,
+  "<|object_ref_end|>": 151647,
+  "<|object_ref_start|>": 151646,
+  "<|quad_end|>": 151651,
+  "<|quad_start|>": 151650,
+  "<|repo_name|>": 151663,
+  "<|video_pad|>": 151656,
+  "<|vision_end|>": 151653,
+  "<|vision_pad|>": 151654,
+  "<|vision_start|>": 151652
+}

chat_template.jinja

@@ -0,0 +1,54 @@
+{%- if tools %}
+    {{- '<|im_start|>system\n' }}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- messages[0]['content'] }}
+    {%- else %}
+        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}
+    {%- endif %}
+    {{- "\n\n# Tools\n\nYou may call one or more functions to assist with the user query.\n\nYou are provided with function signatures within <tools></tools> XML tags:\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>\n\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\n<tool_call>\n{\"name\": <function-name>, \"arguments\": <args-json-object>}\n</tool_call><|im_end|>\n" }}
+{%- else %}
+    {%- if messages[0]['role'] == 'system' %}
+        {{- '<|im_start|>system\n' + messages[0]['content'] + '<|im_end|>\n' }}
+    {%- else %}
+        {{- '<|im_start|>system\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- for message in messages %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) or (message.role == "assistant" and not message.tool_calls) %}
+        {{- '<|im_start|>' + message.role + '\n' + message.content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {{- '<|im_start|>' + message.role }}
+        {%- if message.content %}
+            {{- '\n' + message.content }}
+        {%- endif %}
+        {%- for tool_call in message.tool_calls %}
+            {%- if tool_call.function is defined %}
+                {%- set tool_call = tool_call.function %}
+            {%- endif %}
+            {{- '\n<tool_call>\n{"name": "' }}
+            {{- tool_call.name }}
+            {{- '", "arguments": ' }}
+            {{- tool_call.arguments | tojson }}
+            {{- '}\n</tool_call>' }}
+        {%- endfor %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != "tool") %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- message.content }}
+        {{- '\n</tool_response>' }}
+        {%- if loop.last or (messages[loop.index0 + 1].role != "tool") %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+{%- endif %}

config.json

@@ -0,0 +1,80 @@
+{
+    "architectures": [
+        "Qwen2ForCausalLM"
+    ],
+    "attention_dropout": 0.0,
+    "torch_dtype": "bfloat16",
+    "eos_token_id": 151645,
+    "hidden_act": "silu",
+    "hidden_size": 5120,
+    "initializer_range": 0.02,
+    "intermediate_size": 13824,
+    "layer_types": [
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention",
+        "full_attention"
+    ],
+    "max_position_embeddings": 32768,
+    "max_window_layers": 70,
+    "model_type": "qwen2",
+    "num_attention_heads": 40,
+    "num_hidden_layers": 48,
+    "num_key_value_heads": 8,
+    "pad_token_id": 151654,
+    "rms_norm_eps": 1e-06,
+    "rope_scaling": null,
+    "rope_theta": 1000000.0,
+    "sliding_window": null,
+    "tie_word_embeddings": false,
+    "transformers_version": "4.57.3",
+    "unsloth_fixed": true,
+    "unsloth_version": "2025.12.4",
+    "use_cache": true,
+    "use_sliding_window": false,
+    "vocab_size": 152064
+}

generation_config.json

@@ -0,0 +1,12 @@
+{
+  "bos_token_id": null,
+  "do_sample": true,
+  "eos_token_id": 151645,
+  "pad_token_id": 151654,
+  "top_p": 0.9,
+  "top_k": 50,
+  "temperature": 0.7,
+  "repetition_penalty": 1.0,
+  "max_length": 32768,
+  "transformers_version": "4.57.3"
+}

model-00001-of-00006.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7772c48c028ace57d9e3b5982f8dc29fdb808c12d0f52609a51d31f096a573b3
+size 4986211280

model-00002-of-00006.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1b62e7a6aa87569bba41d5938524e2487d44741ac10073f4e56cad0470d9d844
+size 4954847344

model-00003-of-00006.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00533bbf80a0647f91c42b783269c79b2dd2706f75d8e9b6210ede471d716b42
+size 3013472256

model.safetensors.index.json

@@ -0,0 +1,586 @@
+{
+  "metadata": {
+    "total_size": 29540067328
+  },
+  "weight_map": {
+    "lm_head.weight": "model-00006-of-00006.safetensors",
+    "model.embed_tokens.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.input_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.mlp.down_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.mlp.gate_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.mlp.up_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.post_attention_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.self_attn.k_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.0.self_attn.k_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.self_attn.o_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.self_attn.q_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.0.self_attn.q_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.0.self_attn.v_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.0.self_attn.v_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.input_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.mlp.down_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.mlp.gate_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.mlp.up_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.post_attention_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.self_attn.k_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.1.self_attn.k_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.self_attn.o_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.self_attn.q_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.1.self_attn.q_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.1.self_attn.v_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.1.self_attn.v_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.10.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.10.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.10.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.10.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.10.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.11.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.11.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.11.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.11.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.12.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.12.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.12.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.12.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.13.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.13.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.13.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.13.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.14.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.14.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.14.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.14.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.15.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.15.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.15.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.15.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.15.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.15.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.15.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.15.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.15.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.15.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.15.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.15.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.16.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.16.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.16.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.16.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.16.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.17.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.17.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.17.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.17.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.18.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.18.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.18.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.18.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.19.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.19.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.19.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.19.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.2.input_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.mlp.down_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.mlp.gate_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.mlp.up_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.post_attention_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.self_attn.k_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.2.self_attn.k_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.self_attn.o_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.self_attn.q_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.2.self_attn.q_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.2.self_attn.v_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.2.self_attn.v_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.20.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.20.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.20.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.20.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.20.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.21.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.21.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.21.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.21.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.22.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.22.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.22.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.22.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.input_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.mlp.down_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.mlp.gate_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.mlp.up_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.post_attention_layernorm.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.23.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.23.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.23.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.23.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.24.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.24.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.24.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.24.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.24.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.24.self_attn.k_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.24.self_attn.k_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.24.self_attn.o_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.24.self_attn.q_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.24.self_attn.q_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.24.self_attn.v_proj.bias": "model-00003-of-00006.safetensors",
+    "model.layers.24.self_attn.v_proj.weight": "model-00003-of-00006.safetensors",
+    "model.layers.25.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.25.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.25.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.25.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.25.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.26.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.26.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.26.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.26.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.27.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.27.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.27.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.27.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.28.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.28.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.28.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.28.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.29.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.29.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.29.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.29.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.3.input_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.mlp.down_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.mlp.gate_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.mlp.up_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.post_attention_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.self_attn.k_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.3.self_attn.k_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.self_attn.o_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.self_attn.q_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.3.self_attn.q_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.3.self_attn.v_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.3.self_attn.v_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.30.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.30.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.30.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.30.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.30.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.31.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.31.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.31.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.31.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.input_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.mlp.down_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.mlp.gate_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.mlp.up_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.post_attention_layernorm.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.32.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.32.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.32.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.32.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.33.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.33.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.33.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.33.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.33.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.33.self_attn.k_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.33.self_attn.k_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.33.self_attn.o_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.33.self_attn.q_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.33.self_attn.q_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.33.self_attn.v_proj.bias": "model-00004-of-00006.safetensors",
+    "model.layers.33.self_attn.v_proj.weight": "model-00004-of-00006.safetensors",
+    "model.layers.34.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.34.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.34.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.34.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.34.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.35.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.35.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.35.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.35.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.36.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.36.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.36.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.36.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.37.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.37.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.37.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.37.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.38.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.38.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.38.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.38.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.39.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.39.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.39.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.39.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.4.input_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.mlp.down_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.mlp.gate_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.mlp.up_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.post_attention_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.self_attn.k_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.4.self_attn.k_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.self_attn.o_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.self_attn.q_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.4.self_attn.q_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.4.self_attn.v_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.4.self_attn.v_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.40.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.40.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.40.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.40.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.40.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.input_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.mlp.down_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.mlp.gate_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.mlp.up_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.post_attention_layernorm.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.41.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.41.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.41.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.41.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.42.input_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.42.mlp.down_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.42.mlp.gate_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.42.mlp.up_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.42.post_attention_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.42.self_attn.k_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.42.self_attn.k_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.42.self_attn.o_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.42.self_attn.q_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.42.self_attn.q_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.42.self_attn.v_proj.bias": "model-00005-of-00006.safetensors",
+    "model.layers.42.self_attn.v_proj.weight": "model-00005-of-00006.safetensors",
+    "model.layers.43.input_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.mlp.down_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.mlp.gate_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.mlp.up_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.post_attention_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.self_attn.k_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.43.self_attn.k_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.self_attn.o_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.self_attn.q_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.43.self_attn.q_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.43.self_attn.v_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.43.self_attn.v_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.input_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.mlp.down_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.mlp.gate_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.mlp.up_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.post_attention_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.self_attn.k_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.44.self_attn.k_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.self_attn.o_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.self_attn.q_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.44.self_attn.q_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.44.self_attn.v_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.44.self_attn.v_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.input_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.mlp.down_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.mlp.gate_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.mlp.up_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.post_attention_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.self_attn.k_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.45.self_attn.k_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.self_attn.o_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.self_attn.q_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.45.self_attn.q_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.45.self_attn.v_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.45.self_attn.v_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.input_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.mlp.down_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.mlp.gate_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.mlp.up_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.post_attention_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.self_attn.k_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.46.self_attn.k_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.self_attn.o_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.self_attn.q_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.46.self_attn.q_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.46.self_attn.v_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.46.self_attn.v_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.input_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.mlp.down_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.mlp.gate_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.mlp.up_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.post_attention_layernorm.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.self_attn.k_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.47.self_attn.k_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.self_attn.o_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.self_attn.q_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.47.self_attn.q_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.47.self_attn.v_proj.bias": "model-00006-of-00006.safetensors",
+    "model.layers.47.self_attn.v_proj.weight": "model-00006-of-00006.safetensors",
+    "model.layers.5.input_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.mlp.down_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.mlp.gate_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.mlp.up_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.post_attention_layernorm.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.self_attn.k_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.5.self_attn.k_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.self_attn.o_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.self_attn.q_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.5.self_attn.q_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.5.self_attn.v_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.5.self_attn.v_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.6.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.6.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.6.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.6.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.6.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.6.self_attn.k_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.6.self_attn.k_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.6.self_attn.o_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.6.self_attn.q_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.6.self_attn.q_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.6.self_attn.v_proj.bias": "model-00001-of-00006.safetensors",
+    "model.layers.6.self_attn.v_proj.weight": "model-00001-of-00006.safetensors",
+    "model.layers.7.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.7.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.7.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.7.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.7.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.8.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.8.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.8.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.8.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.input_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.mlp.down_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.mlp.gate_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.mlp.up_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.post_attention_layernorm.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.self_attn.k_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.9.self_attn.k_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.self_attn.o_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.self_attn.q_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.9.self_attn.q_proj.weight": "model-00002-of-00006.safetensors",
+    "model.layers.9.self_attn.v_proj.bias": "model-00002-of-00006.safetensors",
+    "model.layers.9.self_attn.v_proj.weight": "model-00002-of-00006.safetensors",
+    "model.norm.weight": "model-00006-of-00006.safetensors"
+  }
+}

special_tokens_map.json

@@ -0,0 +1,31 @@
+{
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "eos_token": {
+    "content": "<|im_end|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "<|vision_pad|>",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c5ae00e602b8860cbd784ba82a8aa14e8feecec692e7076590d014d7b7fdafa
+size 11421896

tokenizer_config.json

@@ -0,0 +1,209 @@
+{
+  "add_bos_token": false,
+  "add_prefix_space": false,
+  "added_tokens_decoder": {
+    "151643": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151644": {
+      "content": "<|im_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151645": {
+      "content": "<|im_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151646": {
+      "content": "<|object_ref_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151647": {
+      "content": "<|object_ref_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151648": {
+      "content": "<|box_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151649": {
+      "content": "<|box_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151650": {
+      "content": "<|quad_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151651": {
+      "content": "<|quad_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151652": {
+      "content": "<|vision_start|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151653": {
+      "content": "<|vision_end|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151654": {
+      "content": "<|vision_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151655": {
+      "content": "<|image_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151656": {
+      "content": "<|video_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "151657": {
+      "content": "<tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151658": {
+      "content": "</tool_call>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151659": {
+      "content": "<|fim_prefix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151660": {
+      "content": "<|fim_middle|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151661": {
+      "content": "<|fim_suffix|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151662": {
+      "content": "<|fim_pad|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151663": {
+      "content": "<|repo_name|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "151664": {
+      "content": "<|file_sep|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    }
+  },
+  "additional_special_tokens": [
+    "<|im_start|>",
+    "<|im_end|>",
+    "<|object_ref_start|>",
+    "<|object_ref_end|>",
+    "<|box_start|>",
+    "<|box_end|>",
+    "<|quad_start|>",
+    "<|quad_end|>",
+    "<|vision_start|>",
+    "<|vision_end|>",
+    "<|vision_pad|>",
+    "<|image_pad|>",
+    "<|video_pad|>"
+  ],
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "extra_special_tokens": {},
+  "model_max_length": 32768,
+  "pad_token": "<|vision_pad|>",
+  "padding_side": "right",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "chat_template": "{%- if tools %}\n    {{- '<|im_start|>system\\n' }}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- messages[0]['content'] }}\n    {%- else %}\n        {{- 'You are Qwen, created by Alibaba Cloud. You are a helpful assistant.' }}\n    {%- endif %}\n    {{- \"\\n\\n# Tools\\n\\nYou may call one or more functions to assist with the user query.\\n\\nYou are provided with function signatures within <tools></tools> XML tags:\\n<tools>\" }}\n    {%- for tool in tools %}\n        {{- \"\\n\" }}\n        {{- tool | tojson }}\n    {%- endfor %}\n    {{- \"\\n</tools>\\n\\nFor each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:\\n<tool_call>\\n{\\\"name\\\": <function-name>, \\\"arguments\\\": <args-json-object>}\\n</tool_call><|im_end|>\\n\" }}\n{%- else %}\n    {%- if messages[0]['role'] == 'system' %}\n        {{- '<|im_start|>system\\n' + messages[0]['content'] + '<|im_end|>\\n' }}\n    {%- else %}\n        {{- '<|im_start|>system\\nYou are Qwen, created by Alibaba Cloud. You are a helpful assistant.<|im_end|>\\n' }}\n    {%- endif %}\n{%- endif %}\n{%- for message in messages %}\n    {%- if (message.role == \"user\") or (message.role == \"system\" and not loop.first) or (message.role == \"assistant\" and not message.tool_calls) %}\n        {{- '<|im_start|>' + message.role + '\\n' + message.content + '<|im_end|>' + '\\n' }}\n    {%- elif message.role == \"assistant\" %}\n        {{- '<|im_start|>' + message.role }}\n        {%- if message.content %}\n            {{- '\\n' + message.content }}\n        {%- endif %}\n        {%- for tool_call in message.tool_calls %}\n            {%- if tool_call.function is defined %}\n                {%- set tool_call = tool_call.function %}\n            {%- endif %}\n            {{- '\\n<tool_call>\\n{\"name\": \"' }}\n            {{- tool_call.name }}\n            {{- '\", \"arguments\": ' }}\n            {{- tool_call.arguments | tojson }}\n            {{- '}\\n</tool_call>' }}\n        {%- endfor %}\n        {{- '<|im_end|>\\n' }}\n    {%- elif message.role == \"tool\" %}\n        {%- if (loop.index0 == 0) or (messages[loop.index0 - 1].role != \"tool\") %}\n            {{- '<|im_start|>user' }}\n        {%- endif %}\n        {{- '\\n<tool_response>\\n' }}\n        {{- message.content }}\n        {{- '\\n</tool_response>' }}\n        {%- if loop.last or (messages[loop.index0 + 1].role != \"tool\") %}\n            {{- '<|im_end|>\\n' }}\n        {%- endif %}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|im_start|>assistant\\n' }}\n{%- endif %}\n"
+}