llms.txt
Compare with other sites' llms.txt files →# ObsessionDB
> Fully managed hosting for ClickHouse® software: the official ClickHouse engine on a rebuilt storage layer with compute–storage separation. Drop-in replacement, zero operational overhead, obsessive performance per dollar.
Runs fully managed on AWS, Google Cloud and Azure in every public region, or as BYOC (bring your own cloud) inside your own AWS or Google Cloud account or on your own hardware, air-gapped if needed. See [Deployment options](https://obsessiondb.com/docs/deployment-options.md) and the [BYOC launch post](https://obsessiondb.com/blog/byoc-clickhouse-in-your-cloud-account).
The docs below link to plain-markdown versions of each page (the same content
as the HTML docs, without navigation chrome).
## Docs
- [Overview](https://obsessiondb.com/docs.md): ObsessionDB runs the official ClickHouse engine on a rebuilt storage layer with compute–storage separation. If you know ClickHouse, you know ObsessionDB.
- [What is ObsessionDB?](https://obsessiondb.com/docs/what-you-get.md): Understand all the elements the managed platform handles for you: storage, durability, scaling, backups, and caching. Focus on building, not infrastructure, while using the same ClickHouse as always.
- [Why is it a game changer?](https://obsessiondb.com/docs/performance-model.md): Dive into the technical details behind ObsessionDB's performance: our cached storage layer, I/O optimizations, and bandwidth-efficient architecture. The speed of local storage, at scale.
- [Getting started](https://obsessiondb.com/docs/getting-started.md): Feel free to just use it without going deeper. From signup to your first query in about five minutes: create a cluster, connect any ClickHouse client, load data, and query.
- [Deployment options: managed or BYOC](https://obsessiondb.com/docs/deployment-options.md): Run ObsessionDB fully managed on AWS, Google Cloud or Azure, or as BYOC inside your own AWS or Google Cloud account: what stays in your account, access, billing and the PoC.
- [Clients & drivers](https://obsessiondb.com/docs/drivers-and-clients.md): ObsessionDB speaks the native ClickHouse protocol and HTTP interface, so every ClickHouse client and driver connects unchanged. The list and the one habit to keep.
- [The MCP server](https://obsessiondb.com/docs/mcp-server): Connect coding agents (Claude Code, Cursor, Codex, VS Code, Zed) to your databases over MCP: OAuth 2.1, no API keys, tools to list services, run SQL, and read monitoring.
- [BI & SQL tools](https://obsessiondb.com/docs/bi-and-sql-tools.md): Any BI, dashboard, or SQL tool that connects to ClickHouse connects to ObsessionDB: Grafana, Metabase, Superset, Tableau, DBeaver, and the rest.
- [Shared Table Engine - Alloy](https://obsessiondb.com/docs/shared-merge-tree.md): ObsessionDB's SharedMergeTree engine: built against the open-source SharedMergeTree API, it takes plain MergeTree DDL on the surface, with metadata in the coordination layer and data on object storage underneath.
- [Availability & the tier ladder](https://obsessiondb.com/docs/availability-and-tiers.md): Where your data physically lives in ObsessionDB: the two independent axes (data vs. metadata) and the six-tier cache ladder from S3 down to the page cache.
- [The distributed cache](https://obsessiondb.com/docs/distributed-cache.md): How Bunsen, the distributed NVMe cache ring, turns the object-storage latency floor into local-disk speed, and how to size it.
- [Locality: merges](https://obsessiondb.com/docs/locality-merges.md): How Affinity routes background merges to the node that already holds the input parts warm, keeping merge work local instead of crossing the network.
- [Locality: reads & parallel replicas](https://obsessiondb.com/docs/locality-reads.md): How Affinity routes parallel-replica reads to the nodes that own the relevant parts in cache, and the settings that control read locality.
- [Datashares](https://obsessiondb.com/docs/datashares.md): Share your data with other clusters, whether they’re owned by internal teams or external customers, without exposing any cluster credentials or sharing its compute. Compute–compute–storage separation keeps resources isolated while providing read-only access with real-time revocable permissions.
- [Ingesting data](https://obsessiondb.com/docs/ingesting-data.md): Ordinary ClickHouse ingestion, with one principle that dominates: batch your writes and keep inserts few and large, because every write is durable to object storage.
- [Jobs](https://obsessiondb.com/docs/jobs.md): Run large SQL operations as batches of retryable tasks against your service, with live progress and controls to pause, retry, or cancel while the job runs.
- [Monitoring overview](https://obsessiondb.com/docs/monitoring.md): The built-in monitoring dashboard on every service: what it shows, how the data is collected into a durable one-week archive, the time ranges and refresh cadence, and when it is available.
- [Query performance & errors](https://obsessiondb.com/docs/monitoring-queries.md): The Queries tab end to end: query patterns versus executions, the headline KPIs, the searchable stats table, drilling down to a single execution with its time breakdown, and grouped error signatures.
- [Storage & resources](https://obsessiondb.com/docs/monitoring-storage-resources.md): The Storage and Resources tabs: table sizes and partition shape on object storage, plus per-node CPU and memory over time with selectable aggregations and the memory-limit reference.
- [Querying system tables](https://obsessiondb.com/docs/monitoring-system-tables.md): The full ClickHouse observability surface, unchanged from stock ClickHouse, plus how to query it across the whole cluster at once and the signals that matter most when compute and storage are separated.
- [Alerting](https://obsessiondb.com/docs/alerting.md): Turn any SQL query against your cluster into a monitored rule: set an operator, threshold, interval, and severity, start from a template, and follow each incident from firing to resolved.
- [Notification channels](https://obsessiondb.com/docs/notification-channels.md): Route firing alerts to the channels your team already watches. Organization-scoped, reusable Slack and HTTP webhook destinations you set up once and attach to any rule.
- [Scaling & resizing](https://obsessiondb.com/docs/scaling.md): Stateless compute means changing cluster shape moves no data: add or remove nodes and resize compute with no re-sharding and no rebalancing.
- [Backup & recovery](https://obsessiondb.com/docs/backup-and-recovery.md): Durable state lives off the compute nodes, so losing a node loses cache, not data. Automated daily backups, the recovery model, and why there is no manual BACKUP/RESTORE.
- [Migrating from ClickHouse](https://obsessiondb.com/docs/migrate-from-clickhouse.md): Moving a self-managed ClickHouse deployment is mostly a data copy: same SQL, same clients. Move the schema, move the data, repoint clients, adapt the narrow set of differences.
- [Migrating from ClickHouse Cloud](https://obsessiondb.com/docs/migrate-from-clickhouse-cloud.md): The shortest migration there is: both run the official ClickHouse engine on shared storage. Recreate the schema, bridge the data through object storage, repoint, and cut the cost.
- [What changes when you move](https://obsessiondb.com/docs/migration-changes.md): The focused checklist of behaviors compute–storage separation changes: centrally-coordinated operations, the storage-snapshot commands to replace, settings, and ingestion.
- [Feature status](https://obsessiondb.com/docs/feature-status.md): An honest map of what is identical to ClickHouse, what behaves differently, what is not implemented, and what will never be implemented by design.
- [Pricing & billing](https://obsessiondb.com/docs/pricing-and-billing.md): How ObsessionDB prices compute in compute units, what is included (24h time travel, free ingress/egress), and the performance-per-dollar case against ClickHouse Cloud.
## Whitepapers
- [ClickHouse® in Production: The Engineering Playbook](https://obsessiondb.com/whitepaper/clickhouse-in-production): A field guide to running ClickHouse in production, storage architecture, engine selection, materialized views, state management, read-path optimization, and the infrastructure choices underneath it all.
## Blog
- [BYOC: run ClickHouse® on your own S3](https://obsessiondb.com/blog/byoc-clickhouse-in-your-cloud-account): ObsessionDB now runs anywhere: in your own AWS or Google Cloud account, or on your own hardware, air-gapped if you need it. Your data stays with you, and we run upgrades, scaling and on-call.
- [How we halved the cost of running Osmosis's real-time data API](https://obsessiondb.com/blog/migrate-from-tinybird-to-obsessiondb-osmosis): Osmosis's real-time data API cost about $60k a year to run on Tinybird. We migrated it off Tinybird one endpoint group at a time and it now costs about $30k.
- [AI agents don't query like humans](https://obsessiondb.com/blog/ai-agents-dont-query-like-humans): AI agents query ClickHouse with many small, parallel lookups. Our test on 200 billion rows shows why concurrency, cache and isolation decide speed and cost.
- [10 questions your agent transcripts can answer in SQL](https://obsessiondb.com/blog/agent-transcripts-sql): One small model behind four SQL functions turns agent transcripts into typed columns, so ten real questions become ten short queries with no labels, classifier or pipeline.
- [Agentic analytics, part 2: your agents' data is a product. Your customers are waiting for it.](https://obsessiondb.com/blog/agentic-analytics-products): Agent transcripts, tool calls, costs and outcomes can be served straight back to your customers as reports, APIs, live bills and audit logs. Five products hiding in your agent data.
- [Agentic analytics, part 1: your agents are keeping a diary. Read it.](https://obsessiondb.com/blog/agentic-analytics): Every agent run leaves behind transcripts, traces, tool calls, costs and scores. Agentic analytics is what you learn when you keep all of it and join it. Five use cases to start with.
- [Agents are coming. Is your data warehouse bill ready?](https://obsessiondb.com/blog/agents-are-coming-data-warehouse-bill): Most data platforms were priced around a human analyst. Agents write more data and ask it far more questions, and teams already rationing their data will pay for it.
- [Our ClickHouse® setup to reduce cost](https://obsessiondb.com/blog/clickhouse-cost-optimization): How ObsessionDB reduces ClickHouse cost: one copy of the data, compute sized to the job, 4x less merge bandwidth, and compression levers any cluster can use.
- [Our ClickHouse® setup to scale](https://obsessiondb.com/blog/clickhouse-scaling-setup): How ObsessionDB scales ClickHouse on ingest and serve: one copy on object storage, stateless compute, locality-aware merges, and settings any cluster can tune.
- [Our ClickHouse® setup to reduce latency](https://obsessiondb.com/blog/clickhouse-latency-settings): How ObsessionDB reduces ClickHouse query latency: a distributed NVMe cache over S3, resident projection indexes, and the settings any cluster can tune.
- [How We Achieved Sub-second Queries on 56 Terabytes](https://obsessiondb.com/blog/subsecond-p99-56-terabytes): 203 billion rows, 56 TB, and an address lookup whose result size nobody can predict. A thousand random addresses, p99 703 ms, and not one query over a second.
- [What Changes When Your Database's Main User Is an Agent](https://obsessiondb.com/blog/database-main-user-is-an-agent): Agents need a fast, small stack, controlled cost, gated access, and a record of what they did. Here is how ObsessionDB answers each factor, and why we bet on it.
- [ClickHouse® Index vs Projection vs Materialized View](https://obsessiondb.com/blog/clickhouse-index-vs-projection-vs-materialized-view): Index, projection, or materialized view in ClickHouse? Pick by what each costs you. The decision table, plus the 285 ms and 828 GB case from a 13 TiB table.
- [How We Made ClickHouse® Projections 10x Faster at 20 Terabytes](https://obsessiondb.com/blog/clickhouse-projections-at-scale): Projections on SharedMergeTree do not scale well: past a few terabytes, selection overhead starts eating the query. We run one on a 20+ TB table with over 200 billion rows and got it more than 10x faster. This is the engineering underneath.
- [Time Travel for ObsessionDB: rewind your mistakes](https://obsessiondb.com/blog/time-travel-clickhouse-recovery): A GDPR erasure request, a predicate that matched more than it should have, and 200 rows gone across three tables. Getting them back took an afternoon. That afternoon is why we built Time Travel.
- [Sailing on the great ClickHouse® integration ecosystem](https://obsessiondb.com/blog/clickhouse-integration-ecosystem): ObsessionDB speaks standard ClickHouse, so the whole integration ecosystem works unchanged. Here is what we support with extra care, and what we are building ourselves.
- [SharedMergeTree vs ReplicatedMergeTree: the business case](https://obsessiondb.com/blog/sharedmergetree-vs-replicatedmergetree): ReplicatedMergeTree makes you pay for your data twice and reshard by hand. Here's how SharedMergeTree changes the math, and when it's the right call.
- [Announcing Datashares for ClickHouse®: Query another team’s data without copying it](https://obsessiondb.com/blog/datashares-clickhouse-query-team-data): Sharing data between teams has always meant making a copy that drifts the moment the original changes. Because ObsessionDB is shared-storage, another customer’s compute can read the very same objects with no copy, no replica, no sync. Read-only, compute strictly separated, revocable at any time.
- [Automatic data-ops for ClickHouse® database](https://obsessiondb.com/blog/clickhouse-reingestion): Reingesting a large ClickHouse table by hand means owning chunk boundaries, dedup, resume, and retries. Here is how chkit runs those as automatic, idempotent, resumable jobs, locally or submitted to the ObsessionDB platform.
- [What changes once your ClickHouse® schema is code](https://obsessiondb.com/blog/clickhouse-schema-as-code): On ClickHouse you still hand-write DDL and find drift in production. Here is what changes once your schema is code: generated migrations, a drift gate in CI, and ALTERs that cannot quietly rewrite a table.
- [One powerful tool, not forty: ClickHouse® monitoring built for AI agents](https://obsessiondb.com/blog/clickhouse-monitoring-agentic): We built ClickHouse monitoring for the agent that investigates it: one SQL tool plus context, not 40 MCP endpoints. With two real ClickBench investigations.
- [ClickHouse® in Production: The Engineering Playbook](https://obsessiondb.com/whitepaper/clickhouse-in-production): A complete engineering reference for running ClickHouse at scale, schema design, MergeTree internals, materialized views, projections, query optimization, and cost control. Everything we learned operating petabyte-scale workloads.
- [What decoupled storage changes when you build on ClickHouse®](https://obsessiondb.com/blog/building-on-decoupled-clickhouse): Storage and compute are splitting apart in ClickHouse. Here is what actually changes in how you model, migrate, and scale, what stays exactly the same, and where compute-compute separation lets the API serving layer get its own pool.
- [How Numia Cut Costs 75% by Moving 200TB Off BigQuery](https://obsessiondb.com/blog/how-numia-cut-costs-75-percent-bigquery): Numia was scanning 1,600TB a month in BigQuery, about $8,000 per month, purely to reshape data for Postgres. Moving to ObsessionDB collapsed three systems into one, cut the bill by 75%, and made the data fresh within seconds.
- [The lookup kit: dictionaries and JOINs in ClickHouse® DB](https://obsessiondb.com/blog/clickhouse-dictionaries-joins): In ClickHouse, the JOIN reflex is wrong about 80% of the time. dictGet runs 20× faster than the equivalent JOIN on a 10-billion-row enrichment. When dictionaries win, when JOINs still beat them, and how to skip the lookup entirely by enriching at ingest.
- [How We Query 18 Terabytes in Under a Second](https://obsessiondb.com/blog/subsecond-queries-on-terabytes): We have 18 terabytes of Solana blockchain transfer data. 77 billion rows. A user types a wallet address and expects a complete profile before they can reach for their coffee. There is no single trick that gets you there.
- [ClickHouse® Query Optimization: What Makes It Fast and What Kills It](https://obsessiondb.com/blog/clickhouse-query-optimization-what-makes-it-fast): The complete ClickHouse query optimization guide: sorting keys, PREWHERE, data skipping indexes, FINAL evolution, JOIN algorithms, and anti-patterns.
- [ClickHouse® Projections: The Complete Guide](https://obsessiondb.com/blog/clickhouse-projections-complete-guide): ClickHouse projections explained: internal storage, query routing, three projection types, and a decision framework for when to use them vs materialized views.
- [You Don't Need a Separate Pipeline Between Your Warehouse and Your Real-time APIs](https://obsessiondb.com/blog/eliminate-pipeline-warehouse-realtime-api): The pipeline between your warehouse and your API is the most expensive infrastructure you own. Not because of what it costs to run, but because of what it costs your team to build, maintain, and debug.
- [How we detect outliers in real time using ClickHouse®](https://obsessiondb.com/blog/real-time-outlier-detection-clickhouse): Building a pipeline that flags outliers across 15M daily events in 21ms using chained materialized views and rolling quantiles in ClickHouse.
- [CollapsingMergeTree: Current State from Event Streams](https://obsessiondb.com/blog/collapsingmergetree-current-state-event-streams): Instead of asking ClickHouse which row is the latest during merges, you define it during ingestion by cancelling the old value and inserting a new row. The fundamental tradeoff: ingestion complexity for query simplicity.
- [How we feed OHLC candles to TradingView from ClickHouse® DB](https://obsessiondb.com/blog/ohlc-candles-tradingview-clickhouse): Building cascading AggregatingMergeTree tables for real-time OHLC candles served through TradingView's UDF API, with live streaming via Durable Objects.
- [AI Coding Agent Analytics: What 1,573 Sessions Taught Us](https://obsessiondb.com/blog/ai-coding-agent-analytics-1573-sessions): We ran Claude Code across 6 people and 37 projects. After 1,573 sessions, we found patterns nobody was measuring. Here's why we built rudel.ai.
- [ClickHouse® AggregatingMergeTree: Rollups That Scale](https://obsessiondb.com/blog/aggregatingmergetree-rollups-that-scale): The complete AggregatingMergeTree reference: combinator patterns, cascading rollups, SimpleAggregateFunction vs AggregateFunction, and production gotchas.
- [Current State with ClickHouse® ReplacingMergeTree](https://obsessiondb.com/blog/replacingmergetree-current-state): How we use ReplacingMergeTree with is_deleted to serve current state from 25MB batches, schema design, delta queries, and the full pipeline from blockchain events to trader screens.
- [ClickHouse® ReplacingMergeTree: Deduplication Done Right](https://obsessiondb.com/blog/replacingmergetree-deduplication-done-right): ReplacingMergeTree deduplicates at merge time, not insert time. Production patterns, FINAL performance, and the Postgres traps nobody warns you about.
- [Data Modelling in ClickHouse®: Engines, Tables, and Materialisations](https://obsessiondb.com/blog/data-modelling-clickhouse-engines-tables-materialisations): How to choose between MergeTree engines, design ORDER BY and PARTITION BY for performance, and use materialised views for pre-aggregation. A practical guide from running ClickHouse at petabyte scale.
- [How We Built a Stateless Distributed Cache for ClickHouse](https://obsessiondb.com/blog/stateless-distributed-cache-clickhouse): In a stateless distributed database, the network