The SQLite of document databases — embeddable, compatible with MongoDB.

SecantusDB is a real MongoDB server written in Python: it speaks the MongoDB wire protocol on the same TCP socket a mongod would, so any standard driver — pymongo, mongo-go-driver, mongosh, mongodump — connects unchanged. Backed by the same WiredTiger engine MongoDB uses.

Read the docs pip install SecantusDB GitHub
Beta Past initial proving, but the Python API surface may still shift before 1.0. WiredTiger on-disk format is stable, but there's no migration tool yet — don't put production data here.

Drop-in for pymongo

Same wire protocol, same handshake, same error codes. The application code is byte-identical — only the setup line changes.

Normal MongoDB requires mongod running on :27017 
from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017")
db = client["mydb"]
db["users"].insert_one({"_id": 1, "name": "Joe"})
assert db["users"].find_one({"_id": 1})["name"] == "Joe"
Embedded SecantusDB no external process — in your test or app 
from pymongo import MongoClient
from secantus import SecantusDBServer

with SecantusDBServer(port=27017) as server:
    client = MongoClient(server.uri)
    db = client["mydb"]
    db["users"].insert_one({"_id": 1, "name": "Joe"})
    assert db["users"].find_one({"_id": 1})["name"] == "Joe"
Read the docs pip install SecantusDB

Why SecantusDB

Production-grade engineering — real wire protocol, real WiredTiger storage — scoped today to test and dev environments. Each panel links to the reference docs.

Drop-in wire protocol

Speaks MongoDB OP_MSG / OP_QUERY on a real TCP socket. pymongo, the Go driver, mongosh, and mongodump all connect with no code changes.

Architecture →

Single-node by design

No replica sets, no sharding, no cluster topology to model. Within single-node scope SecantusDB is a faithful surrogate — same handshake, same error codes.

Compatibility →

Python-native & embeddable

Start a server in two lines from any test or app. No mongod to install, no port juggling, parallel-test friendly. Or run it as a standalone daemon (secantusdb).

Quickstart →

Real WiredTiger storage

The same C library MongoDB ships with, vendored and built into the wheel. B-trees, page eviction, write-ahead logging, durability — all real.

Storage architecture →

Aggregation pipeline

Full pipeline — $match, $group (every mongod accumulator), $lookup with index-driven joins, $facet, $bucket, $densify, $fill, $merge, $out, $graphLookup, $geoNear. Same expression language as mongod.

Aggregation reference →

Geospatial — 2d & 2dsphere

$geoWithin, $geoIntersects, $near, $nearSphere, $geoNear all accelerated by either index type. S2 cell coverings for GeoJSON; quadtree-decomposed Z-order ranges for legacy [x, y] pairs. Compound geo+scalar indexes work too.

Geospatial reference →

Native TLS & mTLS

Wraps accepted sockets in TLS before the wire protocol starts — no reverse proxy required. Add a CA bundle for mTLS (transport-layer client-cert verification). SCRAM-SHA-256 still identifies the user on top.

Configure TLS →

Change streams

Oplog-backed, single-node. watch() at collection / db / cluster scope, resume tokens, fullDocument: "updateLookup", pre-images via changeStreamPreAndPostImages, awaitData blocking.

Change-streams reference →

Conformance-tested

Validated against the unmodified pymongo, mongo-go-driver, mongo-node-driver, mongo-ruby-driver, mongo-java-driver, and mongo-rust-driver test suites, plus PHP feature smokes. The pass rates are the honest compatibility gauge.

Validation summary →

Performance

A like-for-like benchmark currently has SecantusDB ~8×–46× slower per operation than mongod — the storage engine is the same WiredTiger C library, but the layers above it are Python. CRUD reads sit near the low end; bulk update / delete and aggregation at the high end. The trade is conformance and WiredTiger durability over per-op latency — for ephemeral test and dev data, the wall-clock difference rarely matters. Benchmark & methodology →

Every major MongoDB driver works

SecantusDB is validated against the official driver test suites, unmodified — the same tests the driver maintainers run against a real mongod. Six driver suites — Python, Java, Node.js, Go, Ruby, Rust — plus PHP feature smokes. One wire protocol. pymongo is the headline gauge: it runs the broadest in-scope set, so it's the only one below 100% and the most honest single number. The other five run curated, in-scope subsets in each driver's own language — their job is to catch wire-protocol bugs pymongo's permissive client accepts silently (cursor IDs that must be int64, strict type decoding), not to pile up a bigger count.

pymongo

Python
99.2% pass rate

1021 tests passed · 8 failed

The official MongoDB Python driver, and the deepest suite we run — so it surfaces the long tail. The remaining failures are features outside a single node's scope (text / hashed indexes, server-side $where JavaScript), tests that assume a multi-node cluster, and a few driver-side harness artifacts — not gaps in the CRUD, aggregation, or change-stream surface that test and dev rely on. We run pymongo's own tests, unmodified, against an embedded SecantusDB.

Read the report →

mongo-java-driver

Java
100.0% pass rate

447 tests passed · 0 failed

The driver enterprise MongoDB consumers most often use, and the foundation for many JVM-language wrappers. We run a curated subset of driver-sync/src/test/functional/ — integration tests that open a real connection to a SecantusDB daemon (the driver's own BSON codec unit tests are run but not counted here; they never touch the server). Type-strict decoders catch wire-shape divergences pymongo's permissive client accepts silently.

Read the report →

mongo-node-driver

Node.js
99.7% pass rate

358 tests passed · 1 known divergence

The official Node driver, and the same driver mongosh and the JavaScript ecosystem build on. We run a curated test/integration/ spec set via mocha --config test/mocha_mongodb.js — real wire commands against an embedded SecantusDB daemon.

Read the report →

mongo-go-driver

Go
100.0% pass rate

401 tests passed · 0 failed

The same driver mongodump and mongorestore are built on. We run ./internal/integration/... — the package that opens real mongo.Client instances and exchanges wire commands. Type-strict (int32 vs int64) bugs that pymongo accepts silently fail loudly here.

Read the report →

mongo-ruby-driver

Ruby
99.6% pass rate

258 tests passed · 1 known divergence

The official MongoDB Ruby driver (mongo + bson 5.x), the gem the Rails / Sinatra ecosystem builds on. We run a curated set of integration spec files end-to-end against an embedded SecantusDB daemon — every test opens a real Mongo::Client, SCRAM-authenticates as a pre-provisioned root-user, and exchanges wire commands.

Read the report →

mongo-rust-driver

Rust
100.0% pass rate

101 tests passed · 0 failed

The official MongoDB Rust driver — the basis for Tokio-async MongoDB consumers in Rust. We run a curated set of driver/src/test/ in-tree tests via cargo test --lib -p mongodb with MONGODB_URI explicitly overridden in the subprocess env, so the rust driver's fallback chain ($MONGODB_URI → ~/.mongodb_uri → localhost:27017) can't accidentally route to a real mongod.

Read the report →

mongo-php-library

PHP
98.3% pass rate

2147 tests passed · 37 failed

The official high-level PHP library — the mongodb/mongodb package Laravel and Symfony applications build on. We run its PHPUnit functional suite (Operation / Collection / Database / Command) end-to-end against an embedded SecantusDB daemon; the pure-code query-builder and BSON-comparator units are run but not counted here, since they never touch the server.

Read the report →

mongo-php-driver

PHP
99.6% pass rate

246 tests passed · 1 failed

The low-level PHP extension — the C-based PECL ext-mongodb that wraps libmongoc and underpins the library above. We run its .phpt wire-protocol suite via PHP's run-tests.php against an embedded SecantusDB daemon (the pure BSON-serialization tests are run but not counted). Alongside Go, the strictest wire-shape check we run — type divergences pymongo accepts silently fail here.

Read the report →

Plus a cross-driver feature matrix: every shipped feature (auth, change streams, custom roles, sessions, geo, bulk writes, type fidelity…) is verified end-to-end through the Python / Java / Node / Go / Ruby / PHP drivers via dedicated smoke tests — so a wire-shape divergence that one driver is permissive about gets caught by another.

A note on the license: SecantusDB is GPL-2.0-only. The GPL's obligations apply when you distribute SecantusDB or a derivative of it — not when you run it. Your application talks to it through a standard MongoDB driver over the wire protocol, and a test/dev dependency you don't ship leaves your application's license untouched.