#!/usr/bin/env node
/**
* AIX API JavaScript/Node.js Client Example
* Complete workflow for training and deploying AI models
*/
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');
class AIXClient {
constructor(baseUrl = 'http://localhost:3000', apiKey = null) {
this.baseUrl = baseUrl.replace(/\/$/, '');
this.apiKey = apiKey;
// Create axios instance with default config
this.client = axios.create({
baseURL: this.baseUrl,
timeout: 300000, // 5 minutes timeout for large uploads
});
// Set authorization header if API key provided
if (apiKey) {
this.client.defaults.headers.common['Authorization'] = `Bearer ${apiKey}`;
}
}
async createProject(name, labels) {
const response = await this.client.post('/api/aix/create-project', {
name,
labels
});
return response.data;
}
async uploadDataset(projectName, imagesDir, labelsDir = null) {
const formData = new FormData();
// Add project name
formData.append('projectName', projectName);
// Add images
const imageFiles = fs.readdirSync(imagesDir);
const imageExtensions = ['.jpg', '.jpeg', '.png', '.bmp'];
for (const file of imageFiles) {
const ext = path.extname(file).toLowerCase();
if (imageExtensions.includes(ext)) {
const filePath = path.join(imagesDir, file);
formData.append('files', fs.createReadStream(filePath), file);
}
}
// Add labels if provided
if (labelsDir && fs.existsSync(labelsDir)) {
const labelFiles = fs.readdirSync(labelsDir);
for (const file of labelFiles) {
if (path.extname(file).toLowerCase() === '.txt') {
const filePath = path.join(labelsDir, file);
formData.append('files', fs.createReadStream(filePath), file);
}
}
}
const response = await this.client.post('/api/aix/upload', formData, {
headers: {
...formData.getHeaders(),
},
maxContentLength: Infinity,
maxBodyLength: Infinity,
});
return response.data;
}
async initializeProject(projectName) {
const response = await this.client.post('/api/aix/init', {
projectName
});
return response.data;
}
async startTraining(projectName) {
const response = await this.client.post('/api/aix/train', {
projectName
});
return response.data;
}
async checkModelStatus(projectName) {
if (!this.apiKey) {
throw new Error('API key required for model operations');
}
const response = await this.client.get(`/api/aix/model-status/${projectName}`);
return response.data;
}
async downloadPyTorchModel(projectName, outputPath = null) {
if (!this.apiKey) {
throw new Error('API key required for model operations');
}
if (!outputPath) {
outputPath = `${projectName}_best.pt`;
}
const response = await this.client.get(`/api/aix/download-model/${projectName}`, {
responseType: 'stream'
});
return new Promise((resolve, reject) => {
const writer = fs.createWriteStream(outputPath);
response.data.pipe(writer);
writer.on('finish', () => resolve(outputPath));
writer.on('error', reject);
});
}
async convertToRKNN(projectName) {
if (!this.apiKey) {
throw new Error('API key required for model operations');
}
const response = await this.client.post(`/api/aix/convert-rknn/${projectName}`, {});
return response.data;
}
async downloadRKNNModel(projectName, outputPath = null) {
if (!this.apiKey) {
throw new Error('API key required for model operations');
}
if (!outputPath) {
outputPath = `${projectName}_model.rknn`;
}
const response = await this.client.get(`/api/aix/download-rknn/${projectName}`, {
responseType: 'stream'
});
return new Promise((resolve, reject) => {
const writer = fs.createWriteStream(outputPath);
response.data.pipe(writer);
writer.on('finish', () => resolve(outputPath));
writer.on('error', reject);
});
}
}
async function main() {
// Configuration
const API_KEY = 'aix_your_api_key_here'; // Generate from API docs page
const BASE_URL = 'http://localhost:3000'; // Change to your AIX server URL
// Project configuration
const PROJECT_NAME = 'my-detection-project';
const LABELS = ['person', 'car', 'bicycle', 'dog', 'cat'];
const IMAGES_DIR = './dataset/images';
const LABELS_DIR = './dataset/labels'; // Optional: YOLO format labels
// Initialize client
const client = new AIXClient(BASE_URL, API_KEY);
try {
console.log('š Starting AIX training workflow...');
// Step 1: Create project
console.log(`š Creating project: ${PROJECT_NAME}`);
const createResult = await client.createProject(PROJECT_NAME, LABELS);
console.log('ā
Project created:', createResult);
// Step 2: Upload dataset
console.log(`š¤ Uploading dataset from ${IMAGES_DIR}`);
const uploadResult = await client.uploadDataset(PROJECT_NAME, IMAGES_DIR, LABELS_DIR);
console.log('ā
Dataset uploaded:', uploadResult);
// Step 3: Initialize project
console.log(`āļø Initializing project: ${PROJECT_NAME}`);
const initResult = await client.initializeProject(PROJECT_NAME);
console.log('ā
Project initialized:', initResult);
// Step 4: Start training
console.log(`šļø Starting training for: ${PROJECT_NAME}`);
const trainResult = await client.startTraining(PROJECT_NAME);
console.log('ā
Training started:', trainResult);
console.log('ā³ Training in progress... Monitor progress in AIX terminal');
console.log('š” You can check model status periodically or wait for training completion');
// Step 5: Wait and check model status (example polling)
console.log('\nš Checking model status...');
const maxAttempts = 10;
let status;
for (let attempt = 0; attempt < maxAttempts; attempt++) {
try {
status = await client.checkModelStatus(PROJECT_NAME);
console.log('š Model status:', status);
if (status.hasPt) {
console.log('š PyTorch model is ready!');
break;
} else {
console.log(`ā³ Waiting for training completion... (attempt ${attempt + 1}/${maxAttempts})`);
await new Promise(resolve => setTimeout(resolve, 30000)); // Wait 30 seconds
}
} catch (error) {
if (error.response?.status === 404) {
console.log('ā³ Model not ready yet, continuing to wait...');
await new Promise(resolve => setTimeout(resolve, 30000));
} else {
throw error;
}
}
}
// Step 6: Download models if available
status = await client.checkModelStatus(PROJECT_NAME);
if (status.hasPt) {
console.log('š„ Downloading PyTorch model...');
const ptPath = await client.downloadPyTorchModel(PROJECT_NAME);
console.log(`ā
PyTorch model saved to: ${ptPath}`);
// Step 7: Convert to RKNN (optional)
console.log('š Converting to RKNN format...');
const convertResult = await client.convertToRKNN(PROJECT_NAME);
if (convertResult.success) {
console.log('ā
Model converted to RKNN successfully');
// Step 8: Download RKNN model
console.log('š„ Downloading RKNN model...');
const rknnPath = await client.downloadRKNNModel(PROJECT_NAME);
console.log(`ā
RKNN model saved to: ${rknnPath}`);
} else {
console.log('ā RKNN conversion failed:', convertResult);
}
} else {
console.log('ā ļø PyTorch model not available yet. Training may still be in progress.');
}
console.log('\nš AIX workflow completed successfully!');
} catch (error) {
console.error('ā Error:', error.response?.data || error.message);
if (error.response?.data) {
console.error('Response data:', error.response.data);
}
}
}
// Run if this file is executed directly
if (require.main === module) {
main().catch(console.error);
}
module.exports = { AIXClient };