DEV Community

Cover image for HazelJS 0.3.0: The AI-Native Framework for Production-Ready Intelligent Applications
Muhammad Arslan
Muhammad Arslan

Posted on

HazelJS 0.3.0: The AI-Native Framework for Production-Ready Intelligent Applications

#node #typescript #backend #ai

We're thrilled to announce the release of HazelJS 0.3.0, a major milestone that transforms HazelJS into the most comprehensive AI-native backend framework for Node.js. This release brings enterprise-grade machine learning capabilities, advanced RAG systems, and a complete toolkit for building production-ready AI applications.

🎯 What is HazelJS?

HazelJS is a modern, TypeScript-first Node.js framework designed from the ground up for the AI era. Unlike traditional frameworks that bolt on AI features as an afterthought, HazelJS treats AI as a first-class citizen, providing native support for:

  • 🤖 AI Agents with autonomous decision-making
  • 🧠 Machine Learning pipelines and model management
  • 📚 Retrieval-Augmented Generation (RAG) with advanced chunking strategies
  • 💾 Persistent Memory for context-aware applications
  • 🔄 Agentic Workflows with visual flow builders
  • 40+ Enterprise Packages for complete application development

✨ What's New in 0.3.0

🧪 Complete Machine Learning Toolkit (@hazeljs/ml)

The new ML package provides everything you need to build, train, and deploy machine learning models in production:

Model Management & Training 

import { Model, Train, Predict, TrainerService } from '@hazeljs/ml';

@Model({ name: 'sentiment-classifier', version: '1.0.0', framework: 'tensorflow' })
class SentimentModel {
  @Train()
  async train(data: TrainingData) {
    // Your training logic
    return { accuracy: 0.95, loss: 0.05 };
  }

  @Predict()
  async predict(input: { text: string }) {
    return { sentiment: 'positive', confidence: 0.92 };
  }
}
Enter fullscreen mode Exit fullscreen mode

Experiment Tracking

Track your ML experiments with built-in support for metrics, parameters, and artifacts:

import { ExperimentService } from '@hazeljs/ml';

const experiment = experimentService.createExperiment('sentiment-analysis');
const run = experimentService.startRun(experiment.id);

experimentService.logMetric(run.id, 'accuracy', 0.95);
experimentService.logMetric(run.id, 'f1_score', 0.93);
experimentService.logArtifact(run.id, 'model', 'model', modelData);

experimentService.endRun(run.id);
Enter fullscreen mode Exit fullscreen mode

Model Drift Detection

Monitor your models in production with comprehensive drift detection:

import { DriftService } from '@hazeljs/ml';

const driftService = new DriftService();
driftService.setReferenceDistribution('age', trainingData);

const driftResult = driftService.detectDrift('age', productionData, {
  method: 'psi', // Population Stability Index
  threshold: 0.25
});

if (driftResult.driftDetected) {
  console.log(`Drift detected! Score: ${driftResult.score}`);
}
Enter fullscreen mode Exit fullscreen mode

Supports multiple drift detection methods:

  • PSI (Population Stability Index)
  • KS (Kolmogorov-Smirnov)
  • JSD (Jensen-Shannon Divergence)
  • Wasserstein Distance
  • Chi-Square for categorical features

Model Evaluation & Metrics 

import { MetricsService } from '@hazeljs/ml';

const result = await metricsService.evaluate('sentiment-classifier', testData, {
  metrics: ['accuracy', 'precision', 'recall', 'f1']
});

console.log(result.metrics);
// { accuracy: 0.95, precision: 0.94, recall: 0.96, f1Score: 0.95 }
Enter fullscreen mode Exit fullscreen mode

Production Monitoring 

import { MonitorService } from '@hazeljs/ml';

monitorService.registerModel({
  modelName: 'sentiment-classifier',
  modelVersion: '1.0.0',
  featureDrift: { method: 'psi', threshold: 0.25 },
  accuracyMonitor: { threshold: 0.9, windowSize: 100 },
  checkIntervalMinutes: 60
});

monitorService.onAlert((alert) => {
  console.log(`Alert: ${alert.message}`);
  // Send to Slack, PagerDuty, etc.
});
Enter fullscreen mode Exit fullscreen mode

📊 Test Coverage Achievement: The ML package now has 97.52% test coverage with 246 comprehensive tests, ensuring production-ready reliability.

🔍 Advanced RAG Capabilities (@hazeljs/rag)

Enhanced RAG system with production-grade features:

Intelligent Document Chunking 

import { ChunkingStrategy } from '@hazeljs/rag';

// Semantic chunking based on meaning
const semanticChunker = new ChunkingStrategy({
  type: 'semantic',
  maxChunkSize: 512,
  overlapSize: 50
});

// Recursive chunking for structured documents
const recursiveChunker = new ChunkingStrategy({
  type: 'recursive',
  separators: ['\n\n', '\n', '. ', ' ']
});
Enter fullscreen mode Exit fullscreen mode

Multi-Vector Store Support

  • Pinecone - Serverless vector database
  • Weaviate - Open-source vector search
  • Qdrant - High-performance vector similarity
  • Chroma - AI-native embedding database
  • In-Memory - For development and testing

Agentic RAG

Build autonomous RAG systems that can reason and make decisions:

import { AgenticRAG } from '@hazeljs/rag';

const agenticRAG = new AgenticRAG({
  vectorStore: pineconeStore,
  llm: openaiService,
  tools: [webSearchTool, calculatorTool],
  maxIterations: 5
});

const answer = await agenticRAG.query(
  'What were the Q4 2023 revenue figures and how do they compare to Q3?'
);
Enter fullscreen mode Exit fullscreen mode

🤖 Enhanced AI Agent Runtime (@hazeljs/agent)

Build production-ready AI agents with advanced capabilities:

import { Agent, Tool } from '@hazeljs/agent';

@Agent({
  name: 'customer-support-agent',
  model: 'gpt-4',
  temperature: 0.7,
  maxIterations: 10
})
class CustomerSupportAgent {
  @Tool({ description: 'Search knowledge base' })
  async searchKB(query: string) {
    return await this.ragService.search(query);
  }

  @Tool({ description: 'Create support ticket' })
  async createTicket(issue: string, priority: string) {
    return await this.ticketService.create({ issue, priority });
  }
}
Enter fullscreen mode Exit fullscreen mode

💾 Persistent Memory System (@hazeljs/memory)

Give your AI applications long-term memory:

import { MemoryService } from '@hazeljs/memory';

// Store conversation context
await memoryService.store({
  userId: 'user123',
  sessionId: 'session456',
  content: 'User prefers technical explanations',
  metadata: { type: 'preference', importance: 'high' }
});

// Retrieve relevant memories
const memories = await memoryService.recall({
  userId: 'user123',
  query: 'How should I explain this?',
  limit: 5
});
Enter fullscreen mode Exit fullscreen mode

🔄 Visual Flow Builder (@hazeljs/flow + @hazeljs/flow-runtime)

Create complex AI workflows with a visual interface:

import { Flow, FlowNode } from '@hazeljs/flow';

const workflow = new Flow('customer-onboarding')
  .addNode('validate-email', { type: 'validation' })
  .addNode('send-welcome', { type: 'email' })
  .addNode('create-profile', { type: 'database' })
  .addNode('ai-personalization', { type: 'ai-agent' })
  .connect('validate-email', 'send-welcome')
  .connect('send-welcome', 'create-profile')
  .connect('create-profile', 'ai-personalization');

await flowRuntime.execute(workflow, { email: 'user@example.com' });
Enter fullscreen mode Exit fullscreen mode

📊 Data Processing & ETL (@hazeljs/data)

Enterprise-grade data processing with quality checks:

import { DataPipeline, DataContract } from '@hazeljs/data';

@DataContract({
  owner: 'data-team',
  schema: {
    userId: { type: 'string', required: true },
    email: { type: 'string', format: 'email' },
    age: { type: 'number', min: 0, max: 120 }
  },
  sla: { freshness: '1h', completeness: 0.95 }
})
class UserData {}

const pipeline = new DataPipeline()
  .extract(source)
  .transform(cleanData)
  .validate(schema)
  .load(destination);
Enter fullscreen mode Exit fullscreen mode

🛡️ AI Guardrails (@hazeljs/guardrails)

Ensure safe and compliant AI outputs:

import { GuardrailService } from '@hazeljs/guardrails';

const guardrails = new GuardrailService({
  toxicity: { threshold: 0.7 },
  pii: { detect: true, redact: true },
  factuality: { enabled: true },
  bias: { check: true }
});

const result = await guardrails.validate(aiResponse);
if (!result.passed) {
  console.log('Guardrail violations:', result.violations);
}
Enter fullscreen mode Exit fullscreen mode

🏢 40+ Enterprise Packages

HazelJS 0.3.0 includes a complete ecosystem of packages:

Core Infrastructure

  • @hazeljs/core - Framework foundation
  • @hazeljs/config - Configuration management
  • @hazeljs/cache - Multi-tier caching (Redis, Memory)
  • @hazeljs/discovery - Service discovery & registry
  • @hazeljs/gateway - API gateway with rate limiting

AI & ML

  • @hazeljs/ai - Multi-provider AI integration (OpenAI, Anthropic, Gemini, Cohere, Ollama)
  • @hazeljs/ml - Complete ML toolkit
  • @hazeljs/rag - Advanced RAG systems
  • @hazeljs/agent - AI agent runtime
  • @hazeljs/memory - Persistent memory
  • @hazeljs/guardrails - AI safety & compliance
  • @hazeljs/prompts - Prompt management & templates

Data & Integration

  • @hazeljs/data - ETL & data quality
  • @hazeljs/prisma - Prisma ORM integration
  • @hazeljs/typeorm - TypeORM integration
  • @hazeljs/graphql - GraphQL server
  • @hazeljs/grpc - gRPC support
  • @hazeljs/kafka - Kafka integration
  • @hazeljs/queue - Job queues
  • @hazeljs/messaging - Message bus

Security & Auth

  • @hazeljs/auth - JWT authentication
  • @hazeljs/oauth - OAuth 2.0 / OpenID Connect
  • @hazeljs/casl - Authorization (CASL)
  • @hazeljs/audit - Audit logging

DevOps & Monitoring

  • @hazeljs/inspector - Runtime inspector dashboard
  • @hazeljs/ops-agent - Operations agent
  • @hazeljs/resilience - Circuit breakers & retries
  • @hazeljs/serverless - Serverless deployment

Developer Experience

  • @hazeljs/cli - Code generation & scaffolding
  • @hazeljs/swagger - OpenAPI documentation
  • @hazeljs/i18n - Internationalization
  • @hazeljs/cron - Scheduled tasks

View all packages →

🎓 Getting Started

Installation 

# Create a new HazelJS project
npx @hazeljs/cli new my-ai-app

# Or add to existing project
npm install @hazeljs/core @hazeljs/ai @hazeljs/ml @hazeljs/rag
Enter fullscreen mode Exit fullscreen mode

Quick Example: AI-Powered API 

import { Module, Controller, Get, Post, Body } from '@hazeljs/core';
import { AIEnhancedService } from '@hazeljs/ai';
import { RAGService } from '@hazeljs/rag';
import { MetricsService } from '@hazeljs/ml';

@Controller('/api')
class AIController {
  constructor(
    private ai: AIEnhancedService,
    private rag: RAGService,
    private metrics: MetricsService
  ) {}

  @Post('/chat')
  async chat(@Body() { message }: { message: string }) {
    // Use RAG for context
    const context = await this.rag.search(message, { limit: 3 });

    // Generate AI response
    const response = await this.ai
      .chat()
      .system('You are a helpful assistant')
      .context(context)
      .user(message)
      .execute();

    // Track metrics
    await this.metrics.recordEvaluation({
      modelName: 'chat-assistant',
      version: '1.0.0',
      metrics: { responseTime: response.latency }
    });

    return response;
  }
}

@Module({
  controllers: [AIController],
  providers: [AIEnhancedService, RAGService, MetricsService]
})
class AppModule {}
Enter fullscreen mode Exit fullscreen mode

📈 Performance & Reliability

  • 97.52% Test Coverage for ML package
  • Production-tested drift detection algorithms
  • Type-safe APIs with full TypeScript support
  • Modular architecture - use only what you need
  • Enterprise-ready with comprehensive monitoring

🔗 Resources & Links

Package Documentation

Guides & Tutorials

🤝 Community & Support

Join our growing community:

  • GitHub Discussions: Ask questions and share ideas
  • Discord: Real-time chat with the team and community
  • Stack Overflow: Tag your questions with hazeljs

🎯 What's Next?

We're already working on exciting features for the next release:

  • AutoML capabilities for automated model selection
  • Federated Learning support for privacy-preserving ML
  • Enhanced Graph RAG with knowledge graph integration
  • Multi-modal AI support (vision, audio, video)
  • Distributed Training for large-scale ML
  • Real-time Model Serving with optimized inference

💡 Why Choose HazelJS?

AI-Native Architecture

Unlike frameworks that add AI as an afterthought, HazelJS is built from the ground up for AI applications.

Production-Ready

With 97%+ test coverage, comprehensive monitoring, and enterprise features, HazelJS is ready for production workloads.

Developer Experience

TypeScript-first design, intuitive APIs, and excellent documentation make development a joy.

Complete Ecosystem

40+ packages covering everything from AI to databases, authentication to monitoring.

Open Source

Apache 2.0 licensed, community-driven, and transparent development.

🚀 Try It Today 

npx @hazeljs/cli new my-intelligent-app
cd my-intelligent-app
npm run dev
Enter fullscreen mode Exit fullscreen mode

Visit hazeljs.ai to get started and join the AI-native revolution in backend development!

Found this helpful? Give us a ⭐ on GitHub

Questions? Drop a comment below or join our Discord community.

Top comments (0)