One Database. Every Workload.

// One query: filter + vector search
const results = await db
  .collection('products')
  .aggregate([
    {
      $vectorSearch: {
        queryVector: embedding,
        path: "$vector",
        limit: 10,
        filter: { category: "electronics",
                  price: { $lt: 500 } }
      }
    },
    {
      $project: {
        name: 1, price: 1, score: 1
      }
    }
  ])
  .toArray();

// Before
const uri = "mongodb+srv://user:pass"
  + "@cluster0.mongodb.net/mydb";

// After - just change the host
const uri = "mongodb+srv://user:pass"
  + "@cluster.thermoclinecloud.com/mydb";

// Everything else stays the same
const client = new MongoClient(uri);
const db = client.db("mydb");
const users = await db
  .collection("users")
  .find({ active: true })
  .toArray();

// Create a vector index
await db.collection('articles').createIndex(
  { embedding: "vectorSearch" },
  {
    vectorSearchOptions: {
      dimensions: 1536,
      metric: "cosine"
    }
  }
);

// Semantic search with filters
const results = await db
  .collection('articles')
  .aggregate([{
    $vectorSearch: {
      queryVector: await embed(query),
      path: "embedding",
      limit: 20,
      filter: { published: true }
    }
  }]).toArray();

// Read data as it existed yesterday
db.orders.find(
  { customerId: "cust_123" },
  {
    readConcern: {
      atClusterTime:
        Timestamp(1706745600, 0)
    }
  }
)

// Compare current vs historical state
const now = db.accounts.findOne(
  { _id: accountId }
)
const then = db.accounts.findOne(
  { _id: accountId },
  { readConcern: {
      atClusterTime: yesterday
  } }
)

const stream = db
  .collection('orders')
  .watch([
    { $match: {
        operationType: { $in: [
          "insert", "update"
        ]}
    }}
  ]);

stream.on('change', async (event) => {
  // Update search index
  await searchIndex.upsert(event.fullDocument);

  // Invalidate cache
  await cache.del(event.documentKey._id);

  // Trigger webhook
  await notify(event);
});

// Document-level security policy
{
  "collection": "medical_records",
  "rules": [
    {
      "role": "doctor",
      "filter": {
        "assignedDoctor": "$auth.userId"
      }
    },
    {
      "role": "patient",
      "filter": {
        "patientId": "$auth.userId"
      }
    }
  ]
}

# List documents with filtering
curl https://api.thermoclinecloud.com/v1
  /db/mydb/collections/orders
  ?status=shipped&limit=10

# Time travel: read data at a past timestamp
curl https://api.thermoclinecloud.com/v1
  /db/mydb/collections/orders
  ?at=2025-01-15T00:00:00Z

# Insert a document
curl -X POST
  https://api.thermoclinecloud.com/v1
  /db/mydb/collections/orders
  -d '{"item": "widget", "qty": 5}'

import { ThermoclineClient } from '@thermocline/client';

const tc = new ThermoclineClient(url);

// Subscribe to database changes
tc.subscribe('orders', {
  filter: { status: 'pending' },
  onChange(event) {
    console.log(event.type, event.doc);
  }
});

// Presence tracking
const room = tc.presence('doc:abc');
room.enter({ cursor: { x: 0, y: 0 } });
room.on('update', (peers) => {
  // CRDT-merged peer state
  renderCursors(peers);
});

// WAL-based trigger: auto-embed on insert
export default {
  collection: 'articles',
  events: ['insert', 'update'],

  async handler(event, ctx) {
    const embedding = await ctx
      .embed(event.doc.content);

    await ctx.db
      .collection('articles')
      .updateOne(
        { _id: event.doc._id },
        { $set: { $vector: embedding } }
      );
  }
};

// Enqueue a message
await tc.queue('email-jobs').send({
  to: 'user@example.com',
  template: 'welcome',
  data: { name: 'Alice' }
});

// Process messages with visibility timeout
tc.queue('email-jobs').process(
  async (msg) => {
    await sendEmail(msg.body);
    msg.ack();
  },
  { visibilityTimeout: 30, batchSize: 10 }
);

# Create a branch (instant, O(1))
tc branch create feature/new-schema
  --from main

# Branch gets its own WAL + memtable
# Run migrations, seed test data...
tc branch connect feature/new-schema

# Merge back with conflict detection
tc branch merge feature/new-schema
  --into main
  --strategy last-write-wins

# Use in CI: auto-create per PR
tc branch create pr-${PR_NUMBER}
  --ttl 7d

// Upload a file
const file = await tc.storage('avatars')
  .upload('user-123.jpg', buffer, {
    contentType: 'image/jpeg',
    metadata: { userId: 'user_123' }
  });

// Get a public URL with transforms
const url = tc.storage('avatars')
  .getPublicUrl('user-123.jpg', {
    transform: {
      width: 200,
      height: 200,
      format: 'webp'
    }
  });

{
  "mcpServers": {
    "thermocline": {
      "command": "thermocline-mcp",
      "args": ["--transport", "stdio"],
      "env": {
        "TC_API_KEY": "tc_key_..."
      }
    }
  }
}

// Tool groups: database, schema,
//   management, docs

import { ThermoclineClient } from
  '@thermocline/client';

const tc = new ThermoclineClient({
  url: 'https://my.thermoclinecloud.com',
  apiKey: 'tc_key_...'
});

// Query builder
const orders = await tc
  .from('orders')
  .where('status', 'eq', 'shipped')
  .limit(25)
  .select('id', 'total', 'createdAt')
  .execute();

// Realtime subscription
tc.subscribe('orders', {
  onChange: (e) => update(e)
});