Mira-1-large-0919

Mira

Mira is a 14.8B-parameter conversational and reasoning language model developed by SmilyAI.

Mira is designed for programming, mathematics, reasoning, technical discussion, and general conversation, with a distinctive and expressive conversational style.

Current release: 09/19

---

Overview

Mira is a general-purpose language model fine-tuned for technical and conversational interaction.

The final fine-tuning stage focuses on:

• Conversational quality
• Reasoning
• Programming assistance
• Mathematical problem solving
• Technical explanations
• Code review and debugging
• Self-correction
• Instruction following
• Personality

---

Model Specifications

---

Technical Lineage

Mira was developed through the following model pipeline:

Qwen3-14B
↓
DARE-TIES Merge (Code / Mathematics)
↓
Nova-2-Large
↓
LoRA Fine-tuning
↓
Mira

Nova-2-Large is Mira's immediate base model.

The final LoRA fine-tuning stage focuses on conversational behavior, reasoning, programming, personality, and technical interaction.

---

Capabilities

🧠 Reasoning

Mira is fine-tuned for multi-step reasoning and structured problem solving.

Typical use cases include:

• Breaking complex problems into smaller steps
• Comparing possible solutions
• Identifying incorrect assumptions
• Debugging technical problems
• Explaining solutions
• Reviewing and revising previous answers

When supported by the inference framework and prompting format, Mira may use <think> tags for reasoning.

Reasoning performance can vary depending on the task, prompt, inference framework, and generation settings.

---

💻 Programming

Mira is designed for programming and AI engineering tasks.

Use cases include:

• Python development
• Machine learning
• AI engineering
• Debugging
• Algorithm development
• Code review
• Code explanation
• Technical architecture
• Small software projects

Generated code should be reviewed and tested before deployment.

---

➗ Mathematics

Mira is intended to assist with mathematical problem solving and explanations.

Use cases include:

• Algebra
• Numerical problems
• Applied mathematics
• Algorithmic mathematics
• Mathematical reasoning
• Explaining mathematical concepts

Mathematical outputs may contain errors and should be independently verified when accuracy is important.

---

Conversational Style

Mira has been fine-tuned with a distinctive conversational style.

Its intended characteristics include:

• Friendly
• Curious
• Energetic
• Technically enthusiastic
• Slightly playful
• Direct
• Honest about uncertainty

The personality is intended to complement Mira's technical capabilities without interfering with task accuracy.

---

🔥 Roast Mode

Mira supports an optional playful Roast Mode for code review.

The design principle is:

Roast the code, not the developer.

Roast Mode is intended to make code review more entertaining while remaining constructive and focused on technical issues.

---

Intended Use

Mira is intended for:

• Programming assistance
• AI/ML experimentation
• Code debugging
• Mathematical problem solving
• Technical research
• Engineering discussions
• Robotics brainstorming
• Conversational AI experimentation
• Personal AI development

---

Limitations

Mira is a generative language model and can produce incorrect or misleading information.

Potential limitations include:

• Hallucinated information
• Incorrect or incomplete code
• Mathematical errors
• Incorrect assumptions
• Misinterpretation of ambiguous instructions
• Outdated information
• Overconfident responses
• Inconsistent reasoning on difficult problems

Reasoning behavior does not guarantee correctness.

Users should independently verify important technical, mathematical, or factual outputs.

---

Training

Mira's final fine-tuning stage uses LoRA (Low-Rank Adaptation) applied to Nova-2-Large.

The fine-tuning focuses on:

• Conversational behavior
• Reasoning
• Programming
• Technical interaction
• Personality
• Self-correction
• Instruction following

The exact training dataset composition, hyperparameters, LoRA configuration, and training mixture are proprietary to SmilyAI.

---

Architecture

Mira contains approximately 14.8 billion parameters.

Key architectural characteristics:

• 40 transformer layers
• 5,120 hidden dimensions
• 40,960-token context window
• bfloat16 computation

---

Recommended Generation Settings

The following configuration provides a reasonable starting point:

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

Recommended values may vary depending on the application.

Lower temperatures generally produce more deterministic responses, while higher temperatures allow greater output variation.

---

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 generally performs best when instructions provide sufficient context.

For programming tasks, consider including:

1. The relevant code
2. The expected behavior
3. The observed behavior or error
4. Any relevant constraints

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 and Responsible Use

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

It should not be treated as:

• Professional medical advice
• Professional legal advice
• Professional financial advice
• An autonomous decision-maker
• A guaranteed source of factual information
• A security-critical coding authority

For safety-critical or high-impact applications, additional safeguards, testing, and human oversight are recommended.

---

Privacy

Deployers are responsible for ensuring that applications using Mira handle user-provided information appropriately.

This includes inference logs, application databases, external tools, and other systems connected to the model.

Users should avoid providing sensitive personal information unless the deployment environment provides 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 components may be subject to separate licenses and usage requirements. Users are responsible for complying with applicable upstream terms.

---

Attribution

Mira is built using Bc-AI/Nova-2-Large as its immediate base model.

Nova-2-Large is derived from the Qwen3-14B model family and incorporates a DARE-TIES merge.

Users should review the applicable upstream licenses and attribution requirements before redistribution or deployment.

---

Credits

Developed by SmilyAI

Mira is an independent SmilyAI model focused on conversational interaction, reasoning, programming, mathematics, and technical assistance.

---

<div align="center">

Mira — SmilyAI

AI for everyone.

09/19 Release

</div>