How to Check LlamaFactory Model Support Status: A Complete Guide to the Supported Models Registry

You can verify LlamaFactory's support for any model by inspecting the SUPPORTED_MODELS dictionary in src/llamafactory/extras/constants.py, which serves as the single source of truth for all supported architectures.

LlamaFactory maintains a comprehensive registry of compatible models for fine-tuning and inference. Understanding how to query this registry allows you to instantly determine whether new model releases are supported before beginning your training workflow.

Understanding the Model Registry Architecture

The library stores model compatibility data in a centralized registry composed of two core components working together at import time.

The SUPPORTED_MODELS Dictionary

Located in src/llamafactory/extras/constants.py, the SUPPORTED_MODELS variable is an OrderedDict that maps model names to their download locations across Hugging Face, ModelScope, and Modelers Hub. This dictionary represents the definitive source of truth for the entire library.

The register_model_group Function

The registry populates through a series of register_model_group calls within the same file. These helper functions execute during module import to add model families, template configurations, and multimodal flags. For example, the Llama-2 registration block appears around lines 1400-1510 in constants.py.

Human-Readable Documentation

The README.md file contains a "Supported Models" section that generates a markdown table from the same registry data. This provides a quick visual reference without requiring code inspection.

Programmatically Checking Model Support

Query the registry directly within Python to verify support status dynamically.

Listing All Supported Models

Import the registry to enumerate every compatible model:

from llamafactory.extras.constants import SUPPORTED_MODELS, MULTIMODAL_SUPPORTED_MODELS

# List all known model names

print("All supported models:")
for name in SUPPORTED_MODELS:
    print(f" • {name}")

# List only multimodal models (vision/audio support)

print("\nMultimodal models:")
for name in sorted(MULTIMODAL_SUPPORTED_MODELS):
    print(f" • {name}")

Verifying a Specific Model

Check if a new model release exists in the registry:

from llamafactory.extras.constants import SUPPORTED_MODELS

model_to_check = "Qwen3-72B-Instruct"

if model_to_check in SUPPORTED_MODELS:
    print(f"✅ {model_to_check} is supported.")
    # Display source URLs for each hub

    for source, url in SUPPORTED_MODELS[model_to_check].items():
        print(f"   {source}: {url}")
else:
    print(f"❌ {model_to_check} is not currently supported.")

Retrieving Chat Templates

Determine the default conversation template for any supported model:

from llamafactory.extras.constants import DEFAULT_TEMPLATE

model = "Gemma-2-9B-Instruct"
template = DEFAULT_TEMPLATE.get(model, "default")
print(f"The chat template for {model} is: {template}")

Dynamic Pre-Flight Checks

Implement validation before export or training operations:

def can_export(model_name: str) -> bool:
    from llamafactory.extras.constants import SUPPORTED_MODELS
    return model_name in SUPPORTED_MODELS

if not can_export("InternVL3-8B-hf"):
    raise RuntimeError("Model not supported for export")

Command Line Verification Methods

Access the registry without writing Python scripts using these terminal commands.

Direct Python One-Liner

Print the complete sorted model list from any directory:

python -c "from llamafactory.extras.constants import SUPPORTED_MODELS; \
print('\n'.join(sorted(SUPPORTED_MODELS)))"

CLI Version Check

The llamafactory-cli tool displays version information that references the GitHub repository containing the current registry:

llamafactory-cli version

This outputs the welcome banner including version details and repository links, confirming which codebase version you are running.

Keeping Your Registry Current

Model support expands continuously. Verify you have the latest definitions using these methods.

Inspect the Source File

Since SUPPORTED_MODELS builds at import time, the constants.py file on your current branch reflects exactly which models are available. Check the main branch on GitHub for the most recent additions.

Monitor the README

The "Supported Models" table in README.md updates automatically via CI pipelines to mirror the registry. This offers a faster visual scan than reading source code.

Review GitHub Releases

Each release tag bundles a snapshot of the registry. Compare the constants.py file across tags to track when specific model families were added historically.

Contributing New Models

If your target model is missing:

1. Submit a Pull Request: Add a register_model_group block following the pattern of existing entries in src/llamafactory/extras/constants.py
2. Open an Issue: The maintainers typically add community-requested models rapidly

Summary

• The SUPPORTED_MODELS dictionary in src/llamafactory/extras/constants.py serves as the authoritative registry for all compatible models.
• Programmatic verification allows dynamic checking via Python imports before training or export operations.
• Command line access requires only a single Python one-liner to list all supported architectures.
• Multimodal capabilities are tracked separately in MULTIMODAL_SUPPORTED_MODELS for vision and audio models.
• Chat templates map to models through the DEFAULT_TEMPLATE dictionary in the same constants file.
• Updates flow from register_model_group calls in the source code to the README documentation automatically.

Frequently Asked Questions

How do I know if a brand new model is supported by LlamaFactory?

Check the SUPPORTED_MODELS dictionary in src/llamafactory/extras/constants.py. If the model name exists as a key in this OrderedDict, the library supports it. You can verify this programmatically by importing the constant and checking for key membership, or by scanning the "Supported Models" table in the README.md file.

What is the difference between SUPPORTED_MODELS and MULTIMODAL_SUPPORTED_MODELS?

SUPPORTED_MODELS contains all text-based and general-purpose models that LlamaFactory can fine-tune or serve. MULTIMODAL_SUPPORTED_MODELS is a separate registry specifically for vision-language and audio-language models that require additional processing capabilities. Check both dictionaries if your model handles images, video, or audio inputs.

Where does LlamaFactory store the download URLs for supported models?

The download URLs reside within the SUPPORTED_MODELS dictionary values. Each model key maps to a dictionary containing source locations for Hugging Face, ModelScope, and Modelers Hub. This structure is defined in src/llamafactory/extras/constants.py and populated through the register_model_group function calls.

Can I add support for a new model myself?

Yes. You can extend support by adding a new register_model_group block to src/llamafactory/extras/constants.py following the existing pattern used for similar model families. This requires specifying the model name, download URLs, and default chat template. Submit your changes as a Pull Request to the hiyouga/LlamaFactory repository for review.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}