NeuroCluster Streamer Algorithm - API
Advanced clustering algorithms, real-time data streaming, and intelligent neural network solutions for modern applications.
Explore the APIAbout
Powering the next generation of intelligent data streaming and clustering solutions
NCS-API Platform
Clustering • Streaming • Intelligence
NeuroCluster Streamer Algorithm
What started as a university project in 2024 has grown into an ongoing exploration of real-time clustering and streaming algorithms. NCS-API is the result of that journey — a platform for experimenting with data clustering, anomaly detection, and algorithmic processing.
- Real-time clustering algorithms optimized for high-throughput data streams.
- RESTful API endpoints with comprehensive documentation and SDK support.
- Scalable architecture built for enterprise workloads with low-latency response times and intelligent load balancing.
Whether you're building recommendation engines, anomaly detection systems, or real-time analytics dashboards, NCS-API gives you the tools to process and cluster data at scale.
Core Capabilities
Explore the building blocks of the NeuroCluster Streamer API platform
Clustering Engine
High-performance clustering algorithms including K-Means, DBSCAN, and custom neural cluster models optimized for real-time data processing.
Real-Time Data Streaming
Stream data through our API with WebSocket and SSE support for live analytics, event-driven architectures, and continuous data pipelines.
Developer-First API
Comprehensive RESTful API with interactive documentation, SDKs for Python, JavaScript, and Go, plus an interactive playground for testing.
Ready to Integrate NCS-API?
Get started with our free tier and scale as you grow. Our API handles millions of data points with sub-millisecond latency. Join developers worldwide building smarter applications.
Services
End-to-end solutions for data streaming, clustering, and intelligent analytics
Neural Clustering
Adaptive clustering algorithms that learn from your data patterns, delivering increasingly accurate groupings over time.
Stream Processing
Ingest and process continuous data streams with our high-throughput pipeline engine supporting WebSocket, SSE, and webhook delivery.
Analytics Dashboard
Visualize cluster distributions, streaming metrics, and model performance in real-time with our built-in analytics tools.
Anomaly Detection
Identify outliers and anomalies in your data streams using our neural network-powered detection models with configurable sensitivity.
API & SDK Integration
RESTful endpoints with official SDKs for Python, JavaScript, Go, and Java. Interactive API playground included with every plan.
Cloud Deployment
Deploy on our managed cloud or self-host on your infrastructure. Auto-scaling, load balancing, and 99.9% uptime guaranteed.
Interactive Playground
Try the NCS clustering algorithm live — send data points and watch clusters form in real time
Controls
Generate points or click the canvas to begin
curl -X POST http://localhost:8000/api/v1/batch \
-H "Content-Type: application/json" \
-d '{
"points": [
{"coordinates": [1.2, 3.4]},
{"coordinates": [1.3, 3.5]},
{"coordinates": [8.1, 9.2]}
]
}'3D Campus Network Monitor
Explore a realistic school building with hundreds of terminals — the NCS algorithm pinpoints threats by room, floor, and physical distance
3D Weather Forecasting
Real Florida weather station locations — the NCS algorithm detects anomalous weather patterns across the state in real time
NCS Algorithm Documentation
Mathematical foundations and core concepts of the NeuroCluster Streamer clustering algorithm
Overview
The NeuroCluster Streamer (NCS) algorithm is a single-pass, online clustering method designed for streaming data. Unlike batch algorithms (K-Means, DBSCAN) that require the full dataset upfront, NCS processes each data point exactly once as it arrives, making it suitable for real-time applications where data flows continuously and cluster structure may evolve over time.
The algorithm maintains a dynamic set of centroids with adaptive distance thresholds. It simultaneously performs cluster assignment, centroid adaptation, and outlier scoring in a single step per data point.
Core Data Structures
The algorithm maintains three parallel arrays that grow as new clusters are discovered:
τ = {τ1, τ2, ..., τk} // Adaptive distance thresholds per cluster
N = {n1, n2, ..., nk} // Assignment counts per cluster
k starts at 0 and grows dynamically up to a configurable maximum Kmax. Each centroid ci is a d-dimensional vector in the same feature space as the input data. Each threshold τi is initialized to a base value τ0 and adapts over time.
Algorithm: Per-Point Processing
For each incoming data point x ∈ &Reals;d:
Step 1 — Bootstrap
If no centroids exist (k = 0), create the first cluster: set c1 = x, τ1 = τ0, n1 = 1. Return cluster ID 0 with outlier score 0.
Step 2 — Nearest Centroid Search
Compute the Euclidean distance from x to every centroid:
Find the nearest centroid: i* = argmini di, with minimum distance d* = di*.
Step 3 — Outlier Scoring
The outlier score is the ratio of the minimum distance to the nearest cluster's threshold:
where ε is a small constant (e.g., 0.001) to prevent division by zero. An outlier score > 1.0 means the point lies beyond its nearest cluster's acceptance radius. Scores well below 1.0 indicate the point is close to the cluster center.
Step 4 — Cluster Assignment or Creation
If d* > τi* (point is outside all cluster boundaries):
- If k < Kmax: create a new cluster with ck+1 = x, τk+1 = τ0
- If k = Kmax: assign to the nearest centroid anyway (forced assignment), but the high outlier score is preserved for downstream anomaly detection
If d* ≤ τi* (point falls within nearest cluster):
- Assign the point to cluster i*
- Proceed to centroid and threshold adaptation (Steps 5 & 6)
Step 5 — Centroid Adaptation (Exponential Moving Average)
The centroid is updated using an exponential moving average with learning rate α:
Typical values: α = 0.05 (slow adaptation, stable clusters) to α = 0.10 (faster tracking of distribution drift). This allows centroids to gradually follow shifting data distributions without being destabilized by individual outliers.
Step 6 — Threshold Adaptation
Each cluster's acceptance threshold adapts based on the distances of points assigned to it:
where β controls the threshold adaptation rate. A small β (e.g., 0.02) makes thresholds change slowly, preserving sensitivity to anomalies. A larger β makes thresholds grow more quickly to accommodate dense clusters. Tight clusters (low average d*) will converge to small thresholds, while dispersed clusters will develop larger acceptance radii.
Parameters
| Symbol | Parameter | Typical Range | Effect |
|---|---|---|---|
| τ0 | Base threshold | 0.3 – 0.5 | Initial acceptance radius for new clusters. Lower values create more clusters; higher values create fewer, broader clusters. |
| α | Learning rate | 0.02 – 0.10 | Controls how quickly centroids move toward new data. Lower = more stable; higher = tracks drift faster. |
| β | Threshold adaptation rate | 0.01 – 0.05 | Controls how quickly cluster boundaries expand or contract. Lower = preserves anomaly sensitivity. |
| Kmax | Maximum clusters | 10 – 50 | Upper bound on cluster count. Prevents unbounded growth in noisy data. Points beyond this limit are force-assigned. |
| ε | Division guard | 0.001 | Small constant added to thresholds during outlier score computation to avoid division by zero. |
Properties & Complexity
Time Complexity
- Per point: O(k · d) — linear scan over k centroids, each with d dimensions
- Total for n points: O(n · k · d)
- With Kmax bound: O(n · Kmax · d) worst case
Space Complexity
- O(k · d) for centroid storage
- O(k) for thresholds and counts
- Does not store historical data points
Key Properties
- Single-pass: Each point is processed exactly once; no iterative convergence loops
- Non-parametric cluster count: k is discovered from data, not specified a priori (unlike K-Means)
- Adaptive boundaries: Cluster radii expand or contract based on observed point distributions
- Built-in anomaly detection: Outlier scores are computed as a byproduct of clustering, not a separate pass
- Order-dependent: Results can vary with input order (inherent to online methods)
- No global objective function: Unlike K-Means (which minimizes within-cluster variance), NCS uses local threshold decisions
Comparison with Standard Algorithms
| Property | NCS | K-Means | DBSCAN |
|---|---|---|---|
| Processing mode | Online (streaming) | Batch (iterative) | Batch (single scan) |
| Cluster count | Discovered automatically | Must be specified (k) | Discovered automatically |
| Handles drift | Yes (EMA adaptation) | No (static after convergence) | No (static after run) |
| Outlier detection | Built-in (score per point) | Not built-in | Yes (noise label) |
| Requires full dataset | No | Yes | Yes |
| Cluster shapes | Spherical (Euclidean) | Spherical (Euclidean) | Arbitrary (density-based) |
| Memory | O(k · d) | O(n · d + k · d) | O(n · d) |
Pseudocode
if |C| = 0:
C ← C ∪ {x}
τ ← τ ∪ {τ0}
N ← N ∪ {1}
return (cluster=0, outlier=0)
// Find nearest centroid
i* ← argmini ‖x − ci‖2
d* ← ‖x − ci*‖2
score ← d* / (τi* + ε)
if d* > τi*:
if |C| < Kmax:
C ← C ∪ {x}
τ ← τ ∪ {τ0}
N ← N ∪ {1}
return (cluster=|C|−1, outlier=score)
else:
ni* ← ni* + 1
return (cluster=i*, outlier=score)
// Update centroid (EMA)
ci* ← (1 − α) · ci* + α · x
// Adapt threshold
τi* ← (1 − β) · τi* + β · d*
ni* ← ni* + 1
return (cluster=i*, outlier=score)
Limitations & Considerations
- Spherical cluster assumption: Like K-Means, NCS uses Euclidean distance and implicitly assumes roughly spherical clusters. It will not correctly separate interlocking or non-convex shapes (where DBSCAN excels).
- Sensitivity to τ0: The base threshold strongly influences how many clusters are created. It must be tuned relative to the scale of the feature space. Feature normalization is recommended.
- Input order dependence: The first few data points seed the initial centroids. Different orderings can produce different cluster structures, especially with small datasets.
- No cluster merging: Once created, clusters are never merged. If two clusters drift close together, they remain separate. A post-processing merge step could address this.
- Linear centroid scan: Each point requires O(k) distance computations. For very large k, a spatial index (e.g., KD-tree) could improve lookup time.
Projects
See how NCS-API powers intelligent solutions across industries
- All
- Applications
- Research
- Integrations
Pricing
Flexible plans that scale with your data needs
Pricing In Development
We're currently finalizing our pricing plans. Please contact us for early access and custom pricing options.
Contact UsFrequently Asked Questions
Common questions about integrating and using the NCS-API platform
What is the NeuroCluster Streamer Algorithm?
NCS-API is a platform that provides advanced clustering algorithms powered by neural networks. It enables real-time data streaming, pattern recognition, and intelligent grouping of data points for applications like recommendation engines, anomaly detection, and analytics.
Which programming languages are supported?
We provide official SDKs for Python, JavaScript/TypeScript, Go, and Java. Our RESTful API can also be consumed from any language that supports HTTP requests. Interactive API documentation with code samples is available for all supported languages.
How does real-time streaming work?
NCS-API supports WebSocket connections and Server-Sent Events (SSE) for real-time data streaming. You can push data continuously into our clustering engine and receive processed results instantly, enabling live dashboards and event-driven architectures.
Can I self-host NCS-API on my own infrastructure?
Yes. Enterprise plan subscribers can deploy NCS-API on their own infrastructure using our Docker images and Kubernetes Helm charts. We also offer a fully managed cloud option with auto-scaling and 99.9% uptime SLA.
What clustering algorithms are available?
NCS-API supports K-Means, DBSCAN, Hierarchical Clustering, Spectral Clustering, and our proprietary NeuroCluster algorithm. Each can be configured with custom parameters, and the platform automatically selects optimal settings based on your data characteristics.
Is there a free tier available?
Yes, our Starter plan is completely free and includes 1,000 API requests per day with access to basic clustering algorithms. It's perfect for prototyping and small projects. You can upgrade to Professional or Enterprise as your needs grow.
Our Team
The mind behind the NeuroCluster Streamer platform
Michael Katsaros
Founder & CEO, Heronix Education SystemsComputer Science student at the University of the People. NCS began as a school project in 2024 — an experiment in streaming clustering algorithms that became a way to practice coding, explore data science concepts, and build something real along the way. Now part of the Heronix ecosystem.
Contact
Get in touch with the NCS-API team for support, partnerships, or inquiries
Address
NeuroCluster Streamer HQ
Website
ncs-api.com
Email Us
info@heronixedu.com