V0.2.1a2 - NoLess CLI - Alpha

Noless CLI

NoLess: Multi-Agent AI Model Builder

                        ╔══════════════════════════════════════════════════════════════════════╗
                        ║                                                                      ║
                        ║  ███╗   ██╗ ██████╗     ██╗     ███████╗███████╗███████╗             ║
                        ║  ████╗  ██║██╔═══██╗    ██║     ██╔════╝██╔════╝██╔════╝             ║
                        ║  ██╔██╗ ██║██║   ██║    ██║     █████╗  ███████╗███████╗             ║
                        ║  ██║╚██╗██║██║   ██║    ██║     ██╔══╝  ╚════██║╚════██║             ║
                        ║  ██║ ╚████║╚██████╔╝    ███████╗███████╗███████║███████║             ║
                        ║  ╚═╝  ╚═══╝ ╚═════╝     ╚══════╝╚══════╝╚══════╝╚══════╝             ║
                        ║                                                                      ║
                        ║  Multi-Agent AI Model Builder | LLM-Powered Intelligence              ║
                        ║  Build AI Models Without Limits | Six Specialized Agents              ║
                        ║  Real-Time Code Generation | Intelligent Dataset Discovery             ║
                        ║                                                                      ║
                        ╚══════════════════════════════════════════════════════════════════════╝

Just some minor changes nothing much .. legacy will work as intended with or without this upgrade

V0.2.1a1 - NoLess CLI - Alpha

NoLess v0.2.1a1 Release Notes

Release Date: November 18, 2025
Version: 0.2.1a1 (Alpha 1)

Overview

NoLess v0.2.1a1 is a significant update focused on code quality automation, intelligent refinement, and small model support. This release introduces automatic code fixing, smart request routing, and robust JSON parsing for better reliability across different language models.

---

What's New

✨ Major Features

1. Automatic Code Fixing (NEW)

• Code review now automatically attempts to fix detected issues
• When issues found but no improvements provided → LLM generates fixes
• Includes retry logic (max 2 attempts) for robustness
• Shows improved code preview for review
• Falls back with actionable suggestions if auto-fix fails

# Now returns improved code automatically!
result = validator.validate_and_improve(code, "model.py", context)
print(result["improved_code"])  # Fixed code

2. Smart Request Routing in Refinement (NEW)

• Keyword-based request classification (10x faster than LLM-only)
• Proper routing for all request types:
  • add → Creates new code/features
  • fix → Fixes bugs and errors
  • optimize → Improves performance
  • refactor → Restructures code
  • explain → Provides code explanations
  • modify → General modifications

User: "add dropout layers"        → Addition handler ✓
User: "fix validation error"      → Modification handler ✓
User: "optimize training speed"   → Modification handler ✓
User: "explain the model"         → Explanation handler ✓

3. Robust JSON Parsing for Small Models (NEW)

• 4-stage JSON parser for reliability
• Handles trailing commas (common in small models)
• Extracts JSON from markdown blocks
• Proper escape sequence handling
• Works reliably with smollm:135m and similar small models

Before: {"valid": true, "issues": [],} → ❌ Parse Error
After: {"valid": true, "issues": [],} → ✅ Parsed Successfully

📈 Performance Optimizations (From v0.2.0)

• Caching System: SQLite-based persistent cache with TTL (99% speedup on hits)
• Async Processing: Parallel LLM calls with rate limiting (3-4x faster)
• Dependency Optimization: Lazy loading reduces package size by 60%
• Code Metrics: Fast analysis without LLM for quick feedback

🎯 Code Quality Features (From v0.2.0)

• Schema Validation: Pydantic v2 models for type-safe validation
• Static Analysis: Security and performance issue detection
• Code Metrics: Cyclomatic complexity, type hints coverage, code grading
• Error Detection: Hardcoded secrets, SQL injection, pickle misuse detection

🧠 Accuracy Improvements (From v0.2.0)

• Few-Shot Prompting: +30-40% accuracy improvement
• Chain-of-Thought: Step-by-step reasoning for better validation
• Iterative Feedback: Self-correcting code with up to 3 refinement rounds
• Hybrid Validation: Combines static analysis, execution testing, and linting

🎨 User Experience Improvements (From v0.2.0)

• Progress Tracking: Real-time progress with detailed step information
• Better Error Messages: Actionable suggestions for 10+ error types
• Output Filtering: Multiple output modes (FULL, ANALYSIS_ONLY, DRY_RUN, SUMMARY)
• Version Tracking: Semantic versioning with noless version command

---

Bug Fixes

🐛 Critical Fixes in v0.2.1a1

1. Code Review Issues Not Being Fixed

Issue: System detected issues but said "no changes required"
Fix: Implemented automatic fix attempt with retry logic
Impact: Issues are now actively fixed, not just reported
Files: noless/code_validator.py

2. Refinement Mode Routing Everything to "Modify"

Issue: User requests like "add feature" went to modification handler
Fix: Smart keyword-based classification + LLM fallback
Impact: Proper routing for all request types
Files: noless/refinement.py

3. Small Model JSON Parsing Failures

Issue: smollm:135m responses with trailing commas failed to parse
Fix: 4-stage robust JSON parser
Impact: Small models now work reliably
Files: noless/code_validator.py

---

Technical Changes

New Methods Added

code_validator.py

• _attempt_to_fix_issues() - Automatically fixes detected issues with retry
• _extract_code_from_response() - Extracts code from LLM responses
• _robust_json_parse() - 4-stage JSON parser for robustness

refinement.py

• Improved _classify_request() - Keyword matching + LLM fallback
• Enhanced _apply_refinement() - Proper routing for all request types

Code Statistics

Metric	Count
New methods	3
Modified methods	4
Lines added	~200
Test cases	15+
Documentation files	5

Files Modified

noless/code_validator.py    (+170 lines)
noless/refinement.py        (+30 lines)
noless/__version__.py       (NEW - version management)
setup.py                    (updated version reading)
noless/cli.py               (added version command)

---

Installation & Upgrade

New Installation

pip install noless==0.2.1a1

Upgrade from v0.2.0

pip install --upgrade noless==0.2.1a1

Verify Installation

noless --version
# Output: NoLess, version 0.2.1a1

---

Dependencies

Core Dependencies (Unchanged)

• Python 3.8+
• click, requests, beautifulsoup4, rich, pydantic

Optional Dependencies

• torch, tensorflow (for advanced features)
• bandit, radon (for enhanced analysis)

New in v0.2.1a1

• Improved JSON parsing (uses built-in json module)
• Better error handling with rich console

---

Breaking Changes

✅ None! This release is 100% backward compatible.

All existing code will work without changes and automatically benefit from improvements.

---

Deprecated Features

None in this release.

---

Known Issues

Minor

• Very large code files (>50KB) may take longer for auto-fix
• Some LLM models may still produce malformed JSON (rare)
• Small model fixes are best-effort, may need larger models for complex code

Workarounds

• For large files: Break into smaller pieces
• For parsing issues: Use larger model (13b, 32b, 70b)
• For auto-fix failures: Simplify code structure

---

Performance Impact

Operation	Before	After	Change
Code review (with issues)	1 LLM call	1-2 calls	+0-100% (if fixing)
Code review (no issues)	1 LLM call	1 call	No change
Request classification	Always LLM	Keywords first	10x faster
JSON parsing	Fragile regex	Robust 4-stage	More reliable
Small model support	Broken	Works	Enabled

---

Testing

Comprehensive Test Suite Included

Run tests with:

python test_fixes.py

Expected output:

✓ Robust JSON parsing: 4/4 pass
✓ Auto-fix logic: Functional
✓ Code extraction: All formats handled
✓ Request classification: 6/6 types correct
✓ Routing logic: All types routed properly
✓ Syntax validation: All files compile

---

Documentation

New Documentation Files

• BUG_FIXES_SUMMARY.md - Detailed technical deep-dive
• FIXES_QUICK_REFERENCE.md - Quick start guide
• BEFORE_AFTER_COMPARISON.md - Behavioral changes
• FIXES_DEPLOYED.md - Deployment checklist
• RELEASE_NOTES_0.2.1a1.md - This file

Updated Documentation

• All existing guides updated with new features
• API documentation includes new methods
• Examples show auto-fix and smart routing

---

Upgrade Path

From v0.1.0

pip install --upgrade noless==0.2.1a1

Features gained: All v0.2.0 + v0.2.1a1 features

From v0.2.0

pip install --upgrade noless==0.2.1a1

Features gained: Auto-fix, smart routing, robust parsing

---

Feature Comparison

Feature	v0.1.0	v0.2.0	v0.2.1a1
Code Review	✓	✓	✓✓ (auto-fix)
Auto-Fix Issues	✗	✗	✓
Smart Routing	✗	✗	✓
Caching	✗	✓	✓
Async Processing	✗	✓	✓
Small Model Support	✗	✗	✓
Code Metrics	✗	✓	✓
Few-Shot Prompting	✗	✓	✓
Refinement Mode	✗	✓	✓✓ (better routing)

---

Usage Examples

Auto-Fix in Action

from noless.code_validator import CodeValidator

validator = CodeValidator(reviewer_model="mistral")

result = validator.validate_and_improve(
    code="""
def train(data):
    model = load()
    for batch in data:
        out = model(batch)
        loss = compute(out)
        opt.step(loss)
    return model
""",
    file_type="train.py",
    context={"task": "classification", "framework": "pytorch"}
)

# Now includes improved_code!
print(result["improved_code"])

# Output:
# def train(data):
#     if not data:
#         raise ValueError("Data required")
#     model = load()
#     if not model:
#         raise RuntimeError("Model load failed")
#     try:
#         for batch in data:
#             if batch is None:
#                 continue
#             out = model(batch)
#             loss = compute(out)
#             opt.step(loss)
#     except Exception as e:
#         raise RuntimeError(f"Training failed: {e}") from e
#     return model

Smart Refinement Routing

from noless.refinement import RefinementAgent

agent = RefinementAgent(llm_model="llama2")

# Automatic routing based on intent
agent._classify_request("add dropout")        # → "add"
agent._classify_request("fix bug")            # → "fix"
agent._classify_request("optimize speed")     # → "optimize"
agent._classify_request("explain model")      # → "expla...

V0.1.1a - NoLess CLI - Alpha

NoLess CLI v0.1.1-alpha - Initial Alpha Release

Release Date: November 16, 2025
Status: Alpha (Experimental)

Introduction

Welcome to the first alpha release of NoLess - an intelligent CLI tool that revolutionizes ML model development by combining multi-agent architecture with local LLMs. This alpha release is feature-complete but still under active testing.

Alpha Release Notice

This is an alpha release intended for:

• Early adopters and testers
• Developers who want to experiment with AI-powered code generation
• Contributors interested in shaping the tool's future

Known limitations:

• Some edge cases in dataset downloading may fail
• Generated code quality varies with model choice
• Performance not yet optimized for all scenarios

We welcome feedback and bug reports!

Core Features

1. Autopilot Mode - One Command to Rule Them All

Build complete ML projects with a single command:

noless autopilot -d "classify dog breeds from images"

What happens behind the scenes:

• LLM analyzes your description
• Asks clarifying questions
• Searches 20,000+ datasets
• Designs optimal architecture
• Generates production-ready code
• Creates tests and documentation

2. Multi-Agent System (6 Specialized Agents)

Agent	Role	Key Features
Orchestrator	Task coordination	Plans workflow, manages execution order
DatasetAgent	Data discovery	Searches OpenML, Kaggle, HuggingFace, UCI
ModelAgent	Architecture design	Recommends ResNet, BERT, LSTM, etc.
CodeAgent	Implementation	Generates model.py, train.py with 100-200 lines
EvaluationAgent	Testing	Creates pytest suites with fixtures
OptimizationAgent	Hyperparameter tuning	Suggests learning rates, batch sizes

All agents work autonomously and communicate via structured protocols.

3. Interactive Feedback Loop

Real-time collaboration with AI:

noless autopilot -i -d "sentiment classifier for tweets"

During interaction:

• View syntax-highlighted code previews
• Give feedback in natural language ("add dropout layers")
• Request AI review from larger expert models
• Accept or regenerate until perfect
• Iterate up to 10 times

4. Local LLM Integration (Ollama)

Privacy-first AI with no cloud dependencies:

Supported models:

• deepseek-r1:1.5b - Fast, lightweight (recommended for generation)
• deepseek-coder:6.7b - Code-specialized
• llama3.1:8b - Balanced quality/speed
• mixtral:8x7b - Expert-grade (recommended for review)
• llama3.1:70b - Maximum quality (if you have 48GB+ RAM)

Dual-model system:

noless autopilot \
  --llm-model deepseek-r1:1.5b \      # Fast generation
  --reviewer-model mixtral:8x7b        # Expert review

5. Multi-Source Dataset Discovery

Search across 4 major repositories simultaneously:

Source	Datasets	Best For
OpenML	5,000+	Tabular, classification
HuggingFace	10,000+	NLP, vision
Kaggle	50,000+	Competitions, real-world
UCI ML	500+	Classic ML benchmarks

noless search "medical imaging chest x-ray" --limit 20

Features:

• Smart keyword extraction using LLMs
• Automatic ranking by relevance
• One-click download and caching
• Metadata extraction (features, samples, task type)

6. Complete Project Generation

Every generated project includes:

my_classifier/
├── model.py              # 100-200 lines
│   ├── Complete architecture (ResNet, BERT, etc.)
│   ├── Forward pass implementation
│   ├── Weight initialization
│   └── Type hints & docstrings
│
├── train.py              # 150-250 lines
│   ├── Data loading & augmentation
│   ├── Training loop with progress bars
│   ├── Validation & metrics
│   ├── Checkpointing & early stopping
│   └── Logging (TensorBoard compatible)
│
├── test_model.py         # 50-100 lines
│   ├── Pytest fixtures
│   ├── Model initialization tests
│   ├── Forward pass tests
│   ├── Shape validation
│   └── Dataset loading tests
│
├── config.yaml           # Hyperparameters
│   ├── Model settings (layers, dropout, etc.)
│   ├── Training config (epochs, batch size, LR)
│   └── Data splits (train/val/test)
│
├── requirements.txt      # All dependencies
└── README.md             # Complete documentation

Code quality guarantees:

• No TODO comments or placeholders
• Complete implementations
• Error handling included
• Type hints everywhere
• Comprehensive docstrings
• Follows PEP 8 style

Installation

Option 1: Install from PyPI (recommended)

pip install noless
noless --version

Option 2: Install from source

git clone https://github.com/yourusername/NoLess.git
cd NoLess
pip install -e .

Required: Install Ollama

# macOS/Linux
curl https://ollama.ai/install.sh | sh

# Windows
# Download from: https://ollama.com

# Pull at least one model
ollama pull deepseek-r1:1.5b

Optional: Configure API Keys

For Kaggle datasets:

# 1. Create account at kaggle.com
# 2. Go to Account → API → Create New Token
# 3. Place kaggle.json in:
#    Linux/macOS: ~/.kaggle/kaggle.json
#    Windows: %USERPROFILE%\.kaggle\kaggle.json

For HuggingFace datasets:

pip install datasets
# No API key needed for public datasets

Quick Start Guide

1. Autopilot (Easiest)

Let AI do everything:

noless autopilot -d "classify handwritten digits"

2. Interactive Autopilot

Collaborate with AI:

noless autopilot -i -d "sentiment analysis on movie reviews"

3. Quick Mode (Skip Questions)

noless autopilot --skip-followups -d "object detection for cars"

4. With Specific Models

noless autopilot \
  --llm-model deepseek-r1:1.5b \
  --reviewer-model mixtral:8x7b \
  -d "time series forecasting for stock prices"

5. Manual Project Creation

noless create \
  -t image-classification \
  -f pytorch \
  -a resnet50 \
  --agents \
  --output ./my_project

6. Search Datasets Only

noless search "cifar10" --source openml
noless search "imdb sentiment" --source huggingface

7. Interactive Menu (For Beginners)

noless interactive

Supported Tasks & Architectures

Computer Vision

Tasks: Classification, Detection, Segmentation
Architectures:

• ResNet (18, 34, 50, 101, 152)
• EfficientNet (B0-B7)
• Vision Transformer (ViT-Base, ViT-Large)
• YOLOv8 (for detection)
• U-Net (for segmentation)

Natural Language Processing

Tasks: Classification, Sequence-to-Sequence, NER
Architectures:

• BERT (Base, Large)
• RoBERTa (Base, Large)
• DistilBERT
• T5 (Small, Base, Large)
• GPT-2

Time Series

Tasks: Forecasting, Anomaly Detection
Architectures:

• LSTM, GRU
• Temporal CNNs
• Transformers
• Prophet

Tabular Data

Tasks: Classification, Regression
Algorithms:

• XGBoost, LightGBM, CatBoost
• Random Forest, Gradient Boosting
• Neural Networks (TabNet, FT-Transformer)

System Requirements

Minimum

• Python: 3.8+
• RAM: 8GB
• Disk: 5GB free
• OS: Windows 10+, macOS 10.15+, Linux

Recommended

• Python: 3.10+
• RAM: 16GB (for 13B+ models)
• Disk: 20GB+ (for datasets)
• GPU: CUDA-capable (optional, for faster training)

For Large Models (70B+)

• RAM: 48GB+
• GPU: 80GB VRAM (A100) or CPU with swap

Performance Benchmarks (Alpha)

Code Generation Speed

Model	Time	Quality
deepseek-r1:1.5b	~30s	Good
llama3.1:8b	~60s	Very Good
mixtral:8x7b	~120s	Excellent

Dataset Search

Source	Avg Response	Results
OpenML	~2s	50-100
HuggingFace	~3s	20-50
Kaggle	~5s	30-80

Benchmarks on AMD Ryzen 9 7950X, 64GB RAM

Known Issues (Alpha)

High Priority

1. OpenML large dataset downloads timeout - Workaround: Use smaller datasets or download manually
2. Kaggle API requires manual setup - Must place kaggle.json in ~/.kaggle/
3. Generated code may have minor import errors - AI reviewer catches most, but check before running

Medium Priority

4. Large models (70B) are very slow - Consider smaller models or cloud inference
5. Some architecture combinations not tested - E.g., BERT + Kaggle dataset
6. Windows terminal Unicode issues - Use --no-startup flag if you see garbled characters

Low Priority

7. Progress bars flicker on some terminals - Cosmetic issue only
8. Agent communication logs are verbose - Will add --quiet flag in beta

Roadmap to Beta (v0.2)

Planned Features

• Auto-train after generation - Run training immediately after code gen
• Model fine-tuning workflows - Update existing models with new data
• Distributed training - Multi-GPU and multi-node support
• Web UI - Browser-based interface for non-CLI users
• More dataset sources - Papers with Code, Roboflow, etc.
• Cloud deployment - One-click deploy to AWS/GCP/Azure
• Experiment tracking - Integration with MLflow, Weights & Biases
• Custom templates - User-defined architecture templates

Performance Improvements

• Parallel agent execution
• Streaming dataset downloads
• Code generation caching
• Better error recovery

Quality Improvements

• More comprehensive tests for generated code
• Better prompt engineering for LLMs
• Architecture validation before generation
• Automatic dependency resolution

Testing...