LoNebula/jarvis-moe-v1

My-Jarvis MoE v1

A bilingual (Japanese / English) personal assistant model fine-tuned from Qwen3-30B-A3B, a Mixture-of-Experts model with 30.5B total parameters and 3.3B active parameters per token. This is a public, merged, ready-to-use model that adapts to whoever uses it: it learns the user's name, preferences, tone, and routines from the conversation instead of shipping with any single owner's personal data. It answers in whichever language you write in.

Model overview

Property	Details
Base model	Qwen3-30B-A3B (MoE: 30.5B total / 3.3B active, Apache-2.0)
Method	4-bit QLoRA (NF4 + double quant, bf16 compute) on attention + MoE expert projections, then merged into the base
Languages	Japanese, English
License	Apache-2.0 (merged weights; subject to the base model license)
Author	LoNebula (寝坊ロケット / Nebou Rocket)
Weights format	Merged bfloat16, sharded safetensors (5GB shards), loads directly with transformers

Training data

This model is trained only on public data and contains no single owner's personal information. It is designed so each user can personalize it through conversation or their own local fine-tune, rather than inheriting someone else's identity.

• Aya Dataset (CohereLabs/aya_dataset): Japanese and English instruction rows from the training split (the full dataset has ~202,362 examples across 65 languages; this model uses the JA/EN subset, capped for a single-GPU job). Apache-2.0.
• Japanese instruction corpus (izumi-lab/llm-japanese-dataset): a capped sample of Japanese instruction/response pairs, used to strengthen Japanese instruction-following. CC BY-SA 4.0.
• Persona seed: none. No persona examples are baked into the weights, so personalization can only start after each user loads the model. The model learns the user's name and style from post-load onboarding and local memory.

No owner-curated identity corpus is used. Each user brings their own context at inference time.

Use

The repository contains merged sharded weights, a tokenizer, and a generation_config.json, so it loads directly and generates with sensible defaults. Use a GPU with enough memory for the half-precision MoE weights (active 3.3B parameters per token, 30.5B total in memory).

Learn the user locally (no personal data leaves the machine)

The weights contain no personal data. Personalization happens on the user's own machine with scripts/my_jarvis_pipeline.py:

1. Copy data/my-jarvis-profile.example.json to ~/.my-jarvis/profile.json. It starts empty -- personalization begins after you load the model.
2. On first run the assistant asks 3 onboarding questions (name, interests, preferred tone) and saves the answers locally.
3. Chat history is appended to ~/.my-jarvis/memory.jsonl (local only, git-ignored).
4. Each turn builds system(profile) + recent memory + user message — no retraining needed for basic adaptation.
5. Optional: export local LoRA rows with export_lora_rows() and fine-tune privately. Never upload ~/.my-jarvis/ to the Hub.

from my_jarvis_pipeline import load_profile, load_memory, build_messages

profile = load_profile("~/.my-jarvis/profile.json")
memory = load_memory("~/.my-jarvis/memory.jsonl", limit=6)
messages = build_messages(profile, memory, "今日の調子はどう？")

Or just chat locally (onboards on first run, remembers on device):

python scripts/my_jarvis_chat.py --dry-run   # no weights needed
python scripts/my_jarvis_chat.py --model LoNebula/jarvis-moe-v1

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "LoNebula/jarvis-moe-v1"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

messages = [
    {"role": "system", "content": "You are My-Jarvis, a bilingual (Japanese/English) personal assistant. Learn the user's name and style, and answer in the user's language."},
    {"role": "user", "content": "難しいバグにぶつかったとき、どう進めればいい？"},
]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, return_tensors="pt",
    chat_template_kwargs={"enable_thinking": False},  # Qwen3: non-thinking chat mode
).to(model.device)
output = model.generate(inputs, max_new_tokens=512)
print(tokenizer.decode(output[0][inputs.shape[-1]:], skip_special_tokens=True))

Install the runtime with pip install torch transformers accelerate. The generation_config.json sets temperature=0.7, top_p=0.8, top_k=20; override as needed. This model was fine-tuned with the Qwen3 chat template in non-thinking mode (enable_thinking=False), so pass the same chat_template_kwargs at inference; if your transformers version does not recognize the kwarg, drop it and the template falls back to its default.

Limitations

• This is an experimental assistant, not a benchmarked or production-ready system. It may be inaccurate, reproduce training text, or drift from its intended tone.
• It starts without any user's personal knowledge. Personalization happens per user at inference time (conversation memory or a local adapter), not from baked-in owner data.
• Japanese and English coverage depends on the public corpora above; specialized or low-resource domains may be weak.
• MoE routing means per-token compute is small, but the full 30.5B weights must fit in memory (quantize for smaller GPUs).
• Review outputs before relying on them for important decisions.

License

Apache-2.0, subject to the base model license (Qwen3-30B-A3B, Apache-2.0) and the licenses of the public training data (Aya: Apache-2.0; izumi-lab Japanese corpus: CC BY-SA 4.0). Review source terms before redistribution.