MODEL_CARD.md

---
license: apache-2.0
base_model: google/gemma-4-12b
language:
  - en
  - multilingual
tags:
  - code
  - coding
  - agentic
  - gemma-4
  - code-generation
  - code-review
  - debugging
  - instruction-tuned
  - perciqa
  - aurora
  - canadian-ai
  - mini
  - lora
  - sft
datasets:
  - perciqa/aurora-code-sft-v1
pipeline_tag: text-generation
library_name: transformers
---

# Aurora-Code-Mini-1

> *Compact. Capable. Completely open.*

**Aurora-Code-Mini-1** is a 12B dense coding model built by [Perciqa](https://perciqa.com), a Canadian AI company. Fine-tuned from Gemma 4 12B on curated agentic coding instruction pairs, Aurora-Code-Mini-1 is designed for developers who need fast, high-quality coding assistance on consumer hardware — without cloud dependencies, usage limits, or black boxes.

**3B** active parameters. **Apache 2.0** license. Fits on a **24 GB GPU** at BF16 or **8 GB cards** with quantization.

[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![HuggingFace](https://img.shields.io/badge/%F0%9F%A4%97-Perciqa%2FAurora--Code--Mini--1-yellow)](https://huggingface.co/Perciqa/Aurora-Code-Mini-1)
[![Canadian AI](https://img.shields.io/badge/Made%20in-Canada%20%F0%9F%87%A8%F0%9F%87%A6-red)](https://perciqa.com)

---

## What Aurora-Code-Mini-1 does

Aurora-Code-Mini-1 brings the Aurora coding experience to hardware that fits on your desk. Run it locally, integrate it into your toolchain, and keep your code private.

- **Code generation** — write functions, classes, and complete programs across 40+ languages
- **Debugging** — identify root causes and produce clear, actionable fixes
- **Code review** — flag issues, suggest refactors, explain tradeoffs
- **Agentic tasks** — multi-step reasoning, tool use, and repository-level workflows

No cloud required. No data leaving your machine. Your model, your terms.

---

## Quickstart

### Install

```bash
pip install "transformers>=4.51.0" accelerate
```

> **Hardware:** ~24 GB VRAM at BF16. Works on a single RTX 3090/4090, A5000, or equivalent. For smaller setups, use 4-bit quantization (~8 GB VRAM).

### Transformers

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Perciqa/Aurora-Code-Mini-1"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
)

system_prompt = (
    "You are Aurora, an AI code assistant built by Perciqa. "
    "You help developers write, review, and understand code. "
    "You provide clear, correct, and complete solutions. "
    "When you're unsure, you say so."
)

messages = [
    {"role": "system", "content": system_prompt},
    {"role": "user", "content": "Write a Python function to merge two sorted lists."},
]

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=1024,
    temperature=0.7,
    do_sample=True,
)
response = tokenizer.decode(outputs[0][len(inputs.input_ids[0]):], skip_special_tokens=True)
print(response)
```

### 4-bit Quantization (8 GB GPU)

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(load_in_4bit=True)

model = AutoModelForCausalLM.from_pretrained(
    "Perciqa/Aurora-Code-Mini-1",
    quantization_config=quantization_config,
    device_map="auto",
)
```

### vLLM (recommended for production)

```bash
pip install vllm
vllm serve Perciqa/Aurora-Code-Mini-1 --max-model-len 32768
```

Query via the OpenAI-compatible API:

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="token-abc123")

response = client.chat.completions.create(
    model="Perciqa/Aurora-Code-Mini-1",
    messages=[
        {"role": "system", "content": "You are Aurora, an AI code assistant built by Perciqa."},
        {"role": "user", "content": "Refactor this function to be more Pythonic."},
    ],
    max_tokens=1024,
)
print(response.choices[0].message.content)
```

### Ollama

```bash
ollama run hf.co/Perciqa/Aurora-Code-Mini-1
```

---

## Argus Integration

[Argus](https://perciqa.com/argus) is Perciqa's open-source agent observability SDK — trajectory tracing, token usage, eval-in-production. Aurora-Code-Mini-1 integrates natively.

```python
import argus
from openai import OpenAI

argus.init(server_url="http://localhost:8000", agent_name="aurora-mini")
client = OpenAI(base_url="http://localhost:8000/v1", api_key="token-abc123")

@argus.trace(kind="agent")
def aurora_mini_code(query: str) -> str:
    response = client.chat.completions.create(
        model="Perciqa/Aurora-Code-Mini-1",
        messages=[
            {"role": "system", "content": "You are Aurora, an AI code assistant built by Perciqa."},
            {"role": "user", "content": query},
        ],
    )
    return response.choices[0].message.content

result = aurora_mini_code("Write a TypeScript function that validates an email address.")
print(result)
```

Argus captures latency, token usage, inputs/outputs, and agent spans — visible in the Argus dashboard with no extra instrumentation.

---

## Performance

Benchmarks in progress. Independent evaluations on LiveCodeBench, HumanEval+, and MBPP+ will be published here before the stable release.

---

## Model Details

| Field | Value |
|---|---|
| Architecture | Dense Transformer |
| Total Parameters | 12B |
| Base Model | Gemma 4 12B |
| Fine-Tuning | LoRA SFT — curated agentic coding pairs |
| Context Length | 128,000 tokens |
| License | Apache 2.0 |
| Hardware (BF16) | 24 GB VRAM |
| Hardware (4-bit) | ~8 GB VRAM |

---

## Training

Aurora-Code-Mini-1 is trained with LoRA supervised fine-tuning on a curated dataset of coding instruction pairs. Categories covered:

- Code generation (Python, TypeScript, Go, Rust, and more)
- Debugging and root cause analysis
- Code review and refactoring
- Multi-step agentic reasoning and tool use

---

## Roadmap

| Version | Description | Status |
|---|---|---|
| **v1** | LoRA SFT on curated agentic coding pairs. Perciqa system prompt and Argus integration. | Released |
| **v2** | Expanded SFT dataset. Independent benchmark evaluation. | Q3 2026 |
| **v3** | Full fine-tune with extended dataset across generation, debugging, review, and test writing. | Q4 2026 |

---

## System Prompt

```
You are Aurora, an AI code assistant built by Perciqa. You help developers write, review, and understand code. You provide clear, correct, and complete solutions. When you're unsure, you say so.
```

---

## About Perciqa

Perciqa is a Canadian AI company building enterprise models and tools that organisations can deploy, audit, and fully control — on their own infrastructure, on their own terms. Founded in 2023 and based in Canada 🇨🇦.

[perciqa.com](https://perciqa.com) · [GitHub](https://github.com/perciqa)

---

## License

Aurora-Code-Mini-1 is released under the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).

---

Made with ♥ by [Perciqa](https://perciqa.com) 🇨🇦