Quick start

From zero to a stored datapoint in about five minutes.

1. Install

Java

The Java SDK is not on Maven Central yet, so build it from the platform repository and install it into your local Maven repository once:

git clone https://github.com/IntelliStream-DataHub/datahub-platform.git
cd datahub-platform
./gradlew :datahub-api-model:publishToMavenLocal :datahub-java-sdk:publishToMavenLocal

Then depend on it:

// build.gradle.kts
repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    implementation("ai.intellistream:datahub-sdk:0.1.0-SNAPSHOT")
}

Python

pip install intellistream-datahub-sdk

Rust

# Cargo.toml
[dependencies]
intellistream-datahub-sdk = "0.1"

The name is long on purpose, and you can shorten it

datahub-sdk was already taken on PyPI by an unrelated project, and the bare datahub neighbourhood belongs to a much better-known metadata platform, so the package is qualified with the organisation and the Rust crate takes the same name. Alias it if you would rather not type it:

import intellistream_datahub_sdk as dh

# Cargo.toml — a crate-wide rename
dh = { package = "intellistream-datahub-sdk", version = "0.1" }

2. Configure credentials

The client reads configuration from the environment (or a .env file): a base URL and either a static token or OAuth2 client-credentials.

BASE_URL=https://api.intellistream.ai
TOKEN=eyJhbGciOi...          # or CLIENT_ID / CLIENT_SECRET / TOKEN_URI

3. Create a client and write a datapoint

Java

var client = DatahubClient.fromEnv();

var series = Timeseries.of("engine_temperature").name("Engine temperature");
series.setUnit("celsius");
series.setValueType("float");
client.timeseries().create(series);

client.timeseries().ingest(Map.of(
    "engine_temperature", List.of(
        Datapoint.of(Instant.now(), 92.4))));

Python

import intellistream_datahub_sdk, pandas as pd
from intellistream_datahub_sdk import DataHubClient

client = DataHubClient.from_env()

client.timeseries.create([
    intellistream_datahub_sdk.TimeSeries(external_id="engine_temperature", unit="celsius", value_type="float")])

client.timeseries.insert_from_lists(
    timestamps=[pd.Timestamp.now(tz="UTC")], values=[92.4], ts="engine_temperature")

Rust

use intellistream_datahub_sdk::create_api_service;
use intellistream_datahub_sdk::timeseries::TimeSeries;
use chrono::Utc;

let api = create_api_service();

let mut ts = TimeSeries::new("engine_temperature", "Engine temperature");
ts.set_unit("celsius");
ts.set_value_type("float");
api.time_series.create_one(&ts).await?;
api.time_series
    .insert_datapoint(None, Some("engine_temperature".into()), Utc::now(), "92.4".into())
    .await?;

4. Read it back

Java

var filter = new RetrieveFilter();
filter.setExternalId("engine_temperature");
filter.setStart(ZonedDateTime.now().minusHours(1));
filter.setEnd(ZonedDateTime.now());

var request = new DataRetriever<RetrieveFilter>();
request.setItems(List.of(filter));

client.timeseries().retrieve(request).getItems()
    .forEach(c -> c.getDatapoints().forEach(System.out::println));

Python

rf = intellistream_datahub_sdk.RetrieveFilter(
    ts="engine_temperature",
    start=pd.Timestamp.now(tz="UTC") - pd.Timedelta(hours=1),
    end=pd.Timestamp.now(tz="UTC"))

for dp in client.timeseries.retrieve_datapoints(rf)[0].get_datapoints():
    print(dp.timestamp, dp.value)

Rust

use intellistream_datahub_sdk::generic::{DataWrapper, RetrieveFilter};

let filter = RetrieveFilter {
    external_id: Some("engine_temperature".into()),
    limit: Some(100),
    ..Default::default()
};
let points = api.time_series.retrieve_datapoints(&DataWrapper::from(vec![filter])).await?;
for c in points.get_items() {
    println!("{} points", c.datapoints.len());
}

Pick once, follow everywhere

The tabs above all switch together — and your choice persists as you move through the docs. One selection for the whole site.

Next: a real program

The tutorial turns these calls into a complete agent: it samples your machine's memory every few seconds, creates its series idempotently, and survives API outages with the durable ingest buffer.