Package Exports

zerolabel
zerolabel/dist/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (zerolabel) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

zerolabel

Zero-shot classification made ridiculously simple

✨ What if you could classify anything without training models?

import { classify } from 'zerolabel';

// Classify single or multiple texts at once
const results = await classify({
  texts: [
    'I love this product!',
    'This is terrible quality',
    'Not bad, could be better'
  ],
  labels: ['positive', 'negative', 'neutral'],
  apiKey: process.env.INFERENCE_API_KEY
});

// Get results for each text
results.forEach((result, i) => {
  console.log(`Text ${i + 1}: ${result.predicted_label} (${result.confidence}%)`);
});

That's it. Text, images, or both. Single items or batches. Any labels you want. Results in milliseconds.

🤔 The Problem

Building classification usually means:

❌ Collecting thousands of labeled examples
❌ Training models for hours/days
❌ Managing ML infrastructure
❌ Retraining when you need new categories

zerolabel solves this in one line of code.

🤔 The Solution

import { classify } from 'zerolabel';

// Classify single or multiple texts at once
const results = await classify({
  texts: [
    'I love this product!',
    'This is terrible quality',
    'Not bad, could be better'
  ],
  labels: ['positive', 'negative', 'neutral'],
  apiKey: process.env.INFERENCE_API_KEY
});

// Get results for each text
results.forEach((result, i) => {
  console.log(`Text ${i + 1}: ${result.predicted_label} (${result.confidence}%)`);
});

That's it. No training, no infrastructure, no complexity.

⚡ Installation

npm install zerolabel

🚀 Examples

Text Classification (Single or Batch)

// Process multiple texts efficiently
await classify({
  texts: [
    'Amazing product!', 
    'Worst purchase ever', 
    'It\'s okay', 
    'Best value for money',
    'Would not recommend'
  ],
  labels: ['positive', 'negative', 'neutral'],
  apiKey: process.env.INFERENCE_API_KEY
});

// Or just one text
await classify({
  texts: ['Single text to classify'],
  labels: ['positive', 'negative', 'neutral'],
  apiKey: process.env.INFERENCE_API_KEY
});

Image Classification

await classify({
  images: ['data:image/jpeg;base64,...'],
  labels: ['cat', 'dog', 'bird'],
  apiKey: process.env.INFERENCE_API_KEY
});

Both Together (Multimodal)

await classify({
  texts: ['Check out this cute animal!'],
  images: ['data:image/jpeg;base64,...'],
  labels: ['cute cat', 'cute dog', 'not cute'],
  apiKey: process.env.INFERENCE_API_KEY
});

Custom Categories

await classify({
  texts: ['Fix login bug', 'Add dark mode', 'Server is down!'],
  labels: ['bug_report', 'feature_request', 'incident'],
  apiKey: process.env.INFERENCE_API_KEY
});

Batch Processing Made Easy

Process thousands of texts efficiently in a single API call:

import { classify } from 'zerolabel';

// Classify entire datasets at once
const reviews = [
  "Amazing product, highly recommend!",
  "Terrible quality, waste of money",
  "It's okay, nothing special",
  "Best purchase I've made this year",
  "Would not buy again",
  // ... thousands more
];

const results = await classify({
  texts: reviews,
  labels: ['positive', 'negative', 'neutral'],
  apiKey: process.env.INFERENCE_API_KEY
});

// Process results
results.forEach((result, index) => {
  console.log(`Review ${index + 1}: ${result.predicted_label} (${result.confidence}%)`);
});

// Or analyze by label distribution
const distribution = results.reduce((acc, result) => {
  acc[result.predicted_label] = (acc[result.predicted_label] || 0) + 1;
  return acc;
}, {});

console.log('Sentiment distribution:', distribution);

Benefits of batch processing:

✅ Faster: Single API call vs. hundreds of individual requests
✅ Cost-effective: Reduced API overhead and latency
✅ Simple: Same API, just pass an array
✅ Scalable: Handle datasets of any size

🎯 Real-World Use Cases

Use Case	Labels	Input
Email Triage	`['urgent', 'normal', 'spam']`	Single email or batch of emails
Content Moderation	`['safe', 'nsfw', 'spam']`	User posts + images (single or batch)
Support Tickets	`['bug', 'feature', 'question']`	Ticket descriptions (process entire queue)
Document Classification	`['invoice', 'receipt', 'contract']`	Document images (single or batch)
Sentiment Analysis	`['positive', 'negative', 'neutral']`	Reviews/feedback (analyze all at once)

🏗️ How It Works

You provide: Text/images and your custom labels
We handle: The AI model (Google Gemma 3-27B), prompting, and inference
You get: Instant predictions with confidence scores

Powered by inference.net infrastructure

📊 Response Format

[
  {
    "text": "I love this product!",
    "predicted_label": "positive", 
    "confidence": 95.2,
    "probabilities": {
      "positive": 0.952,
      "negative": 0.048
    }
  }
]

🔧 Configuration

import { ZeroLabelClient } from 'zerolabel';

const client = new ZeroLabelClient({
  apiKey: process.env.INFERENCE_API_KEY,
  maxRetries: 3
});

const results = await client.classify({
  texts: ['Hello world'],
  labels: ['greeting', 'question']
});

🔑 Getting Your API Key

Sign up at inference.net
Get your API key from the dashboard
Set it as INFERENCE_API_KEY environment variable

export INFERENCE_API_KEY="your-key-here"

💡 Why zerolabel?

Traditional ML	zerolabel
Weeks to collect data	✅ Instant
Hours to train models	✅ No training needed
Complex infrastructure	✅ One npm install
Fixed categories	✅ Any labels you want
Expensive compute	✅ Pay per request

🌟 Live Demo

Try it yourself: zerolabel.dev

📚 API Reference

`classify(options)`

Parameter	Type	Required	Description
`texts`	`string[]`	No*	Array of texts to classify (single or multiple)
`images`	`string[]`	No*	Array of base64 image data URIs
`labels`	`string[]`	✅	Your classification categories
`apiKey`	`string`	✅	Your inference.net API key (set as INFERENCE_API_KEY)
`criteria`	`string`	No	Additional classification criteria

*At least one of texts or images is required

🛠️ TypeScript Support

Full TypeScript definitions included:

import type { 
  ClassificationInput, 
  ClassificationResult,
  ZeroLabelConfig 
} from 'zerolabel';

❓ FAQ

Q: What models does this use?
A: Google Gemma 3-27B, optimized for classification tasks.

Q: How accurate is it?
A: Comparable to fine-tuned models for most classification tasks, especially with descriptive labels.

Q: Can I process multiple texts at once?
A: Yes! Pass an array of texts and get results for each one in a single API call.

Q: Can I use custom models?
A: No, we use inference.net's infrastructure with optimized models for best performance.

Q: Is there a rate limit?
A: Limits depend on your inference.net plan.

🤝 Contributing

Issues and PRs welcome! See our GitHub repo.

📄 License

MIT - Use it however you want!

Made with ❤️ for developers who want AI classification without the complexity

Website • GitHub • npm