FineTuneLite

A CPU-optimized LLM fine-tuning studio powered by LM Studio for completely local AI development

FineTuneLite is a lightweight, CPU-only LLM fine-tuning studio designed for local execution on consumer hardware. Fine-tune and chat with small open-source language models using PEFT (Parameter-Efficient Fine-Tuning) and LoRA, all powered by LM Studio. No GPU required, no cloud dependencies, and no API keys needed.

---

Table of Contents

• Features
• Prerequisites
• Installation
• Quick Start
• Usage
• Testing
• Deployment
• Architecture
• Documentation
• Contributing
• License
• Author

---

Features

Core Capabilities

• Dataset Manager: Upload and manage training datasets in JSON, CSV, or TXT formats
• Fine-tuning Configurator: Wizard-style interface for configuring model fine-tuning
• CPU-Optimized Training: Efficient training using PEFT and LoRA techniques
• Training Dashboard: Real-time monitoring of training progress and metrics
• Playground: Interactive chat interface for testing models
• Teacher/Critic Mode: Dual-model evaluation system for quality assessment

LM Studio Integration

• Dynamic Model Loading: Automatically detects and lists all available LM Studio models
• IBM Granite 4.0 H Tiny: Optimized default model for CPU inference
• Model Switching: Seamlessly switch between different models in your library
• Teacher/Critic Evaluation: Use stronger models to evaluate and improve weaker ones
• 100% Local: Complete offline operation with no external dependencies

Technical Features

• Modern Web Interface: Built with Next.js 15 and React
• RESTful API: FastAPI backend with automatic OpenAPI documentation
• Docker Support: Production-ready containerization
• Comprehensive Testing: Automated test suite with performance benchmarking
• Professional UI: Clean, responsive interface with shadcn/ui components

---

Prerequisites

Before installing FineTuneLite, ensure you have the following:

• Node.js 20+: JavaScript runtime for the frontend
• Python 3.10+: Python runtime for the backend
• LM Studio: Download from lmstudio.ai
• 8GB RAM minimum: Recommended for smooth operation
• 2GB free disk space: For application and model storage

---

Installation

Step 1: Install LM Studio

1. Download LM Studio from lmstudio.ai
2. Install and open the application
3. Download IBM Granite 4.0 H Tiny (recommended for CPU)
4. Start the Local Server on port 1234

Step 2: Clone Repository

git clone <repository-url>
cd cious

Step 3: Install Dependencies

Backend:

cd backend
pip install -r requirements.txt

Frontend:

cd frontend
npm install

Step 4: Configure Environment

Backend (.env):

cd backend
cp .env.example .env
# Edit .env if needed (defaults work for local development)

Frontend (.env.local):

cd frontend
# Create .env.local if custom configuration needed
# Default: NEXT_PUBLIC_API_URL=http://localhost:8000

---

Quick Start

Option 1: Using Startup Scripts

Windows:

start.bat

Linux/Mac:

chmod +x start.sh
./start.sh

Option 2: Manual Start

Terminal 1 - Backend:

cd backend
python -m uvicorn main:app --reload

Terminal 2 - Frontend:

cd frontend
npm run dev

Option 3: Docker Deployment

Windows:

deploy-docker.bat

Linux/Mac:

chmod +x deploy-docker.sh
./deploy-docker.sh

Access Application

• Frontend: http://localhost:3000
• Backend API: http://localhost:8000
• API Documentation: http://localhost:8000/docs
• Settings & Testing: http://localhost:3000/settings

---

Usage

1. Dataset Management

Upload a Dataset:

1. Navigate to the Datasets page
2. Click "Upload Dataset"
3. Select a JSON or CSV file
4. View your uploaded datasets in the list

Dataset Format (JSON):

[
  {
    "input": "User question or prompt",
    "output": "Expected model response"
  }
]

2. Chat Playground

Basic Chat:

1. Go to the Playground page
2. Select a model from the dropdown
3. Type your message and send
4. View the model's response

Teacher/Critic Mode:

1. Enable Teacher/Critic mode toggle
2. Select a student model (for responses)
3. Select a teacher model (for evaluation)
4. Chat and receive both responses and critiques

3. Fine-Tuning Configuration

Configure Training:

1. Navigate to the Fine-tune page
2. Select a base model
3. Choose your training dataset
4. Configure hyperparameters:
   • Epochs: 1-3 recommended
   • Batch Size: 1 for CPU
   • Learning Rate: 0.0002 default
   • PEFT Type: LoRA

Note: Full training implementation is in progress. The UI and workflow are ready for demonstration.

4. Settings and Testing

Configure Application:

1. Go to Settings page
2. Verify connection status
3. Configure API endpoints
4. Adjust model preferences

Run Tests:

1. Navigate to Settings > Testing tab
2. Click "Run Tests"
3. Review test results
4. Download test report if needed

---

Testing

Quick API Test

python test_suite.py

Tests:

• Backend health check
• LM Studio connectivity
• Model listing
• Chat completion
• Teacher/Critic evaluation
• Dataset management

Comprehensive Test Suite

python comprehensive_test.py

Features:

• All API endpoints
• Multiple chat scenarios
• Performance benchmarking
• Detailed HTML reports
• Success rate tracking

Expected Performance (CPU-only)

Operation	Expected Time
Health Check	< 0.1s
Model List	0.2-0.5s
Chat (short)	10-15s
Chat (long)	15-25s
Evaluation	10-20s
Dataset Upload	0.1-1s

---

Deployment

Local Development

Use the startup scripts or manual commands as described in Quick Start.

Docker Deployment

Build and Start:

cd infra
docker-compose up --build -d

View Logs:

docker-compose logs -f

Stop Services:

docker-compose down

Production Deployment

Refer to DEPLOYMENT.md for detailed production deployment instructions, including:

• Server setup
• Environment configuration
• Nginx reverse proxy
• SSL/TLS setup
• Process management
• Monitoring and logging

---

Architecture

System Overview

User → Frontend (Next.js) → Backend (FastAPI) → LM Studio
                                ↓
                          SQLite Database
                                ↓
                          File Storage

Technology Stack

Frontend:

• Next.js 15 (React framework)
• TypeScript (type safety)
• Tailwind CSS (styling)
• shadcn/ui (components)

Backend:

• FastAPI (web framework)
• SQLAlchemy (ORM)
• PyTorch (training)
• PEFT (fine-tuning)
• httpx (HTTP client)

Infrastructure:

• Docker (containerization)
• SQLite (database)
• LM Studio (model runtime)

For detailed architecture diagrams, see docs/architecture.md.

---

Documentation

User Guides

• SETUP_GUIDE.md - Detailed setup instructions
• TESTING_GUIDE.md - Testing procedures and best practices
• DEPLOYMENT.md - Production deployment guide

Technical Documentation

• PROJECT_STRUCTURE.md - File organization and structure
• docs/architecture.md - System architecture diagrams
• docs/demo_script.md - Demo walkthrough script
• docs/test_summary.md - Testing documentation

API Documentation

Access the interactive API documentation at http://localhost:8000/docs when the backend is running.

---

Contributing

Contributions are welcome! Please follow these guidelines:

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Write or update tests
5. Update documentation
6. Submit a pull request

Development Setup

1. Follow the installation instructions
2. Install development dependencies
3. Run tests before committing
4. Follow the existing code style

---

License

This project is licensed under the MIT License. See the LICENSE file for details.

---

Author

Made by Aditya Shenvi

• Website: adityacuz.dev
• LinkedIn: linkedin.com/in/adityashenvi
• Open for collaboration and feedback

---

Acknowledgments

• LM Studio for providing an excellent local model runtime
• IBM for the Granite model series
• Hugging Face for PEFT and LoRA libraries
• FastAPI and Next.js communities for excellent frameworks

---

Support

For issues, questions, or feature requests:

1. Check the documentation in the docs/ directory
2. Review the SETUP_GUIDE.md for common issues
3. Run the test suite for diagnostics: python comprehensive_test.py
4. Create an issue on the repository with detailed information

---

Project Status

Current Version: 1.0.0
Status: Production Ready
Last Updated: 2025-11-29

Features Complete:

• Dataset management
• Chat playground
• Teacher/Critic mode
• Settings and testing interface
• Docker deployment
• Comprehensive documentation

In Progress:

• Full PEFT/LoRA training implementation
• WebSocket for live training updates
• Advanced hyperparameter tuning

---

Made with dedication for the local AI community

No cloud dependencies, no API keys, no subscriptions—just pure local AI development