Capture and access blob data as time series, tailored for edge computing, computer vision, and IoT.
ReductStore handles blob data without size limits; your disk capacity is the only boundary.
Ensure optimal storage management with FIFO quotas, preventing disk space shortages in real-time.
Manage your time-series blob data with ease: annotate, filter, and save AI labels or meta-data.
Integrate and communicate with ReductStore using our feature-rich and secure API.
Minimize network overhead in areas with high latency by fetching records in batched HTTP responses.
import time
import asyncio
from reduct import Client, Bucket
async def main():
client = Client('http://127.0.0.1:8383')
bucket: Bucket = await client.create_bucket("my-bucket", exist_ok=True)
ts = time.time_ns() / 1000
await bucket.write("entry-1", b"Hey!!", ts)
async with bucket.read("entry-1", ts) as record:
data = await record.read_all()
print(data)
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
const {Client} = require("reduct-js")
const client = new Client("http://127.0.0.1:8383");
const main = async () => {
const bucket = await client.getOrCreateBucket("bucket");
const timestamp = Date.now() * 1000;
let record = await bucket.beginWrite("entry-1", timestamp);
await record.write("Hello, World!");
record = await bucket.beginRead("entry-1", timestamp);
console.log((await record.read()).toString());
};
main()
.then(() => console.log("done"))
.catch((err) => console.error("oops: ", err));
#include <reduct/client.h>
#include <iostream>
using reduct::IBucket;
using reduct::IClient;
int main() {
auto client = IClient::Build("http://127.0.0.1:8383");
auto [bucket, create_err] = client->GetOrCreateBucket("bucket");
IBucket::Time ts = IBucket::Time::clock::now();
[[maybe_unused]] auto err = bucket->Write("entry-1", ts, [](auto rec) {
rec->WriteAll("Hello, World!");
});
err = bucket->Read("entry-1", ts, [](auto rec) {
std::cout << "Read record: "
<< rec.ReadAll().result << std::endl;
return true;
});
}
use bytes::Bytes;
use reduct_rs::{HttpError, ReductClient};
use std::str::from_utf8;
use std::time::SystemTime;
use tokio;
#[tokio::main]
async fn main() -> Result<(), HttpError> {
let timestamp = SystemTime::now();
let client = ReductClient::builder().url("http://127.0.0.1:8383").build();
let bucket = client.create_bucket("test").exist_ok(true).send().await?;
bucket
.write_record("entry-1")
.timestamp(timestamp)
.data(Bytes::from("Hello, World!")).send().await?;
let record = bucket
.read_record("entry-1")
.timestamp(timestamp).send().await?;
println!(
"Data: {}",
from_utf8(&record.bytes().await?.to_vec()).unwrap()
);
Ok(())
}
export API_PATH="http://127.0.0.1:8383/api/v1"
# Create a bucket
curl -d "{\"quota_type\":\"FIFO\", \"quota_size\":10000}" \
-X POST -a "${API_PATH}"/b/my_data
# Write some data
export TIME=`date +%s000000`
curl -d "some_data" \
-X POST -a ${API_PATH}/b/my_data/entry_1?ts=${TIME}
# Read the data by using its timestamp
curl -a ${API_PATH}/b/my_data/entry_1?ts=${TIME}
ReductStore has an integrated web console that allows you to easily manage your data and access to it.
reduct@store % pip install reduct-cli
reduct@store % rcli alias add -L https://play.reduct.store -t reduct play
reduct@store % rcli bucket show play/data --full
╭───────────────────── Info ─────────────────╮╭───────── Settings ─────────╮
│ Entry count: 1 ││ Quota Type: FIFO │
│ Size: 30 GB ││ Quota Size: 30 GB │
│ Oldest Record (UTC): 2022-12-20T16:36:41 ││ Max. Block Size: 64 MB │
│ Latest Record (UTC): 2022-12-20T19:15:26 ││ Max. Block Records: 1024 │
│ History Interval: 3 hour(s) ││ │
│ ││ │
│ ││ │
│ ││ │
│ ││ │
│ ││ │
╰────────────────────────────────────────────╯╰────────────────────────────╯
Entries
┏━━━━━━┳━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┓
┃ ┃ ┃ ┃ Oldest Record ┃ Latest Record ┃ ┃
┃ Name ┃ Records ┃ Size ┃ (UTC) ┃ (UTC) ┃ History ┃
┡━━━━━━╇━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━╇━━━━━━━━━━━┩
│ test │ 57154 │ 30 GB │ 2022-12-20T1… │ 2022-12-20T19… │ 3 hour(s) │
└──────┴─────────┴───────┴───────────────┴────────────────┴───────────┘
You can manage your ReductStore instance and export data from it by using ReducStore CLI client. The client is cross-platform, written in Python and available as a PIP package.
Venturing into the new age of intelligent edge computing? Dive deep with ReductStore, not just as a database, but as your guiding light in this AI-centric revolution. Every millisecond, every piece of data counts. Equip yourself with the right tools, tailor-made MLOps functionalities, and the promise of tomorrow.
Explore AI CapabilitiesReductStore is a time series database designed specifically for storing and managing large amounts of blob data. It offers high performance for writing and real-time querying, making it suitable for edge computing, computer vision, and IoT applications. ReductStore is licensed under the Business Source License 1.1.
ReductStore LLC
651 N BROAD ST STE 201
MIDDLETOWN, DE 19709
info@reduct.store