SLMGen: The Smart Factory for Small Language Model Fine-Tuning, One-Click from Data to Deployment

SLMGen is an end-to-end automated fine-tuning platform for small language models (SLMs), designed to address a series of pain points developers face during SLM fine-tuning. With features like intelligent dataset analysis, interpretable model recommendations, and automatic Colab notebook generation, it allows developers to complete the entire workflow from data upload to model deployment without complex configurations. Its core values are lowering technical barriers, improving efficiency, ensuring quality, and supporting flexible deployment.

With the rise of SLMs like Phi-4, Llama3.2, and Gemma3, developers face many fine-tuning challenges:

1. Difficulty in model selection: Faced with dozens of models, it's hard to choose the optimal solution based on task characteristics;
2. Unknown dataset quality: Uploaded data may have duplicates, format errors, or uneven distribution;
3. Complex training configuration: Tuning parameters like learning rate, batch size, and LoRA parameters requires professional experience;
4. Tedious deployment process: After training, manual export to formats like Ollama and GGUF is needed for deployment.

SLMGen provides end-to-end support with key features including:

• Intelligent data processing: Drag-and-drop upload of data in formats like JSONL, real-time preview of conversation examples, automatic conversion to ChatML format, and generation of a 0-100% quality score via duplicate detection and consistency checks;
• Hundred-point model matching: Intelligent recommendations based on task adaptability (50% weight), deployment target (30%), and data characteristics (20%), with detailed explanations;
• Multi-model support: Covers 18+ mainstream SLMs such as Phi-4 Mini, Llama3.2, Gemma3, and Qwen2.5;
• Training and deployment: Offers multiple presets like quick demo and production environment, generates Colab notebooks with embedded datasets and Unsloth+LoRA optimizations, and supports export in multiple formats;
• Advanced features: Hallucination risk assessment, confidence scoring, prompt checker, etc.

SLMGen uses a front-end and back-end separation architecture:

• Back-end: Python3.11 runtime, FastAPI framework, Pydantic v2 data validation, Redis7+ session storage, Supabase authentication;
• Front-end: Next.js16 framework, TypeScript language, React19 UI library, Tailwind CSS styling, Framer Motion animations;
• Training and deployment: Efficient fine-tuning via Unsloth+LoRA, front-end deployed on Vercel, back-end deployed on Render.

Applicable Scenarios:

1. Domain-specific customer service robots (fine-tuned based on historical conversations, privacy-protected);
2. Edge device intelligent assistants (e.g., TinyLlama/SmolLM2 deployed on IoT devices);
3. Code assistance tools (fine-tuned based on internal code repositories, integrated with IDEs);
4. Personalized education tutoring (optimized for subjects/student levels);
5. Multilingual localization processing (leveraging Qwen2.5's multilingual capabilities).

Comparison with Traditional Fine-Tuning:

Feature	Traditional Fine-Tuning	SLMGen
Model Selection	Manual trial and error	Intelligent matching
Data Quality	Manual inspection	Automatic scoring
Training Configuration	Manual parameter tuning	Preset optimizations
Deployment Process	Multi-step manual	Automatic export
Development Cycle	Days to weeks	Hours
Technical Threshold	Requires deep learning knowledge	Only needs data upload

Usage Flow: Prepare JSONL data → Upload and analyze → Get model recommendations → Generate Colab notebook → Train and export → Deploy online.

Core Values:

• Lower barriers: Non-professional developers can also customize SLMs;
• Improve efficiency: Shorten development cycle from weeks to hours;
• Ensure quality: Intelligent analysis reduces trial-and-error costs;
• Flexible deployment: Supports multiple export formats and platforms.

Future Directions:

• Support more fine-tuning methods (QLoRA, DoRA, etc.);
• Integrate automatic hyperparameter search;
• Provide model performance comparison and A/B testing;
• Support multi-modal model fine-tuning;
• Enterprise-level team collaboration features.

SLMGen is open-sourced under the MIT license, with code hosted on GitHub. The project structure is clear:

• libslmgen: Python back-end (FastAPI application, core logic);
• slmgenui: Next.js front-end (pages, components);
• docs: Documentation.

Community contributors can participate in:

• Adding support for new models;
• Improving recommendation algorithms;
• Contributing training presets;
• Perfecting documentation and examples.