feat: Parakeet Index - Stat Aggregations

.gitignore

···
 .idea/
 .env
 Config.toml
+data/

Cargo.lock

···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "cexpr",
  "clang-sys",
  "itertools 0.12.1",
···
  "syn",
  "which",
 ]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
···
  "metrics",
  "metrics-exporter-prometheus",
  "parakeet-db",
+ "parakeet-index",
  "reqwest",
  "serde",
  "serde_bytes",
···
  "serde_json",
  "tokio",
  "tokio-postgres",
+ "tokio-stream",
  "tokio-tungstenite",
  "tracing",
  "tracing-subscriber",
···
 checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
 dependencies = [
  "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+dependencies = [
+ "cfg-if",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf1bedf64cdb9643204a36dd15b19a6ce8e7aa7f7b105868e9f1fad5ffa7d12"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "byteorder",
  "chrono",
  "diesel_derives",
···
 ]
 
 [[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
 name = "flume"
 version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
 dependencies = [
  "percent-encoding",
+]
+
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
 name = "generic-array"
 version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "ipconfig",
  "lru-cache",
  "once_cell",
- "parking_lot",
+ "parking_lot 0.12.3",
  "rand",
  "resolv-conf",
  "smallvec",
···
 ]
 
 [[package]]
+name = "hyper-timeout"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
+dependencies = [
+ "hyper",
+ "hyper-util",
+ "pin-project-lite",
+ "tokio",
+ "tower-service",
+]
+
+[[package]]
 name = "hyper-tls"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
 
 [[package]]
+name = "instant"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
 name = "ipconfig"
 version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "multimap"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defc4c55412d89136f966bbb339008b474350e5e6e78d2714439c386b3137a03"
+
+[[package]]
 name = "nanorand"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6174bc48f102d208783c2c84bf931bb75927a617866870de8a4ea85597f871f5"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "cfg-if",
  "foreign-types",
  "libc",
···
  "itertools 0.14.0",
  "lexica",
  "parakeet-db",
+ "parakeet-index",
  "serde",
  "serde_json",
  "tokio",
···
 ]
 
 [[package]]
+name = "parakeet-index"
+version = "0.1.0"
+dependencies = [
+ "eyre",
+ "figment",
+ "itertools 0.14.0",
+ "prost",
+ "serde",
+ "sled",
+ "tokio",
+ "tonic",
+ "tonic-build",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
 name = "parakeet-lexgen"
 version = "0.1.0"
 dependencies = [
···
 
 [[package]]
 name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core 0.8.6",
+]
+
+[[package]]
+name = "parking_lot"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
 dependencies = [
  "lock_api",
- "parking_lot_core",
+ "parking_lot_core 0.9.10",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall 0.2.16",
+ "smallvec",
+ "winapi",
 ]
 
 [[package]]
···
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
+ "redox_syscall 0.5.8",
  "smallvec",
  "windows-targets 0.52.6",
 ]
···
 checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
+name = "petgraph"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
+
+[[package]]
 name = "phf"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
 dependencies = [
  "siphasher",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "prost"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2796faa41db3ec313a31f7624d9286acf277b52de526150b7e69f3debf891ee5"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be769465445e8c1474e9c5dac2018218498557af32d9ed057325ec9a41ae81bf"
+dependencies = [
+ "heck",
+ "itertools 0.14.0",
+ "log",
+ "multimap",
+ "once_cell",
+ "petgraph",
+ "prettyplease",
+ "prost",
+ "prost-types",
+ "regex",
+ "syn",
+ "tempfile",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a56d757972c98b346a9b766e3f02746cde6dd1cd1d1d563472929fdd74bec4d"
+dependencies = [
+ "anyhow",
+ "itertools 0.14.0",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52c2c1bf36ddb1a1c396b3601a3cec27c2462e45f07c386894ec3ccf5332bd16"
+dependencies = [
+ "prost",
+]
+
+[[package]]
 name = "quanta"
 version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6df7ab838ed27997ba19a4664507e6f82b41fe6e20be42929332156e5e85146"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+dependencies = [
+ "bitflags 1.3.2",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "errno",
  "libc",
  "linux-raw-sys",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "core-foundation 0.9.4",
  "core-foundation-sys",
  "libc",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271720403f46ca04f7ba6f55d438f8bd878d6b8ca0a1046e8228c4145bcbb316"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "core-foundation 0.10.0",
  "core-foundation-sys",
  "libc",
···
 ]
 
 [[package]]
+name = "sled"
+version = "0.34.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f96b4737c2ce5987354855aed3797279def4ebf734436c6aa4552cf8e169935"
+dependencies = [
+ "crc32fast",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "fs2",
+ "fxhash",
+ "libc",
+ "log",
+ "parking_lot 0.11.2",
+]
+
+[[package]]
 name = "smallvec"
 version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "core-foundation 0.9.4",
  "system-configuration-sys",
 ]
···
  "bytes",
  "libc",
  "mio",
- "parking_lot",
+ "parking_lot 0.12.3",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2",
···
  "futures-channel",
  "futures-util",
  "log",
- "parking_lot",
+ "parking_lot 0.12.3",
  "percent-encoding",
  "phf",
  "pin-project-lite",
···
 ]
 
 [[package]]
+name = "tokio-stream"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
 name = "tokio-tungstenite"
 version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "tonic"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85839f0b32fd242bb3209262371d07feda6d780d16ee9d2bc88581b89da1549b"
+dependencies = [
+ "async-trait",
+ "axum",
+ "base64",
+ "bytes",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-timeout",
+ "hyper-util",
+ "percent-encoding",
+ "pin-project",
+ "prost",
+ "socket2",
+ "tokio",
+ "tokio-stream",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tonic-build"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d85f0383fadd15609306383a90e85eaed44169f931a5d2be1b42c76ceff1825e"
+dependencies = [
+ "prettyplease",
+ "proc-macro2",
+ "prost-build",
+ "prost-types",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "tower"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "futures-core",
  "futures-util",
+ "indexmap",
  "pin-project-lite",
+ "slab",
  "sync_wrapper",
  "tokio",
+ "tokio-util",
  "tower-layer",
  "tower-service",
  "tracing",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "403fa3b783d4b626a8ad51d766ab03cb6d2dbfc46b1c5d4448395e6628dc9697"
 dependencies = [
- "bitflags",
+ "bitflags 2.8.0",
  "bytes",
  "http",
  "http-body",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "372d5b87f58ec45c384ba03563b03544dc5fadc3983e434b286913f5b4a9bb6d"
 dependencies = [
- "redox_syscall",
+ "redox_syscall 0.5.8",
  "wasite",
  "web-sys",
 ]

Cargo.toml

···
     "lexica",
     "parakeet",
     "parakeet-db",
+    "parakeet-index",
     "parakeet-lexgen"
 ]

consumer/Cargo.toml

···
 metrics = "0.24.1"
 metrics-exporter-prometheus = "0.16.2"
 parakeet-db = { path = "../parakeet-db" }
+parakeet-index = { path = "../parakeet-index" }
 reqwest = { version = "0.12.12", features = ["native-tls"] }
 serde = { version = "1.0.217", features = ["derive"] }
 serde_bytes = "0.11"
···
 serde_json = "1.0.134"
 tokio = { version = "1.42.0", features = ["full"] }
 tokio-postgres = { version = "0.7.12", features = ["with-chrono-0_4"] }
+tokio-stream = "0.1.17"
 tokio-tungstenite = { version = "0.26.1", features = ["native-tls"] }
 tracing = "0.1.40"
 tracing-subscriber = "0.3.18"

consumer/run.sh

···
+cargo run

consumer/src/backfill/mod.rs

···
 use crate::config::HistoryMode;
-use crate::indexer::types::{BackfillItem, BackfillItemInner, CollectionType, RecordTypes};
+use crate::indexer::types::{AggregateDeltaStore, BackfillItem, BackfillItemInner};
 use crate::indexer::{self, db as indexer_db};
 use did_resolver::Resolver;
 use diesel_async::pooled_connection::deadpool::Pool;
···
 use metrics::counter;
 use parakeet_db::types::{ActorStatus, ActorSyncState};
 use reqwest::{Client, StatusCode};
+use std::collections::HashMap;
 use std::str::FromStr;
 use std::sync::Arc;
 use tracing::{instrument, Instrument};
···
 mod types;
 
 const PDS_SERVICE_ID: &str = "#atproto_pds";
+// There's a 4MiB limit on parakeet-index, so break delta batches up if there's loads.
+// this should be plenty low enough to not trigger the size limit. (59k did slightly)
+const DELTA_BATCH_SIZE: usize = 32 * 1024;
 
 #[derive(Clone)]
 pub struct BackfillManagerInner {
     pool: Pool<AsyncPgConnection>,
     resolver: Arc<Resolver>,
     client: Client,
+    index_client: parakeet_index::Client,
 }
 
 pub struct BackfillManager {
···
         pool: Pool<AsyncPgConnection>,
         history_mode: HistoryMode,
         resolver: Arc<Resolver>,
+        index_client: parakeet_index::Client,
     ) -> eyre::Result<(Self, Sender<String>)> {
         let client = Client::new();
 
···
                 pool,
                 resolver,
                 client,
+                index_client,
             },
             rx,
             do_backfill: history_mode == HistoryMode::BackfillHistory,
···
         if self.do_backfill {
             for idx in 0..threads {
                 let rx = self.rx.clone();
-                let inner = self.inner.clone();
+                let mut inner = self.inner.clone();
 
                 js.spawn(
                     async move {
                         while let Ok(did) = rx.recv_async().await {
                             tracing::trace!("backfilling {did}");
-                            if let Err(e) = backfill_actor(&inner, &did).await {
+                            if let Err(e) = backfill_actor(&mut inner, &did).await {
                                 tracing::error!(did, "backfill failed: {e}");
                                 counter!("backfill_failure").increment(1);
                             } else {
···
 }
 
 #[instrument(skip(inner))]
-async fn backfill_actor(inner: &BackfillManagerInner, did: &str) -> eyre::Result<()> {
+async fn backfill_actor(inner: &mut BackfillManagerInner, did: &str) -> eyre::Result<()> {
     let mut conn = inner.pool.get().await?;
 
     let (status, sync_state) = db::get_actor_status(&mut conn, did).await?;
···
 
     tracing::trace!("repo pulled - inserting");
 
-    conn.transaction::<(), diesel::result::Error, _>(|t| {
-        Box::pin(async move {
-            db::defer(t).await?;
+    let delta_store = conn
+        .transaction::<_, diesel::result::Error, _>(|t| {
+            Box::pin(async move {
+                let mut delta_store = HashMap::new();
 
-            indexer_db::update_repo_version(t, did, &rev, cid).await?;
+                db::defer(t).await?;
 
-            let mut follow_stats = vec![did.to_string()];
+                indexer_db::update_repo_version(t, did, &rev, cid).await?;
 
-            for (path, (cid, record)) in records {
-                let Some((collection, rkey)) = path.split_once("/") else {
-                    tracing::warn!("record contained invalid path {}", path);
-                    return Err(diesel::result::Error::RollbackTransaction);
-                };
+                // let mut follow_stats = vec![did.to_string()];
 
-                counter!("backfilled_commits", "collection" => collection.to_string()).increment(1);
+                for (path, (cid, record)) in records {
+                    let Some((collection, rkey)) = path.split_once("/") else {
+                        tracing::warn!("record contained invalid path {}", path);
+                        return Err(diesel::result::Error::RollbackTransaction);
+                    };
 
-                let full_path = format!("at://{did}/{path}");
+                    counter!("backfilled_commits", "collection" => collection.to_string())
+                        .increment(1);
 
-                match record {
-                    RecordTypes::AppBskyGraphFollow(record) => {
-                        follow_stats.push(record.subject.clone());
-                        indexer_db::insert_follow(t, did, &full_path, record).await?;
-                    }
-                    _ => indexer::index_op(t, did, cid, record, &full_path, rkey).await?,
+                    let full_path = format!("at://{did}/{path}");
+
+                    indexer::index_op(t, &mut delta_store, did, cid, record, &full_path, rkey)
+                        .await?
                 }
-            }
 
-            db::update_repo_sync_state(t, did, ActorSyncState::Synced).await?;
+                db::update_repo_sync_state(t, did, ActorSyncState::Synced).await?;
 
-            handle_backfill_rows(t, &mut follow_stats, did, &rev).await?;
+                handle_backfill_rows(t, &mut delta_store, did, &rev).await?;
+                tracing::trace!("insertion finished");
 
-            // on second thought, should this be done after the transaction?
-            // if we're loading a chunky repo, we might be a few seconds+ out of date?
-            indexer_db::update_follow_stats(t, &follow_stats).await?;
+                Ok(delta_store)
+            })
+        })
+        .await?;
 
-            tracing::trace!("insertion finished");
-            Ok(())
+    // submit the deltas
+    let delta_store = delta_store
+        .into_iter()
+        .map(|((uri, typ), delta)| parakeet_index::AggregateDeltaReq {
+            typ,
+            uri: uri.to_string(),
+            delta,
         })
-    })
-    .await?;
+        .collect::<Vec<_>>();
+
+    let mut read = 0;
+
+    while read < delta_store.len() {
+        let rem = delta_store.len() - read;
+        let take = DELTA_BATCH_SIZE.min(rem);
+
+        tracing::debug!("reading & submitting {take} deltas");
+
+        let deltas = delta_store[read..read + take].to_vec();
+        inner
+            .index_client
+            .submit_aggregate_delta_batch(parakeet_index::AggregateDeltaBatchReq { deltas })
+            .await?;
+
+        read += take;
+        tracing::debug!("read {read} of {} deltas", delta_store.len());
+    }
 
     Ok(())
 }
 
 async fn handle_backfill_rows(
     conn: &mut AsyncPgConnection,
-    follow_stats: &mut Vec<String>,
+    deltas: &mut impl AggregateDeltaStore,
     repo: &str,
     rev: &str,
 ) -> diesel::QueryResult<()> {
···
                         continue;
                     };
 
-                    match record {
-                        RecordTypes::AppBskyGraphFollow(follow) => {
-                            follow_stats.push(follow.subject.clone());
-                            indexer_db::insert_follow(conn, repo, &item.at_uri, follow).await?;
-                        }
-                        _ => indexer::index_op(conn, repo, cid, record, &item.at_uri, rkey).await?,
-                    }
+                    indexer::index_op(conn, deltas, repo, cid, record, &item.at_uri, rkey).await?
+                }
+                BackfillItemInner::Delete => {
+                    indexer::index_op_delete(conn, deltas, repo, item.collection, &item.at_uri)
+                        .await?
                 }
-                BackfillItemInner::Delete => match item.collection {
-                    CollectionType::BskyFollow => {
-                        if let Some(subject) = indexer_db::delete_follow(conn, &item.at_uri).await?
-                        {
-                            follow_stats.push(subject);
-                        }
-                    }
-                    _ => {
-                        indexer::index_op_delete(conn, repo, item.collection, &item.at_uri).await?
-                    }
-                },
             }
         }
     }

consumer/src/config.rs

···
 
 #[derive(Debug, Deserialize)]
 pub struct Config {
+    pub index_uri: String,
     pub relay_source: String,
     pub database_url: String,
     pub plc_directory: Option<String>,

consumer/src/indexer/db.rs

···
         .await
 }
 
+pub async fn get_post_info_for_delete(
+    conn: &mut AsyncPgConnection,
+    at_uri: &str,
+) -> QueryResult<Option<(Option<String>, Option<String>)>> {
+    schema::posts::table
+        .left_join(
+            schema::post_embed_record::table
+                .on(schema::posts::at_uri.eq(schema::post_embed_record::post_uri)),
+        )
+        .select((
+            schema::posts::parent_uri,
+            schema::post_embed_record::uri.nullable(),
+        ))
+        .filter(schema::posts::at_uri.eq(at_uri))
+        .get_result(conn)
+        .await
+        .optional()
+}
+
 pub async fn upsert_postgate(
     conn: &mut AsyncPgConnection,
     at_uri: &str,
···
         .await
 }
 
-pub async fn delete_like(conn: &mut AsyncPgConnection, at_uri: &str) -> QueryResult<usize> {
+pub async fn delete_like(
+    conn: &mut AsyncPgConnection,
+    at_uri: &str,
+) -> QueryResult<Option<String>> {
     diesel::delete(schema::likes::table)
         .filter(schema::likes::at_uri.eq(at_uri))
-        .execute(conn)
+        .returning(schema::likes::subject)
+        .get_result(conn)
         .await
+        .optional()
 }
 
 pub async fn insert_repost(
···
         .await
 }
 
-pub async fn delete_repost(conn: &mut AsyncPgConnection, at_uri: &str) -> QueryResult<usize> {
+pub async fn delete_repost(
+    conn: &mut AsyncPgConnection,
+    at_uri: &str,
+) -> QueryResult<Option<String>> {
     diesel::delete(schema::reposts::table)
         .filter(schema::reposts::at_uri.eq(at_uri))
-        .execute(conn)
+        .returning(schema::reposts::post)
+        .get_result(conn)
         .await
+        .optional()
 }
 
 pub async fn upsert_chat_decl(

consumer/src/indexer/mod.rs

···
 use crate::config::HistoryMode;
 use crate::firehose::{AtpAccountEvent, AtpCommitEvent, AtpIdentityEvent, CommitOp, FirehoseEvent};
-use crate::indexer::types::{BackfillItem, BackfillItemInner, CollectionType, RecordTypes};
+use crate::indexer::types::{
+    AggregateDeltaStore, BackfillItem, BackfillItemInner, CollectionType, RecordTypes,
+};
 use did_resolver::Resolver;
 use diesel_async::pooled_connection::deadpool::Pool;
 use diesel_async::{AsyncConnection, AsyncPgConnection};
···
 use ipld_core::cid::Cid;
 use metrics::counter;
 use parakeet_db::types::{ActorStatus, ActorSyncState};
+use parakeet_index::AggregateType;
 use std::collections::HashMap;
 use std::hash::BuildHasher;
 use std::sync::Arc;
···
 #[derive(Clone)]
 struct RelayIndexerState {
     backfill_tx: flume::Sender<String>,
+    idxc_tx: Sender<parakeet_index::AggregateDeltaReq>,
     resolver: Arc<Resolver>,
     do_backfill: bool,
 }
···
     pub async fn new(
         pool: Pool<AsyncPgConnection>,
         backfill_tx: flume::Sender<String>,
+        idxc_tx: Sender<parakeet_index::AggregateDeltaReq>,
         resolver: Arc<Resolver>,
         history_mode: HistoryMode,
     ) -> eyre::Result<(Self, Sender<FirehoseEvent>)> {
···
                 backfill_tx,
                 resolver,
                 do_backfill: history_mode == HistoryMode::BackfillHistory,
+                idxc_tx,
             },
             rx,
             hasher: RandomState::default(),
···
         let (submit, _handles) = (0..threads)
             .map(|idx| {
                 let pool = self.pool.clone();
-                let state = self.state.clone();
+                let mut state = self.state.clone();
                 let (tx, mut rx) = channel(16);
 
                 let handle = tokio::spawn(async move {
···
                                 index_account(&state, &mut conn, account).await
                             }
                             FirehoseEvent::Commit(commit) => {
-                                index_commit(&state, &mut conn, commit).await
+                                index_commit(&mut state, &mut conn, commit).await
                             }
                             FirehoseEvent::Label(_) => unreachable!(),
                         };
···
 
 #[instrument(skip_all, fields(seq = commit.seq, repo = commit.repo, rev = commit.rev))]
 async fn index_commit(
-    state: &RelayIndexerState,
+    state: &mut RelayIndexerState,
     conn: &mut AsyncPgConnection,
     commit: AtpCommitEvent,
 ) -> eyre::Result<()> {
···
                 }
 
                 for op in &commit.ops {
-                    process_op(t, &commit.repo, op, &blocks).await?;
+                    process_op(t, &mut state.idxc_tx, &commit.repo, op, &blocks).await?;
                 }
             } else {
                 let items = commit
···
 #[inline(always)]
 async fn process_op(
     conn: &mut AsyncPgConnection,
+    deltas: &mut impl AggregateDeltaStore,
     repo: &str,
     op: &CommitOp,
     blocks: &HashMap<Cid, Vec<u8>>,
···
             return Ok(());
         };
 
-        index_op(conn, repo, cid, decoded, &full_path, rkey).await?;
+        index_op(conn, deltas, repo, cid, decoded, &full_path, rkey).await?;
     } else if op.action == "delete" {
-        index_op_delete(conn, repo, collection, &full_path).await?;
+        index_op_delete(conn, deltas, repo, collection, &full_path).await?;
     } else {
         tracing::warn!("op contained invalid action {}", op.action);
     }
···
 
 pub async fn index_op(
     conn: &mut AsyncPgConnection,
+    deltas: &mut impl AggregateDeltaStore,
     repo: &str,
     cid: Cid,
     record: RecordTypes,
···
         }
         RecordTypes::AppBskyFeedGenerator(record) => {
             let labels = record.labels.clone();
-            db::upsert_feedgen(conn, repo, cid, at_uri, record).await?;
+            let count = db::upsert_feedgen(conn, repo, cid, at_uri, record).await?;
 
             if let Some(labels) = labels {
                 db::maintain_self_labels(conn, repo, Some(cid), at_uri, labels).await?;
             }
+
+            deltas
+                .add_delta(repo, AggregateType::ProfileFeed, count as i32)
+                .await;
         }
         RecordTypes::AppBskyFeedLike(record) => {
-            db::insert_like(conn, repo, at_uri, record).await?;
+            let subject = record.subject.uri.clone();
+            let count = db::insert_like(conn, repo, at_uri, record).await?;
+
+            deltas
+                .add_delta(&subject, AggregateType::Like, count as i32)
+                .await;
         }
         RecordTypes::AppBskyFeedPost(record) => {
             if let Some(records::AppBskyEmbed::RecordWithMedia(embed)) = &record.embed {
···
                 }
             }
 
+            let maybe_reply = record.reply.as_ref().map(|v| v.parent.uri.clone());
+            let maybe_embed = record.embed.as_ref().and_then(|v| match v {
+                records::AppBskyEmbed::Record(r) => Some(r.record.uri.clone()),
+                records::AppBskyEmbed::RecordWithMedia(r) => Some(r.record.record.uri.clone()),
+                _ => None,
+            });
+
             let labels = record.labels.clone();
             db::insert_post(conn, repo, cid, at_uri, record).await?;
             if let Some(labels) = labels {
                 db::maintain_self_labels(conn, repo, Some(cid), at_uri, labels).await?;
             }
+
+            deltas.incr(repo, AggregateType::ProfilePost).await;
+            if let Some(reply) = maybe_reply {
+                deltas.incr(&reply, AggregateType::Reply).await;
+            }
+            if let Some(embed) = maybe_embed {
+                deltas.incr(&embed, AggregateType::Embed).await;
+            }
         }
         RecordTypes::AppBskyFeedPostgate(record) => {
             let split_aturi = record.post.rsplitn(4, '/').collect::<Vec<_>>();
···
             .await?;
         }
         RecordTypes::AppBskyFeedRepost(record) => {
+            deltas
+                .incr(&record.subject.uri, AggregateType::Repost)
+                .await;
             db::insert_repost(conn, repo, at_uri, record).await?;
         }
         RecordTypes::AppBskyFeedThreadgate(record) => {
···
             db::insert_block(conn, repo, at_uri, record).await?;
         }
         RecordTypes::AppBskyGraphFollow(record) => {
-            db::insert_follow(conn, repo, at_uri, record).await?;
+            let subject = record.subject.clone();
+            let count = db::insert_follow(conn, repo, at_uri, record).await?;
+
+            deltas
+                .add_delta(repo, AggregateType::Follow, count as i32)
+                .await;
+            deltas
+                .add_delta(&subject, AggregateType::Follower, count as i32)
+                .await;
         }
         RecordTypes::AppBskyGraphList(record) => {
             let labels = record.labels.clone();
-            db::upsert_list(conn, repo, at_uri, cid, record).await?;
+            let count = db::upsert_list(conn, repo, at_uri, cid, record).await?;
 
             if let Some(labels) = labels {
                 db::maintain_self_labels(conn, repo, Some(cid), at_uri, labels).await?;
             }
 
-            // todo: when we have profile stats, update them.
+            deltas
+                .add_delta(repo, AggregateType::ProfileList, count as i32)
+                .await;
         }
         RecordTypes::AppBskyGraphListBlock(record) => {
             db::insert_list_block(conn, repo, at_uri, record).await?;
···
             db::insert_list_item(conn, at_uri, record).await?;
         }
         RecordTypes::AppBskyGraphStarterPack(record) => {
-            db::upsert_starterpack(conn, repo, cid, at_uri, record).await?;
+            let count = db::upsert_starterpack(conn, repo, cid, at_uri, record).await?;
+            deltas
+                .add_delta(repo, AggregateType::ProfileStarterpack, count as i32)
+                .await;
         }
         RecordTypes::AppBskyGraphVerification(record) => {
             db::upsert_verification(conn, repo, cid, at_uri, record).await?;
···
 
 pub async fn index_op_delete(
     conn: &mut AsyncPgConnection,
+    deltas: &mut impl AggregateDeltaStore,
     repo: &str,
     collection: CollectionType,
     at_uri: &str,
···
     match collection {
         CollectionType::BskyProfile => db::delete_profile(conn, repo).await?,
         CollectionType::BskyBlock => db::delete_block(conn, at_uri).await?,
-        CollectionType::BskyFeedGen => db::delete_feedgen(conn, at_uri).await?,
-        CollectionType::BskyFeedLike => db::delete_like(conn, at_uri).await?,
-        CollectionType::BskyFeedPost => db::delete_post(conn, at_uri).await?,
+        CollectionType::BskyFeedGen => {
+            let count = db::delete_feedgen(conn, at_uri).await?;
+            deltas
+                .add_delta(repo, AggregateType::ProfileFeed, -(count as i32))
+                .await;
+            count
+        }
+        CollectionType::BskyFeedLike => {
+            if let Some(subject) = db::delete_like(conn, at_uri).await? {
+                deltas.decr(&subject, AggregateType::Like).await;
+            }
+            0
+        }
+        CollectionType::BskyFeedPost => {
+            let post_info = db::get_post_info_for_delete(conn, at_uri).await?;
+
+            db::delete_post(conn, at_uri).await?;
+
+            if let Some((reply_to, embed)) = post_info {
+                deltas.decr(repo, AggregateType::ProfilePost).await;
+                if let Some(reply_to) = reply_to {
+                    deltas.decr(&reply_to, AggregateType::Reply).await;
+                }
+                if let Some(embed) = embed {
+                    deltas.decr(&embed, AggregateType::Embed).await;
+                }
+            }
+
+            0
+        }
         CollectionType::BskyFeedPostgate => db::delete_postgate(conn, at_uri).await?,
-        CollectionType::BskyFeedRepost => db::delete_repost(conn, at_uri).await?,
+        CollectionType::BskyFeedRepost => {
+            if let Some(subject) = db::delete_repost(conn, at_uri).await? {
+                deltas.decr(&subject, AggregateType::Repost).await;
+            }
+            0
+        }
         CollectionType::BskyFeedThreadgate => db::delete_threadgate(conn, at_uri).await?,
         CollectionType::BskyFollow => {
-            db::delete_follow(conn, at_uri).await?;
+            if let Some(followee) = db::delete_follow(conn, at_uri).await? {
+                deltas.decr(&followee, AggregateType::Follower).await;
+                deltas.decr(repo, AggregateType::Follow).await;
+            }
             0
         }
         CollectionType::BskyList => {
-            db::delete_list(conn, at_uri).await?
-            // todo: when we have profile stats, update them.
+            let count = db::delete_list(conn, at_uri).await?;
+            deltas
+                .add_delta(repo, AggregateType::ProfileList, -(count as i32))
+                .await;
+            count
         }
         CollectionType::BskyListBlock => db::delete_list_block(conn, at_uri).await?,
         CollectionType::BskyListItem => db::delete_list_item(conn, at_uri).await?,
-        CollectionType::BskyStarterPack => db::delete_starterpack(conn, at_uri).await?,
+        CollectionType::BskyStarterPack => {
+            let count = db::delete_starterpack(conn, at_uri).await?;
+            deltas
+                .add_delta(repo, AggregateType::ProfileStarterpack, -(count as i32))
+                .await;
+            count
+        }
         CollectionType::BskyVerification => db::delete_verification(conn, at_uri).await?,
         CollectionType::BskyLabelerService => db::delete_label_service(conn, at_uri).await?,
         CollectionType::ChatActorDecl => db::delete_chat_decl(conn, at_uri).await?,

consumer/src/indexer/types.rs

···
     Update(RecordTypes),
     Delete,
 }
+
+pub trait AggregateDeltaStore {
+    async fn add_delta(&mut self, uri: &str, typ: parakeet_index::AggregateType, delta: i32);
+    async fn incr(&mut self, uri: &str, typ: parakeet_index::AggregateType) {
+        self.add_delta(uri, typ, 1).await
+    }
+    async fn decr(&mut self, uri: &str, typ: parakeet_index::AggregateType) {
+        self.add_delta(uri, typ, -1).await
+    }
+}
+
+impl AggregateDeltaStore for tokio::sync::mpsc::Sender<parakeet_index::AggregateDeltaReq> {
+    async fn add_delta(&mut self, uri: &str, typ: parakeet_index::AggregateType, delta: i32) {
+        let res = self
+            .send(parakeet_index::AggregateDeltaReq {
+                typ: typ.into(),
+                uri: uri.to_string(),
+                delta,
+            })
+            .await;
+
+        if let Err(e) = res {
+            tracing::error!("failed to send aggregate delta: {e}");
+        }
+    }
+}
+
+impl AggregateDeltaStore for std::collections::HashMap<(String, i32), i32> {
+    async fn add_delta(&mut self, uri: &str, typ: parakeet_index::AggregateType, delta: i32) {
+        let key = (uri.to_string(), typ.into());
+        self.entry(key).and_modify(|v| *v += delta).or_insert(delta);
+    }
+}

consumer/src/main.rs

···
         ..Default::default()
     })?);
 
+    let index_client = parakeet_index::Client::connect(conf.index_uri).await?;
+
     let (label_mgr, label_svc_tx) = label_indexer::LabelServiceManager::new(
         &conf.database_url,
         resolver.clone(),
···
     let (backfiller, backfill_tx) =
         backfill::BackfillManager::new(pool.clone(), conf.history_mode, resolver.clone()).await?;
 
+    let (idxc_tx, idxc_rx) = tokio::sync::mpsc::channel(128);
+
     let (relay_indexer, tx) = indexer::RelayIndexer::new(
         pool.clone(),
         backfill_tx,
+        idxc_tx,
         resolver.clone(),
         conf.history_mode,
     )
     .await?;
 
-    let (firehose_res, indexer_res, backfill_res, label_res) = tokio::try_join! {
+    let (firehose_res, indexer_res, backfill_res, label_res, idxt_res) = tokio::try_join! {
         tokio::spawn(relay_consumer(relay_firehose, tx)),
         tokio::spawn(relay_indexer.run(conf.indexer_workers)),
         tokio::spawn(backfiller.run(conf.backfill_workers)),
         tokio::spawn(label_mgr.run(conf.initial_label_services)),
+        tokio::spawn(index_transport(index_client, idxc_rx)),
     }?;
 
     firehose_res
         .and(indexer_res)
         .and(backfill_res)
         .and(label_res)
+        .and(idxt_res)
 }
 
 async fn relay_consumer(
···
             }
         }
     }
+
+    Ok(())
+}
+
+async fn index_transport(mut idxc: parakeet_index::Client, rx: tokio::sync::mpsc::Receiver<parakeet_index::AggregateDeltaReq>) -> eyre::Result<()> {
+    use tokio_stream::wrappers::ReceiverStream;
+
+    idxc.submit_aggregate_delta_stream(ReceiverStream::new(rx)).await?;
 
     Ok(())
 }

parakeet-index/Cargo.toml

···
+[package]
+name = "parakeet-index"
+version = "0.1.0"
+edition = "2024"
+
+[[bin]]
+name = "parakeet-index"
+required-features = ["server"]
+
+[dependencies]
+tonic = "0.13.0"
+prost = "0.13.5"
+
+eyre = { version = "0.6.12", optional = true }
+figment = { version = "0.10.19", features = ["env", "toml"], optional = true }
+itertools = { version = "0.14.0", optional = true }
+serde = { version = "1.0.217", features = ["derive"], optional = true }
+sled = { version = "0.34.7", optional = true }
+tokio = { version = "1.42.0", features = ["full"], optional = true }
+tracing = { version = "0.1.40", optional = true }
+tracing-subscriber = { version = "0.3.18", optional = true }
+
+[build-dependencies]
+tonic-build = "0.13.0"
+
+[features]
+server = ["dep:eyre", "dep:figment", "dep:itertools", "dep:serde", "dep:sled", "dep:tokio", "dep:tracing", "dep:tracing-subscriber"]

parakeet-index/build.rs

···
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tonic_build::configure().compile_protos(&["proto/parakeet.proto"], &[""])?;
+
+    Ok(())
+}

parakeet-index/proto/parakeet.proto

···
+syntax = "proto3";
+package parakeet;
+
+service Index {
+  rpc SubmitAggregateDelta(AggregateDeltaReq) returns (AggregateDeltaRes);
+  rpc SubmitAggregateDeltaBatch(AggregateDeltaBatchReq) returns (AggregateDeltaRes);
+  rpc SubmitAggregateDeltaStream(stream AggregateDeltaReq) returns (AggregateDeltaRes);
+
+  rpc GetProfileStats(GetStatsReq) returns (GetProfileStatsRes);
+  rpc GetProfileStatsMany(GetStatsManyReq) returns (GetProfileStatsManyRes);
+  rpc GetPostStats(GetStatsReq) returns (GetPostStatsRes);
+  rpc GetPostStatsMany(GetStatsManyReq) returns (GetPostStatsManyRes);
+  rpc GetLikeCount(GetStatsReq) returns (GetLikeCountRes);
+  rpc GetLikeCountMany(GetStatsManyReq) returns (GetLikeCountManyRes);
+}
+
+enum AggregateType {
+  UNKNOWN = 0;
+  FOLLOW = 1;
+  FOLLOWER = 2;
+  LIKE = 3;
+  REPLY = 4;
+  REPOST = 5;
+  // aka Quotes (in the context of posts)
+  EMBED = 6;
+  PROFILE_POST = 7;
+  PROFILE_LIST = 8;
+  PROFILE_FEED = 9;
+  PROFILE_STARTERPACK = 10;
+}
+
+message AggregateDeltaReq {
+  // The type of aggregate to change
+  AggregateType typ = 1;
+  // The entry to change. Can be a full at:// uri for items or a did for actors/profiles
+  string uri = 2;
+  sint32 delta = 3;
+}
+
+message AggregateDeltaBatchReq {
+  repeated AggregateDeltaReq deltas = 1;
+}
+
+message AggregateDeltaRes {}
+
+message GetStatsReq {
+  string uri = 1;
+}
+
+message GetStatsManyReq {
+  repeated string uris = 1;
+}
+
+message ProfileStats {
+  int32 followers = 1;
+  int32 following = 2;
+  int32 posts = 3;
+  int32 lists = 4;
+  int32 feeds = 5;
+  int32 starterpacks = 6;
+}
+
+message GetProfileStatsRes {
+  optional ProfileStats stats = 1;
+}
+
+message GetProfileStatsManyRes {
+  map<string, ProfileStats> entries = 1;
+}
+
+message PostStats {
+  int32 replies = 1;
+  int32 likes = 2;
+  int32 reposts = 3;
+  int32 quotes = 4;
+}
+
+message GetPostStatsRes {
+  optional PostStats stats = 1;
+}
+
+message GetPostStatsManyRes {
+  map<string, PostStats> entries = 1;
+}
+
+message LikeCount {
+  int32 likes = 1;
+}
+
+message GetLikeCountRes {
+  optional LikeCount likes = 1;
+}
+
+message GetLikeCountManyRes {
+  map<string, LikeCount> entries = 1;
+}

parakeet-index/run.sh

···
+cargo run --features server

parakeet-index/src/lib.rs

···
+#[allow(clippy::all)]
+pub mod index {
+    tonic::include_proto!("parakeet");
+}
+
+pub use index::*;
+pub type Client = index_client::IndexClient<tonic::transport::Channel>;
+
+#[cfg(feature = "server")]
+pub mod server;

parakeet-index/src/main.rs

···
+use parakeet_index::index_server::IndexServer;
+use parakeet_index::server::service::Service;
+use parakeet_index::server::{GlobalState, config};
+use std::sync::Arc;
+use tonic::transport::Server;
+
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    tracing_subscriber::fmt::init();
+
+    let conf = config::load_config()?;
+
+    let db_root = conf.index_db_path.parse()?;
+    let addr = std::net::SocketAddr::new(conf.server.bind_address.parse()?, conf.server.port);
+    let state = Arc::new(GlobalState::new(db_root)?);
+
+    let service = Service::new(state.clone());
+    Server::builder()
+        .add_service(IndexServer::new(service))
+        .serve(addr)
+        .await?;
+
+    Ok(())
+}

parakeet-index/src/server/config.rs

···
+use figment::Figment;
+use figment::providers::{Env, Format, Toml};
+use serde::Deserialize;
+
+pub fn load_config() -> eyre::Result<Config> {
+    let conf = Figment::new()
+        .merge(Toml::file("Config.toml"))
+        .merge(Env::prefixed("PKI_"))
+        .extract()?;
+
+    Ok(conf)
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Config {
+    pub database_url: String,
+    pub index_db_path: String,
+    #[serde(default)]
+    pub server: ConfigServer,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ConfigServer {
+    #[serde(default = "default_bind_address")]
+    pub bind_address: String,
+    #[serde(default = "default_port")]
+    pub port: u16,
+}
+
+impl Default for ConfigServer {
+    fn default() -> Self {
+        ConfigServer {
+            bind_address: default_bind_address(),
+            port: default_port(),
+        }
+    }
+}
+
+fn default_bind_address() -> String {
+    "0.0.0.0".to_string()
+}
+
+fn default_port() -> u16 {
+    6001
+}

parakeet-index/src/server/db.rs

···
+use crate::all_none;
+use crate::server::utils::{ToIntExt, TreeExt, slice_as_i32};
+use sled::{Db, MergeOperator, Tree};
+use std::path::PathBuf;
+
+pub struct DbStore {
+    pub agg_db: Db,
+    pub label_db: Db,
+
+    pub follows: Tree,
+    pub followers: Tree,
+    pub likes: Tree,
+    pub replies: Tree,
+    pub reposts: Tree,
+    pub embeds: Tree,
+    pub profile_posts: Tree,
+    pub profile_lists: Tree,
+    pub profile_feeds: Tree,
+    pub profile_starterpacks: Tree,
+}
+
+impl DbStore {
+    pub fn new(db_root: PathBuf) -> eyre::Result<Self> {
+        let agg_db = sled::open(db_root.join("aggdb"))?;
+        let label_db = sled::open(db_root.join("labeldb"))?;
+
+        Ok(DbStore {
+            follows: open_tree(&agg_db, "follows", merge_delta)?,
+            followers: open_tree(&agg_db, "followers", merge_delta)?,
+            likes: open_tree(&agg_db, "likes", merge_delta)?,
+            replies: open_tree(&agg_db, "replies", merge_delta)?,
+            reposts: open_tree(&agg_db, "reposts", merge_delta)?,
+            embeds: open_tree(&agg_db, "embeds", merge_delta)?,
+            profile_posts: open_tree(&agg_db, "profile_posts", merge_delta)?,
+            profile_lists: open_tree(&agg_db, "profile_lists", merge_delta)?,
+            profile_feeds: open_tree(&agg_db, "profile_feeds", merge_delta)?,
+            profile_starterpacks: open_tree(&agg_db, "profile_starterpacks", merge_delta)?,
+
+            agg_db,
+            label_db,
+        })
+    }
+
+    pub fn get_post_stats(&self, post: &str) -> Option<crate::PostStats> {
+        let replies = self.replies.get_i32(post);
+        let likes = self.likes.get_i32(post);
+        let reposts = self.reposts.get_i32(post);
+        let quotes = self.embeds.get_i32(post);
+
+        if all_none![replies, likes, reposts, quotes] {
+            return None;
+        }
+
+        Some(crate::PostStats {
+            replies: replies.unwrap_or_default(),
+            likes: likes.unwrap_or_default(),
+            reposts: reposts.unwrap_or_default(),
+            quotes: quotes.unwrap_or_default(),
+        })
+    }
+
+    pub fn get_profile_stats(&self, did: &str) -> Option<crate::ProfileStats> {
+        let followers = self.followers.get_i32(did);
+        let following = self.follows.get_i32(did);
+        let posts = self.profile_posts.get_i32(did);
+        let lists = self.profile_lists.get_i32(did);
+        let feeds = self.profile_feeds.get_i32(did);
+        let starterpacks = self.profile_starterpacks.get_i32(did);
+
+        if all_none![followers, following, posts, lists, feeds, starterpacks] {
+            return None;
+        }
+
+        Some(crate::ProfileStats {
+            followers: followers.unwrap_or_default(),
+            following: following.unwrap_or_default(),
+            posts: posts.unwrap_or_default(),
+            lists: lists.unwrap_or_default(),
+            feeds: feeds.unwrap_or_default(),
+            starterpacks: starterpacks.unwrap_or_default(),
+        })
+    }
+}
+
+fn open_tree(db: &Db, name: &str, merge: impl MergeOperator + 'static) -> eyre::Result<Tree> {
+    let tree = db.open_tree(name)?;
+
+    tree.set_merge_operator(merge);
+
+    Ok(tree)
+}
+
+fn merge_delta(_key: &[u8], old: Option<&[u8]>, new: &[u8]) -> Option<Vec<u8>> {
+    let old = old.and_then(slice_as_i32);
+    let new = slice_as_i32(new)?;
+
+    let res = match old {
+        Some(old) => old + new,
+        None => new,
+    };
+
+    Some(Vec::from_i32(res))
+}

parakeet-index/src/server/mod.rs

···
+use std::path::PathBuf;
+
+pub mod config;
+pub mod db;
+pub mod service;
+mod utils;
+
+pub struct GlobalState {
+    pub dbs: db::DbStore,
+}
+
+impl GlobalState {
+    pub fn new(db_root: PathBuf) -> eyre::Result<Self> {
+        let dbs = db::DbStore::new(db_root)?;
+
+        Ok(GlobalState { dbs })
+    }
+}

parakeet-index/src/server/service.rs

···
+use crate::index::*;
+use crate::server::GlobalState;
+use crate::server::utils::TreeExt;
+use std::collections::HashMap;
+use std::ops::Deref;
+use std::sync::Arc;
+use tonic::codegen::tokio_stream::StreamExt;
+use tonic::{Request, Response, Status, Streaming, async_trait};
+
+pub struct Service(Arc<GlobalState>);
+
+impl Service {
+    pub fn new(state: Arc<GlobalState>) -> Self {
+        Service(state)
+    }
+
+    fn apply_delta(
+        &self,
+        uri: &str,
+        typ: AggregateType,
+        delta: i32,
+    ) -> sled::Result<Option<sled::IVec>> {
+        let val = delta.to_le_bytes();
+
+        match typ {
+            AggregateType::Unknown => todo!(),
+            AggregateType::Follow => self.dbs.follows.merge(uri, val),
+            AggregateType::Follower => self.dbs.followers.merge(uri, val),
+            AggregateType::Like => self.dbs.likes.merge(uri, val),
+            AggregateType::Reply => self.dbs.replies.merge(uri, val),
+            AggregateType::Repost => self.dbs.reposts.merge(uri, val),
+            AggregateType::Embed => self.dbs.embeds.merge(uri, val),
+            AggregateType::ProfilePost => self.dbs.profile_posts.merge(uri, val),
+            AggregateType::ProfileList => self.dbs.profile_lists.merge(uri, val),
+            AggregateType::ProfileFeed => self.dbs.profile_feeds.merge(uri, val),
+            AggregateType::ProfileStarterpack => self.dbs.profile_starterpacks.merge(uri, val),
+        }
+    }
+}
+
+impl Deref for Service {
+    type Target = Arc<GlobalState>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[async_trait]
+impl index_server::Index for Service {
+    async fn submit_aggregate_delta(
+        &self,
+        request: Request<AggregateDeltaReq>,
+    ) -> Result<Response<AggregateDeltaRes>, Status> {
+        let inner = request.into_inner();
+
+        let res = self.apply_delta(&inner.uri, inner.typ(), inner.delta);
+
+        if let Err(e) = res {
+            tracing::error!("failed to update stats DB: {e}");
+            return Err(Status::unknown("failed to update stats DB"));
+        }
+
+        Ok(Response::new(AggregateDeltaRes {}))
+    }
+
+    async fn submit_aggregate_delta_batch(
+        &self,
+        request: Request<AggregateDeltaBatchReq>,
+    ) -> Result<Response<AggregateDeltaRes>, Status> {
+        let inner = request.into_inner();
+
+        for data in inner.deltas {
+            let res = self.apply_delta(&data.uri, data.typ(), data.delta);
+
+            if let Err(e) = res {
+                tracing::error!("failed to update stats DB: {e}");
+                return Err(Status::unknown("failed to update stats DB"));
+            }
+        }
+
+        Ok(Response::new(AggregateDeltaRes {}))
+    }
+
+    async fn submit_aggregate_delta_stream(
+        &self,
+        request: Request<Streaming<AggregateDeltaReq>>,
+    ) -> Result<Response<AggregateDeltaRes>, Status> {
+        let mut inner = request.into_inner();
+
+        while let Some(req) = inner.next().await {
+            if let Ok(data) = req {
+                let res = self.apply_delta(&data.uri, data.typ(), data.delta);
+
+                if let Err(e) = res {
+                    tracing::error!("failed to update stats DB: {e}");
+                    return Err(Status::unknown("failed to update stats DB"));
+                }
+            } else {
+                tracing::error!("failed to read stream item")
+            }
+        }
+
+        Ok(Response::new(AggregateDeltaRes {}))
+    }
+
+    async fn get_profile_stats(
+        &self,
+        request: Request<GetStatsReq>,
+    ) -> Result<Response<GetProfileStatsRes>, Status> {
+        let inner = request.into_inner();
+
+        let stats = self.dbs.get_profile_stats(&inner.uri);
+
+        Ok(Response::new(GetProfileStatsRes { stats }))
+    }
+
+    async fn get_profile_stats_many(
+        &self,
+        request: Request<GetStatsManyReq>,
+    ) -> Result<Response<GetProfileStatsManyRes>, Status> {
+        let inner = request.into_inner();
+
+        // idk if this is the best way of doing this????
+        let entries = inner
+            .uris
+            .into_iter()
+            .filter_map(|uri| {
+                let stats = self.dbs.get_profile_stats(&uri)?;
+
+                Some((uri, stats))
+            })
+            .collect::<HashMap<_, _>>();
+
+        Ok(Response::new(GetProfileStatsManyRes { entries }))
+    }
+
+    async fn get_post_stats(
+        &self,
+        request: Request<GetStatsReq>,
+    ) -> Result<Response<GetPostStatsRes>, Status> {
+        let inner = request.into_inner();
+
+        let stats = self.dbs.get_post_stats(&inner.uri);
+
+        Ok(Response::new(GetPostStatsRes { stats }))
+    }
+
+    async fn get_post_stats_many(
+        &self,
+        request: Request<GetStatsManyReq>,
+    ) -> Result<Response<GetPostStatsManyRes>, Status> {
+        let inner = request.into_inner();
+
+        let entries = inner
+            .uris
+            .into_iter()
+            .filter_map(|uri| {
+                let stats = self.dbs.get_post_stats(&uri)?;
+
+                Some((uri, stats))
+            })
+            .collect::<HashMap<_, _>>();
+
+        Ok(Response::new(GetPostStatsManyRes { entries }))
+    }
+
+    async fn get_like_count(
+        &self,
+        request: Request<GetStatsReq>,
+    ) -> Result<Response<GetLikeCountRes>, Status> {
+        let inner = request.into_inner();
+
+        let likes = self
+            .dbs
+            .likes
+            .get_i32(inner.uri)
+            .map(|likes| LikeCount { likes });
+
+        Ok(Response::new(GetLikeCountRes { likes }))
+    }
+
+    async fn get_like_count_many(
+        &self,
+        request: Request<GetStatsManyReq>,
+    ) -> Result<Response<GetLikeCountManyRes>, Status> {
+        let inner = request.into_inner();
+
+        let entries = inner
+            .uris
+            .into_iter()
+            .filter_map(|uri| {
+                let likes = self.dbs.likes.get_i32(&uri)?;
+
+                Some((uri, LikeCount { likes }))
+            })
+            .collect();
+
+        Ok(Response::new(GetLikeCountManyRes { entries }))
+    }
+}

parakeet-index/src/server/utils.rs

···
+use sled::{IVec, Tree};
+
+pub trait ToIntExt {
+    fn as_i32(&self) -> Option<i32>;
+    fn from_i32(i: i32) -> Self;
+}
+
+impl ToIntExt for IVec {
+    fn as_i32(&self) -> Option<i32> {
+        if self.len() == 4 {
+            let bytes = self[0..4].try_into().ok()?;
+            Some(i32::from_le_bytes(bytes))
+        } else {
+            None
+        }
+    }
+
+    fn from_i32(i: i32) -> Self {
+        IVec::from(&i.to_le_bytes())
+    }
+}
+
+impl ToIntExt for Vec<u8> {
+    fn as_i32(&self) -> Option<i32> {
+        if self.len() == 4 {
+            let bytes = self[0..4].try_into().ok()?;
+            Some(i32::from_le_bytes(bytes))
+        } else {
+            None
+        }
+    }
+
+    fn from_i32(i: i32) -> Self {
+        Vec::from(&i.to_le_bytes())
+    }
+}
+
+pub fn slice_as_i32(data: &[u8]) -> Option<i32> {
+    let bytes = data[0..4].try_into().ok()?;
+
+    Some(i32::from_le_bytes(bytes))
+}
+
+pub trait TreeExt {
+    fn get_i32(&self, key: impl AsRef<[u8]>) -> Option<i32>;
+}
+
+impl TreeExt for Tree {
+    fn get_i32(&self, key: impl AsRef<[u8]>) -> Option<i32> {
+        self.get(key).ok().flatten().and_then(|v| v.as_i32())
+    }
+}
+
+#[macro_export]
+macro_rules! all_none {
+    ($var0:ident, $($var:ident),*) => {
+        $var0.is_none() $(&& $var.is_none())*
+    };
+}

parakeet/Cargo.toml

···
 itertools = "0.14.0"
 lexica = { path = "../lexica" }
 parakeet-db = { path = "../parakeet-db" }
+parakeet-index = { path = "../parakeet-index" }
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.134"
 tokio = { version = "1.42.0", features = ["full"] }

parakeet/run.sh

···
+cargo run

parakeet/src/config.rs

···
 
 #[derive(Debug, Deserialize)]
 pub struct Config {
+    pub index_uri: String,
     pub database_url: String,
     #[serde(default)]
     pub server: ConfigServer,

parakeet/src/hydration/feedgen.rs

···
     feedgen: models::FeedGen,
     creator: ProfileView,
     labels: Vec<models::Label>,
+    likes: Option<i32>,
 ) -> GeneratorView {
     let content_mode = feedgen
         .content_mode
···
         avatar: feedgen
             .avatar_cid
             .map(|v| format!("https://localhost/feedgen/{v}")),
-        like_count: 0,
+        like_count: likes.unwrap_or_default() as i64,
         accepts_interactions: feedgen.accepts_interactions,
         labels: map_labels(labels),
         content_mode,
···
     apply_labelers: &[LabelConfigItem],
 ) -> Option<GeneratorView> {
     let labels = loaders.label.load(&feedgen, apply_labelers).await;
-    let feedgen = loaders.feedgen.load(feedgen).await?;
+    let (feedgen, likes) = loaders.feedgen.load(feedgen).await?;
     let profile = hydrate_profile(loaders, feedgen.owner.clone(), apply_labelers).await?;
 
-    Some(build_feedgen(feedgen, profile, labels))
+    Some(build_feedgen(feedgen, profile, labels, likes))
 }
 
 pub async fn hydrate_feedgens(
···
 
     let creators = feedgens
         .values()
-        .map(|feedgen| feedgen.owner.clone())
+        .map(|(feedgen, _)| feedgen.owner.clone())
         .collect();
     let creators = hydrate_profiles(loaders, creators, apply_labelers).await;
 
     feedgens
         .into_iter()
-        .filter_map(|(uri, feedgen)| {
+        .filter_map(|(uri, (feedgen, likes))| {
             let creator = creators.get(&feedgen.owner)?;
             let labels = labels.get(&uri).cloned().unwrap_or_default();
 
-            Some((uri, build_feedgen(feedgen, creator.to_owned(), labels)))
+            Some((
+                uri,
+                build_feedgen(feedgen, creator.to_owned(), labels, likes),
+            ))
         })
         .collect()
 }

parakeet/src/hydration/labeler.rs

···
     labeler: models::LabelerService,
     creator: ProfileView,
     labels: Vec<models::Label>,
+    likes: Option<i32>,
 ) -> LabelerView {
     LabelerView {
         uri: format!("at://{}/app.bsky.labeler.service/self", labeler.did),
         cid: labeler.cid,
         creator,
-        like_count: 0,
+        like_count: likes.unwrap_or_default() as i64,
         labels: map_labels(labels),
         indexed_at: labeler.indexed_at,
     }
···
     defs: Vec<models::LabelDefinition>,
     creator: ProfileView,
     labels: Vec<models::Label>,
+    likes: Option<i32>,
 ) -> LabelerViewDetailed {
     let reason_types = labeler.reasons.map(|v| {
         v.into_iter()
···
         uri: format!("at://{}/app.bsky.labeler.service/self", labeler.did),
         cid: labeler.cid,
         creator,
-        like_count: 0,
+        like_count: likes.unwrap_or_default() as i64,
         policies: LabelerPolicy {
             label_values,
             label_value_definitions,
···
     apply_labelers: &[LabelConfigItem],
 ) -> Option<LabelerView> {
     let labels = loaders.label.load(&labeler, apply_labelers).await;
-    let (labeler, _) = loaders.labeler.load(labeler).await?;
+    let (labeler, _, likes) = loaders.labeler.load(labeler).await?;
     let creator = hydrate_profile(loaders, labeler.did.clone(), apply_labelers).await?;
 
-    Some(build_view(labeler, creator, labels))
+    Some(build_view(labeler, creator, labels, likes))
 }
 
 pub async fn hydrate_labelers(
···
 
     let creators = labelers
         .values()
-        .map(|(labeler, _)| labeler.did.clone())
+        .map(|(labeler, _, _)| labeler.did.clone())
         .collect();
     let creators = hydrate_profiles(loaders, creators, apply_labelers).await;
 
     labelers
         .into_iter()
-        .filter_map(|(k, (labeler, _))| {
+        .filter_map(|(k, (labeler, _, likes))| {
             let creator = creators.get(&labeler.did).cloned()?;
             let labels = labels.get(&k).cloned().unwrap_or_default();
 
-            Some((k, build_view(labeler, creator, labels)))
+            Some((k, build_view(labeler, creator, labels, likes)))
         })
         .collect()
 }
···
     apply_labelers: &[LabelConfigItem],
 ) -> Option<LabelerViewDetailed> {
     let labels = loaders.label.load(&labeler, apply_labelers).await;
-    let (labeler, defs) = loaders.labeler.load(labeler).await?;
+    let (labeler, defs, likes) = loaders.labeler.load(labeler).await?;
     let creator = hydrate_profile(loaders, labeler.did.clone(), apply_labelers).await?;
 
-    Some(build_view_detailed(labeler, defs, creator, labels))
+    Some(build_view_detailed(labeler, defs, creator, labels, likes))
 }
 
 pub async fn hydrate_labelers_detailed(
···
 
     let creators = labelers
         .values()
-        .map(|(labeler, _)| labeler.did.clone())
+        .map(|(labeler, _, _)| labeler.did.clone())
         .collect();
     let creators = hydrate_profiles(loaders, creators, apply_labelers).await;
 
     labelers
         .into_iter()
-        .filter_map(|(k, (labeler, defs))| {
+        .filter_map(|(k, (labeler, defs, likes))| {
             let creator = creators.get(&labeler.did).cloned()?;
             let labels = labels.get(&k).cloned().unwrap_or_default();
 
-            Some((k, build_view_detailed(labeler, defs, creator, labels)))
+            Some((
+                k,
+                build_view_detailed(labeler, defs, creator, labels, likes),
+            ))
         })
         .collect()
 }

parakeet/src/hydration/posts.rs

···
 use lexica::app_bsky::embed::{AspectRatio, Embed};
 use lexica::app_bsky::feed::{FeedViewPost, PostView, ReplyRef, ReplyRefPost, ThreadgateView};
 use lexica::app_bsky::graph::ListViewBasic;
+use lexica::app_bsky::RecordStats;
 use parakeet_db::models;
+use parakeet_index::PostStats;
 use std::collections::HashMap;
 
 fn build_postview(
···
     labels: Vec<models::Label>,
     embed: Option<Embed>,
     threadgate: Option<ThreadgateView>,
+    stats: Option<PostStats>,
 ) -> PostView {
+    let stats = stats
+        .map(|stats| RecordStats {
+            reply_count: stats.replies as i64,
+            repost_count: stats.reposts as i64,
+            like_count: stats.likes as i64,
+            quote_count: stats.quotes as i64,
+        })
+        .unwrap_or_default();
+
     PostView {
         uri: post.at_uri,
         cid: post.cid,
         author,
         record: post.record,
         embed,
-        stats: Default::default(),
+        stats,
         labels: map_labels(labels),
         threadgate,
         indexed_at: post.created_at,
···
     post: String,
     apply_labelers: &[LabelConfigItem],
 ) -> Option<PostView> {
-    let (post, threadgate) = loaders.posts.load(post).await?;
+    let (post, threadgate, stats) = loaders.posts.load(post).await?;
     let embed = hydrate_embed(loaders, post.at_uri.clone(), apply_labelers).await;
     let author = hydrate_profile_basic(loaders, post.did.clone(), apply_labelers).await?;
     let threadgate = hydrate_threadgate(loaders, threadgate, apply_labelers).await;
     let labels = loaders.label.load(&post.at_uri, apply_labelers).await;
 
-    Some(build_postview(post, author, labels, embed, threadgate))
+    Some(build_postview(
+        post, author, labels, embed, threadgate, stats,
+    ))
 }
 
 pub async fn hydrate_posts(
···
 
     let (authors, post_uris) = posts
         .values()
-        .map(|(post, _)| (post.did.clone(), post.at_uri.clone()))
+        .map(|(post, _, _)| (post.did.clone(), post.at_uri.clone()))
         .unzip::<_, _, Vec<_>, Vec<_>>();
     let authors = hydrate_profiles_basic(loaders, authors, apply_labelers).await;
 
···
 
     let threadgates = posts
         .values()
-        .filter_map(|(_, threadgate)| threadgate.clone())
+        .filter_map(|(_, threadgate, _)| threadgate.clone())
         .collect();
     let threadgates = hydrate_threadgates(loaders, threadgates, apply_labelers).await;
 
···
 
     posts
         .into_iter()
-        .filter_map(|(uri, (post, threadgate))| {
+        .filter_map(|(uri, (post, threadgate, stats))| {
             let author = authors.get(&post.did)?;
             let embed = embeds.get(&uri).cloned();
             let threadgate = threadgate.and_then(|tg| threadgates.get(&tg.at_uri).cloned());
···
 
             Some((
                 uri,
-                build_postview(post, author.to_owned(), labels, embed, threadgate),
+                build_postview(post, author.to_owned(), labels, embed, threadgate, stats),
             ))
         })
         .collect()
···
 
     let (authors, post_uris) = posts
         .values()
-        .map(|(post, _)| (post.did.clone(), post.at_uri.clone()))
+        .map(|(post, _, _)| (post.did.clone(), post.at_uri.clone()))
         .unzip::<_, _, Vec<_>, Vec<_>>();
     let authors = hydrate_profiles_basic(loaders, authors, apply_labelers).await;
 
···
 
     let reply_refs = posts
         .values()
-        .flat_map(|(post, _)| [post.parent_uri.clone(), post.root_uri.clone()])
+        .flat_map(|(post, _, _)| [post.parent_uri.clone(), post.root_uri.clone()])
         .flatten()
         .collect::<Vec<_>>();
 
···
 
     posts
         .into_iter()
-        .filter_map(|(post_uri, (post, threadgate))| {
+        .filter_map(|(post_uri, (post, threadgate, stats))| {
             let author = authors.get(&post.did)?;
 
             let root = post.root_uri.as_ref().and_then(|uri| reply_posts.get(uri));
···
 
             let embed = embeds.get(&post_uri).cloned();
             let labels = post_labels.get(&post_uri).cloned().unwrap_or_default();
-            let post = build_postview(post, author.to_owned(), labels, embed, None);
+            let post = build_postview(post, author.to_owned(), labels, embed, None, stats);
 
             Some((
                 post_uri,

parakeet/src/hydration/profile.rs

···
 use crate::loaders::Dataloaders;
 use lexica::app_bsky::actor::*;
 use parakeet_db::models;
+use parakeet_index::ProfileStats;
 use std::collections::HashMap;
 use std::sync::OnceLock;
 
 pub static TRUSTED_VERIFIERS: OnceLock<Vec<String>> = OnceLock::new();
 
-fn build_associated(chat: Option<ChatAllowIncoming>, labeler: bool) -> Option<ProfileAssociated> {
-    if chat.is_some() || labeler {
+fn build_associated(
+    chat: Option<ChatAllowIncoming>,
+    labeler: bool,
+    stats: Option<ProfileStats>,
+) -> Option<ProfileAssociated> {
+    if chat.is_some() || labeler || stats.is_some() {
+        let stats = stats.unwrap_or_default();
+
         Some(ProfileAssociated {
-            lists: 0,
-            feedgens: 0,
-            starter_packs: 0,
+            lists: stats.lists as i64,
+            feedgens: stats.feeds as i64,
+            starter_packs: stats.starterpacks as i64,
             labeler,
             chat: chat.map(|v| ProfileAssociatedChat { allow_incoming: v }),
         })
···
     is_labeler: bool,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
+    stats: Option<ProfileStats>,
 ) -> ProfileViewBasic {
-    let associated = build_associated(chat_decl, is_labeler);
+    let associated = build_associated(chat_decl, is_labeler, stats);
     let verification = build_verification(&profile, &handle, verifications);
 
     ProfileViewBasic {
···
     is_labeler: bool,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
+    stats: Option<ProfileStats>,
 ) -> ProfileView {
-    let associated = build_associated(chat_decl, is_labeler);
+    let associated = build_associated(chat_decl, is_labeler, stats);
     let verification = build_verification(&profile, &handle, verifications);
 
     ProfileView {
···
 fn build_detailed(
     handle: Option<String>,
     profile: models::Profile,
-    follow_stats: Option<models::FollowStats>,
     chat_decl: Option<ChatAllowIncoming>,
     is_labeler: bool,
     labels: Vec<models::Label>,
     verifications: Option<Vec<models::VerificationEntry>>,
+    stats: Option<ProfileStats>,
 ) -> ProfileViewDetailed {
-    let associated = build_associated(chat_decl, is_labeler);
+    let associated = build_associated(chat_decl, is_labeler, stats);
     let verification = build_verification(&profile, &handle, verifications);
 
     ProfileViewDetailed {
···
         banner: profile
             .banner_cid
             .map(|v| format!("https://localhost/banner/{v}")),
-        followers_count: follow_stats
-            .as_ref()
-            .map(|v| v.followers as i64)
-            .unwrap_or_default(),
-        follows_count: follow_stats
-            .as_ref()
-            .map(|v| v.following as i64)
-            .unwrap_or_default(),
+        followers_count: stats.map(|v| v.followers as i64).unwrap_or_default(),
+        follows_count: stats.map(|v| v.following as i64).unwrap_or_default(),
         associated,
         labels: map_labels(labels),
         verification,
···
 ) -> Option<ProfileViewBasic> {
     let labels = loaders.label.load(&did, apply_labelers).await;
     let verif = loaders.verification.load(did.clone()).await;
-    let (handle, profile, _, chat_decl, labeler) = loaders.profile.load(did).await?;
+    let (handle, profile, chat_decl, labeler, stats) = loaders.profile.load(did).await?;
 
     Some(build_basic(
-        handle, profile, chat_decl, labeler, labels, verif,
+        handle, profile, chat_decl, labeler, labels, verif, stats,
     ))
 }
 
···
 
     profiles
         .into_iter()
-        .map(|(k, (handle, profile, _, chat_decl, labeler))| {
+        .map(|(k, (handle, profile, chat_decl, labeler, stats))| {
             let labels = labels.get(&k).cloned().unwrap_or_default();
             let verif = verif.get(&k).cloned();
 
             (
                 k,
-                build_basic(handle, profile, chat_decl, labeler, labels, verif),
+                build_basic(handle, profile, chat_decl, labeler, labels, verif, stats),
             )
         })
         .collect()
···
 ) -> Option<ProfileView> {
     let labels = loaders.label.load(&did, apply_labelers).await;
     let verif = loaders.verification.load(did.clone()).await;
-    let (handle, profile, _, chat_decl, labeler) = loaders.profile.load(did).await?;
+    let (handle, profile, chat_decl, labeler, stats) = loaders.profile.load(did).await?;
 
     Some(build_profile(
-        handle, profile, chat_decl, labeler, labels, verif,
+        handle, profile, chat_decl, labeler, labels, verif, stats,
     ))
 }
 
···
 
     profiles
         .into_iter()
-        .map(|(k, (handle, profile, _, chat_decl, labeler))| {
+        .map(|(k, (handle, profile, chat_decl, labeler, stats))| {
             let labels = labels.get(&k).cloned().unwrap_or_default();
             let verif = verif.get(&k).cloned();
 
             (
                 k,
-                build_profile(handle, profile, chat_decl, labeler, labels, verif),
+                build_profile(handle, profile, chat_decl, labeler, labels, verif, stats),
             )
         })
         .collect()
···
 ) -> Option<ProfileViewDetailed> {
     let labels = loaders.label.load(&did, apply_labelers).await;
     let verif = loaders.verification.load(did.clone()).await;
-    let (handle, profile, follow_stats, chat_decl, labeler) = loaders.profile.load(did).await?;
+    let (handle, profile, chat_decl, labeler, stats) = loaders.profile.load(did).await?;
 
     Some(build_detailed(
-        handle,
-        profile,
-        follow_stats,
-        chat_decl,
-        labeler,
-        labels,
-        verif,
+        handle, profile, chat_decl, labeler, labels, verif, stats,
     ))
 }
 
···
 
     profiles
         .into_iter()
-        .map(|(k, (handle, profile, follow_stats, chat_decl, labeler))| {
+        .map(|(k, (handle, profile, chat_decl, labeler, stats))| {
             let labels = labels.get(&k).cloned().unwrap_or_default();
             let verif = verif.get(&k).cloned();
 
             (
                 k,
-                build_detailed(
-                    handle,
-                    profile,
-                    follow_stats,
-                    chat_decl,
-                    labeler,
-                    labels,
-                    verif,
-                ),
+                build_detailed(handle, profile, chat_decl, labeler, labels, verif, stats),
             )
         })
         .collect()

parakeet/src/loaders.rs

···
 impl Dataloaders {
     // for the moment, we set up memory cached loaders
     // we should build a redis/valkey backend at some point in the future.
-    pub fn new(pool: Pool<AsyncPgConnection>) -> Dataloaders {
+    pub fn new(pool: Pool<AsyncPgConnection>, idxc: parakeet_index::Client) -> Dataloaders {
         Dataloaders {
             embed: Loader::new(EmbedLoader(pool.clone())),
-            feedgen: Loader::new(FeedGenLoader(pool.clone())),
+            feedgen: Loader::new(FeedGenLoader(pool.clone(), idxc.clone())),
             handle: Loader::new(HandleLoader(pool.clone())),
             label: LabelLoader(pool.clone()), // CARE: never cache this.
-            labeler: Loader::new(LabelServiceLoader(pool.clone())),
+            labeler: Loader::new(LabelServiceLoader(pool.clone(), idxc.clone())),
             list: Loader::new(ListLoader(pool.clone())),
-            posts: Loader::new(PostLoader(pool.clone())),
-            profile: Loader::new(ProfileLoader(pool.clone())),
+            posts: Loader::new(PostLoader(pool.clone(), idxc.clone())),
+            profile: Loader::new(ProfileLoader(pool.clone(), idxc.clone())),
             starterpacks: Loader::new(StarterPackLoader(pool.clone())),
             verification: Loader::new(VerificationLoader(pool.clone())),
         }
···
     }
 }
 
-pub struct ProfileLoader(Pool<AsyncPgConnection>);
+pub struct ProfileLoader(Pool<AsyncPgConnection>, parakeet_index::Client);
 type ProfileLoaderRet = (
     Option<String>,
     models::Profile,
-    Option<models::FollowStats>,
     Option<ChatAllowIncoming>,
     bool,
+    Option<parakeet_index::ProfileStats>,
 );
 impl BatchFn<String, ProfileLoaderRet> for ProfileLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, ProfileLoaderRet> {
···
                 schema::actors::did,
                 schema::actors::handle,
                 models::Profile::as_select(),
-                Option::<models::FollowStats>::as_select(),
                 schema::chat_decls::allow_incoming.nullable(),
                 schema::labelers::cid.nullable(),
             ))
···
                 String,
                 Option<String>,
                 models::Profile,
-                Option<models::FollowStats>,
                 Option<String>,
                 Option<String>,
             )>(&mut conn)
             .await;
 
+        let stats_req = parakeet_index::GetStatsManyReq {
+            uris: keys.to_vec(),
+        };
+        let mut stats = self
+            .1
+            .get_profile_stats_many(stats_req)
+            .await
+            .unwrap()
+            .into_inner()
+            .entries;
+
         match res {
             Ok(res) => HashMap::from_iter(res.into_iter().map(
-                |(did, handle, profile, follow_stats, chat_decl, labeler_cid)| {
+                |(did, handle, profile, chat_decl, labeler_cid)| {
                     let chat_decl = chat_decl.and_then(|v| ChatAllowIncoming::from_str(&v).ok());
                     let is_labeler = labeler_cid.is_some();
+                    let maybe_stats = stats.remove(&did);
 
-                    let val = (handle, profile, follow_stats, chat_decl, is_labeler);
+                    let val = (handle, profile, chat_decl, is_labeler, maybe_stats);
 
                     (did, val)
                 },
···
     }
 }
 
-pub struct FeedGenLoader(Pool<AsyncPgConnection>);
-type FeedGenLoaderRet = models::FeedGen; //todo: when we have likes, we'll need the count here
+pub struct FeedGenLoader(Pool<AsyncPgConnection>, parakeet_index::Client);
+type FeedGenLoaderRet = (models::FeedGen, Option<i32>);
 impl BatchFn<String, FeedGenLoaderRet> for FeedGenLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, FeedGenLoaderRet> {
         let mut conn = self.0.get().await.unwrap();
···
             .load(&mut conn)
             .await;
 
+        let stats_req = parakeet_index::GetStatsManyReq {
+            uris: keys.to_vec(),
+        };
+        let mut stats = self
+            .1
+            .get_like_count_many(stats_req)
+            .await
+            .unwrap()
+            .into_inner()
+            .entries;
+
         match res {
-            Ok(res) => HashMap::from_iter(
-                res.into_iter()
-                    .map(|feedgen| (feedgen.at_uri.clone(), feedgen)),
-            ),
+            Ok(res) => HashMap::from_iter(res.into_iter().map(|feedgen| {
+                let likes = stats.remove(&feedgen.at_uri).map(|v| v.likes);
+
+                (feedgen.at_uri.clone(), (feedgen, likes))
+            })),
             Err(e) => {
                 tracing::error!("feedgen load failed: {e}");
                 HashMap::new()
···
     }
 }
 
-pub struct PostLoader(Pool<AsyncPgConnection>);
-type PostLoaderRet = (models::Post, Option<models::Threadgate>);
+pub struct PostLoader(Pool<AsyncPgConnection>, parakeet_index::Client);
+type PostLoaderRet = (
+    models::Post,
+    Option<models::Threadgate>,
+    Option<parakeet_index::PostStats>,
+);
 impl BatchFn<String, PostLoaderRet> for PostLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, PostLoaderRet> {
         let mut conn = self.0.get().await.unwrap();
···
             .load(&mut conn)
             .await;
 
+        let stats_req = parakeet_index::GetStatsManyReq {
+            uris: keys.to_vec(),
+        };
+        let mut stats = self
+            .1
+            .get_post_stats_many(stats_req)
+            .await
+            .unwrap()
+            .into_inner()
+            .entries;
+
         match res {
-            Ok(res) => HashMap::from_iter(
-                res.into_iter()
-                    .map(|(post, threadgate)| (post.at_uri.clone(), (post, threadgate))),
-            ),
+            Ok(res) => HashMap::from_iter(res.into_iter().map(|(post, threadgate)| {
+                let maybe_stats = stats.remove(&post.at_uri);
+
+                (post.at_uri.clone(), (post, threadgate, maybe_stats))
+            })),
             Err(e) => {
                 tracing::error!("post load failed: {e}");
                 HashMap::new()
···
     }
 }
 
-pub struct LabelServiceLoader(Pool<AsyncPgConnection>);
-type LabelServiceLoaderRet = (models::LabelerService, Vec<models::LabelDefinition>);
+pub struct LabelServiceLoader(Pool<AsyncPgConnection>, parakeet_index::Client);
+type LabelServiceLoaderRet = (
+    models::LabelerService,
+    Vec<models::LabelDefinition>,
+    Option<i32>,
+);
 impl BatchFn<String, LabelServiceLoaderRet> for LabelServiceLoader {
     async fn load(&mut self, keys: &[String]) -> HashMap<String, LabelServiceLoaderRet> {
         let mut conn = self.0.get().await.unwrap();
···
 
         let defs = defs.grouped_by(&labelers);
 
+        let uris = keys
+            .iter()
+            .map(|v| format!("at://{v}/app.bsky.labeler.service/self"))
+            .collect();
+        let stats_req = parakeet_index::GetStatsManyReq { uris };
+        let mut stats = self
+            .1
+            .get_like_count_many(stats_req)
+            .await
+            .unwrap()
+            .into_inner()
+            .entries;
+
         labelers
             .into_iter()
             .zip(defs)
-            .map(|(labeler, defs)| (labeler.did.clone(), (labeler, defs)))
+            .map(|(labeler, defs)| {
+                let likes = stats
+                    .remove(&format!(
+                        "at://{}/app.bsky.labeler.service/self",
+                        &labeler.did
+                    ))
+                    .map(|v| v.likes);
+
+                (labeler.did.clone(), (labeler, defs, likes))
+            })
             .collect()
     }
 }

parakeet/src/main.rs

···
 pub struct GlobalState {
     pub pool: Pool<AsyncPgConnection>,
     pub dataloaders: Arc<loaders::Dataloaders>,
+    pub index_client: parakeet_index::Client,
 }
 
 #[tokio::main]
···
     let db_mgr = AsyncDieselConnectionManager::<AsyncPgConnection>::new(&conf.database_url);
     let pool = Pool::builder(db_mgr).build()?;
 
-    let dataloaders = Arc::new(loaders::Dataloaders::new(pool.clone()));
+    let index_client = parakeet_index::Client::connect(conf.index_uri).await?;
+
+    let dataloaders = Arc::new(loaders::Dataloaders::new(
+        pool.clone(),
+        index_client.clone(),
+    ));
 
     #[allow(unused)]
     hydration::TRUSTED_VERIFIERS.set(conf.trusted_verifiers);
···
         )
         .layer(TraceLayer::new_for_http())
         .layer(cors)
-        .with_state(GlobalState { pool, dataloaders });
+        .with_state(GlobalState {
+            pool,
+            dataloaders,
+            index_client,
+        });
 
     let addr = std::net::SocketAddr::new(conf.server.bind_address.parse()?, conf.server.port);
     let listener = tokio::net::TcpListener::bind(addr).await?;