Instructions to use Smilyai-labs/Mira-1-large with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Smilyai-labs/Mira-1-large with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Smilyai-labs/Mira-1-large")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Smilyai-labs/Mira-1-large")
model = AutoModelForCausalLM.from_pretrained("Smilyai-labs/Mira-1-large", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Smilyai-labs/Mira-1-large with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Smilyai-labs/Mira-1-large"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Smilyai-labs/Mira-1-large",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/Smilyai-labs/Mira-1-large

SGLang

How to use Smilyai-labs/Mira-1-large with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Smilyai-labs/Mira-1-large" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Smilyai-labs/Mira-1-large",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Smilyai-labs/Mira-1-large" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Smilyai-labs/Mira-1-large",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use Smilyai-labs/Mira-1-large with Docker Model Runner:
```
docker model run hf.co/Smilyai-labs/Mira-1-large
```

Mira

MIRA IS THE LAST MODEL IN THE NOVA SERIES

Mira is a specialized conversational and reasoning model developed by SmilyAI.

Mira is built through a multi-stage model lineage rather than being trained directly from the original Qwen3 checkpoint:

Qwen3-14B → DARE-TIES code/math merge → Nova-2-Large → LoRA fine-tuning → Mira

Mira’s goal is to combine strong coding and mathematical capabilities with a distinctive, friendly personality and useful conversational behavior.

Model Lineage

Qwen3-14B

The underlying architectural foundation comes from Qwen3-14B.

Qwen3 provides the foundation for Mira’s transformer architecture and general language capabilities.

Nova-2-Large

Bc-AI/Nova-2-Large was developed by SmilyAI from the Qwen3-14B foundation.

Nova-2-Large incorporates a DARE-TIES merge focused on improving code and mathematics capabilities.

This means Mira is not a direct Qwen3-14B LoRA model. Its immediate base model is Nova-2-Large.

Mira

Mira is created by applying LoRA fine-tuning to Nova-2-Large.

The fine-tuning focuses primarily on:

Personality
Conversational behavior
Reasoning behavior
Code-related interaction
Self-correction
Helpful technical responses

Model Details

Property Value Model Mira Organization SmilyAI Immediate base model Bc-AI/Nova-2-Large Upstream foundation Qwen3-14B Nova merge DARE-TIES Fine-tuning LoRA Parameters ~14.8B Layers 40 Hidden size 5120 Context length 40,960 tokens Precision bfloat16 Primary language English Architecture Transformer Intended use Conversational AI, coding, reasoning

Capabilities

🧠 Reasoning

Mira is fine-tuned to perform structured reasoning and problem solving.

Its intended reasoning behaviors include:

Breaking complex problems into smaller steps
Checking intermediate conclusions
Revisiting incorrect assumptions
Debugging code methodically
Explaining technical concepts
Verifying solutions where appropriate

When configured with a compatible prompting format, Mira may produce reasoning traces using tags.

Reasoning behavior can vary depending on the inference framework, prompt format, sampling parameters, and deployment configuration.

💻 Coding

Mira inherits much of its coding capability from the Nova-2-Large lineage and its underlying code-focused merge.

It is intended for:

Python
Machine learning
AI engineering
Debugging
Algorithmic reasoning
Code explanation
Technical brainstorming
Small software projects

Mira is designed to review and improve code rather than simply generate code without explanation.

💬 Conversational Personality

Mira was specifically fine-tuned to have a recognizable conversational style.

The intended personality is:

Curious
Friendly
Energetic
Slightly playful
Technically enthusiastic
Honest about limitations
Interested in AI and engineering

Mira is designed to feel more like an AI engineering companion than a purely formal coding assistant.

🔥 Roast Mode

Mira can optionally use a playful “roast mode” during code review.

The principle is:

Roast the code, never the coder.

For example, Mira may humorously point out questionable code while still explaining what is wrong and providing a practical fix.

Roast mode should remain constructive and should not become harassment or personal attacks.

Intended Use

Mira is primarily intended for:

AI/ML experimentation
Programming assistance
Code debugging
Mathematics
Technical discussion
Conversational experimentation
Robotics and engineering brainstorming
Personal AI research and development

Not Intended For

Mira should not be treated as:

A replacement for professional medical, legal, or financial advice
An autonomous decision-maker
A guaranteed source of factual information
A security-critical coding authority
A system whose generated code should automatically be executed without review

Generated outputs should be reviewed by a human before being used in important systems.

Limitations

Despite its capabilities, Mira can still:

Hallucinate facts
Generate incorrect code
Make mathematical mistakes
Misinterpret ambiguous prompts
Produce plausible but incorrect explanations
Fail to recognize when information is outdated
Overestimate its own confidence

Reasoning behavior does not guarantee correctness.

For important tasks, users should independently verify the model’s output.

Training

Mira uses LoRA (Low-Rank Adaptation) for its final fine-tuning stage.

Rather than updating all model parameters, LoRA introduces trainable low-rank adapter weights into the underlying model.

The fine-tuning datasets are focused on:

Personality
Reasoning
Conversational behavior
Technical interaction
Code-oriented behavior

The exact training datasets, training mixture, hyperparameters, and adapter configuration are proprietary to SmilyAI.

Model Architecture

Mira contains approximately 14.8 billion parameters.

Key architectural specifications include:

40 transformer layers
5120-dimensional hidden representation
40,960-token context window
bfloat16 inference/training precision

The model architecture ultimately derives from the Qwen3-14B lineage through Nova-2-Large.

Model Lineage Diagram

Qwen3-14B │ ▼ DARE-TIES Merge (Code / Mathematics) │ ▼ Nova-2-Large (Bc-AI/Nova-2-Large) │ │ LoRA Fine-tuning │ ├── Personality ├── Reasoning ├── Conversation └── Technical behavior │ ▼ Mira (Bc-AI/Mira)

Recommended Generation Settings

These settings are a reasonable starting point and may be adjusted depending on the application.

outputs = model.generate( **inputs, max_new_tokens=512, temperature=0.7, )

For deterministic or highly consistent responses, a lower temperature may be preferable.

For more creative conversational behavior, a somewhat higher temperature can be used.

Usage

from transformers import AutoTokenizer, AutoModelForCausalLM import torch model_name = "Bc-AI/Mira" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, dtype=torch.bfloat16, device_map="auto" ) messages = [ { "role": "user", "content": "Debug this Python function for me" } ] 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][inputs.input_ids.shape[1]:], skip_special_tokens=True ) print(response)

Prompting

Mira works best when given clear instructions and sufficient context.

For coding tasks, providing:

The relevant code
The expected behavior
The observed behavior or error
Any constraints

will generally produce better results.

Example:

I have a Python function that should calculate the average of a list, but it sometimes returns the wrong value. Here is the code: [paste code] Find the bug, explain why it happens, and provide a fix.

Safety

Mira is a general-purpose language model and may generate unsafe, incorrect, or misleading information.

Users are responsible for evaluating generated outputs before acting on them.

The model should not be deployed in safety-critical or high-impact applications without appropriate additional safeguards, testing, and human oversight.

Privacy

Mira is intended for private use.

Users deploying Mira should ensure that their inference environment and any connected applications handle user-provided data appropriately.

Do not provide sensitive personal information to the model unless the deployment environment has appropriate protections.

License

Proprietary — Private Use Only

Mira is not released under a general open-source license.

Permission to use, copy, modify, redistribute, host, or commercially deploy Mira is determined by the terms specified by SmilyAI.

Mira’s upstream model lineage may contain components subject to separate licenses or usage restrictions. Users are responsible for complying with the applicable upstream terms.

Attribution

Mira’s model lineage includes technology derived from the Qwen3-14B model family.

The immediate base model for Mira is:

Bc-AI/Nova-2-Large

Nova-2-Large itself is derived from Qwen3-14B and incorporates a DARE-TIES merge focused on code and mathematics.

Credits

Developed by SmilyAI.

Mira is part of the broader Nova model ecosystem and represents a specialized branch focused on conversational personality, reasoning, coding, and technical assistance.

⸻

Mira — SmilyAI

AI for everyone.

Downloads last month: 202

Safetensors

Model size

15B params

Tensor type

BF16

Model tree for Smilyai-labs/Mira-1-large

Base model

Bc-AI/Mira-1-XL

Adapter

(1)

this model

Adapters

2 models

Smilyai-labs
/

Mira-1-large

Mira

MIRA IS THE LAST MODEL IN THE NOVA SERIES

Model tree for Smilyai-labs/Mira-1-large

Spaces using Smilyai-labs/Mira-1-large 2