DBCenter - The Embedded PostgreSQL for Modern Apps

Enterprise Grade. Developer Friendly.

Built on the robust foundation of PostgreSQL, enhanced with the speed of Rust, and wrapped in an API you'll actually enjoy using.

Rust Core Performance

The core engine is rewritten in Rust for zero-cost abstractions, memory safety, and blazing fast startup times.

AI-Ready Vector Store

Built-in pgvector support with ChromaDB-style API. No manual extension setup - just call vector_store() and start storing embeddings.

PostGIS Support

Full geospatial capabilities out of the box. Perform complex spatial queries without setting up an external server.

Fuzzy Text Search

Built-in pg_trgm for fuzzy matching. FuzzyWuzzy-like API running on PostgreSQL - 93x faster than pure Python solutions.

Watcher Pattern

A dedicated sidecar process ensures your database shuts down cleanly, even if your main application crashes.

Zero Dependencies

No Docker, no system PostgreSQL required. Binaries are lazily downloaded to ~/.dbcenter only when needed.

See It In Action

Explore real-world use cases with our built-in extensions. Click each example to expand.

from dbcenter import DBCenter

db = DBCenter("./data")

# Create vector store (pgvector auto-loaded)
vectors = db.vector_store("documents", dimension=1536)

# Add embeddings - ChromaDB-style API
vectors.add(
    ids=["doc1", "doc2", "doc3"],
    embeddings=[[0.1, 0.2, ...], [0.3, 0.4, ...], [0.5, 0.6, ...]],
    metadatas=[
        {"source": "blog", "author": "Alice"},
        {"source": "docs", "author": "Bob"},
        {"source": "paper", "author": "Charlie"}
    ]
)

# Semantic search - no SQL needed!
results = vectors.query(
    query_embeddings=[[0.1, 0.2, ...]],
    n_results=5,
    where={"source": "blog"}  # Filter by metadata
)

print(results)  # [{"id": "doc1", "distance": 0.23, "metadata": {...}}, ...]

use dbcenter::DBCenter;
use serde_json::json;

let db = DBCenter::new(Some("./data"))?;

// Create vector store (pgvector auto-loaded)
let vectors = db.vector_store("documents", 1536)?;

// Add embeddings - ChromaDB-style API
vectors.add(
    vec!["doc1", "doc2", "doc3"],
    vec![vec![0.1, 0.2, ...], vec![0.3, 0.4, ...], vec![0.5, 0.6, ...]],
    vec![
        json!({"source": "blog", "author": "Alice"}),
        json!({"source": "docs", "author": "Bob"}),
        json!({"source": "paper", "author": "Charlie"})
    ]
)?;

// Semantic search - no SQL needed!
let results = vectors.query(
    vec![0.1, 0.2, ...],
    5,
    Some(json!({"source": "blog"}))
)?;

package main

import "github.com/heyobi/dbcenter-go"

func main() {
    db := dbcenter.New("./data")
    
    // Create vector store (pgvector auto-loaded)
    vectors := db.VectorStore("documents", 1536)
    
    // Add embeddings - ChromaDB-style API
    vectors.Add(dbcenter.VectorAddOptions{
        IDs: []string{"doc1", "doc2", "doc3"},
        Embeddings: [][]float32{
            {0.1, 0.2, ...},
            {0.3, 0.4, ...},
            {0.5, 0.6, ...},
        },
        Metadatas: []map[string]interface{}{
            {"source": "blog", "author": "Alice"},
            {"source": "docs", "author": "Bob"},
            {"source": "paper", "author": "Charlie"},
        },
    })
    
    // Semantic search - no SQL needed!
    results := vectors.Query(dbcenter.VectorQueryOptions{
        QueryEmbeddings: []float32{0.1, 0.2, ...},
        NResults: 5,
        Where: map[string]interface{}{"source": "blog"},
    })
}

#include <dbcenter.h>

int main() {
    DBCenter* db = dbcenter_new("./data");
    
    // Create vector store (pgvector auto-loaded)
    VectorStore* vectors = dbcenter_vector_store(db, "documents", 1536);
    
    // Add embeddings
    const char* ids[] = {"doc1", "doc2", "doc3"};
    float embeddings[][3] = {{0.1, 0.2, 0.3}, {0.3, 0.4, 0.5}, {0.5, 0.6, 0.7}};
    const char* metadatas[] = {
        "{\"source\": \"blog\", \"author\": \"Alice\"}",
        "{\"source\": \"docs\", \"author\": \"Bob\"}",
        "{\"source\": \"paper\", \"author\": \"Charlie\"}"
    };
    
    vector_store_add(vectors, ids, embeddings, metadatas, 3);
    
    // Semantic search - no SQL needed!
    float query[] = {0.1, 0.2, 0.3};
    VectorResults* results = vector_store_query(
        vectors, query, 5, "{\"source\": \"blog\"}"
    );
    
    vector_store_free(vectors);
    dbcenter_free(db);
    return 0;
}

import com.dbcenter.DBCenter;
import com.dbcenter.VectorStore;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        DBCenter db = new DBCenter("./data");
        
        // Create vector store (pgvector auto-loaded)
        VectorStore vectors = db.vectorStore("documents", 1536);
        
        // Add embeddings - ChromaDB-style API
        vectors.add(
            Arrays.asList("doc1", "doc2", "doc3"),
            Arrays.asList(
                Arrays.asList(0.1f, 0.2f, ...),
                Arrays.asList(0.3f, 0.4f, ...),
                Arrays.asList(0.5f, 0.6f, ...)
            ),
            Arrays.asList(
                Map.of("source", "blog", "author", "Alice"),
                Map.of("source", "docs", "author", "Bob"),
                Map.of("source", "paper", "author", "Charlie")
            )
        );
        
        // Semantic search - no SQL needed!
        List<VectorResult> results = vectors.query(
            Arrays.asList(0.1f, 0.2f, ...),
            5,
            Map.of("source", "blog")
        );
    }
}

const { DBCenter } = require('dbcenter');

const db = new DBCenter({ path: './data' });

// Create vector store (pgvector auto-loaded)
const vectors = db.vectorStore('documents', { dimension: 1536 });

// Add embeddings - ChromaDB-style API
await vectors.add({
  ids: ['doc1', 'doc2', 'doc3'],
  embeddings: [
    [0.1, 0.2, ...],
    [0.3, 0.4, ...],
    [0.5, 0.6, ...]
  ],
  metadatas: [
    { source: 'blog', author: 'Alice' },
    { source: 'docs', author: 'Bob' },
    { source: 'paper', author: 'Charlie' }
  ]
});

// Semantic search - no SQL needed!
const results = await vectors.query({
  queryEmbeddings: [0.1, 0.2, ...],
  nResults: 5,
  where: { source: 'blog' }
});

console.log(results);

library(dbcenter)

db <- dbcenter_new(path = "./data")

# Create vector store (pgvector auto-loaded)
vectors <- db_vector_store(db, "documents", dimension = 1536)

# Add embeddings - ChromaDB-style API
vector_store_add(vectors,
  ids = c("doc1", "doc2", "doc3"),
  embeddings = list(
    c(0.1, 0.2, ...),
    c(0.3, 0.4, ...),
    c(0.5, 0.6, ...)
  ),
  metadatas = list(
    list(source = "blog", author = "Alice"),
    list(source = "docs", author = "Bob"),
    list(source = "paper", author = "Charlie")
  )
)

# Semantic search - no SQL needed!
results <- vector_store_query(vectors,
  query_embeddings = c(0.1, 0.2, ...),
  n_results = 5,
  where = list(source = "blog")
)

from dbcenter import DBCenter

db = DBCenter("./data")
products = db.collection("products")

# Insert some products
products.insert_many([
    {"name": "iPhone 15 Pro", "price": 999},
    {"name": "Samsung Galaxy S24", "price": 899},
    {"name": "iPad Air", "price": 599}
])

# Fuzzy search - FuzzyWuzzy-style API (pg_trgm auto-loaded)
results = products.fuzzy_search(
    query="ipone",  # Typo-tolerant!
    field="name",
    threshold=0.3
)

print(results)
# [{"name": "iPhone 15 Pro", "similarity": 0.67, ...}, ...]

# Or use direct similarity scoring
score = products.similarity("iPhone", "ipone")
print(score)  # 0.67

use dbcenter::DBCenter;

let db = DBCenter::new(Some("./data"))?;
let products = db.collection("products");

// Insert some products
products.insert_many(vec![
    json!({"name": "iPhone 15 Pro", "price": 999}),
    json!({"name": "Samsung Galaxy S24", "price": 899}),
    json!({"name": "iPad Air", "price": 599})
])?;

// Fuzzy search - FuzzyWuzzy-style API (pg_trgm auto-loaded)
let results = products.fuzzy_search(
    "ipone",  // Typo-tolerant!
    "name",
    0.3
)?;

// Or use direct similarity scoring
let score = products.similarity("iPhone", "ipone")?;

package main

import "github.com/heyobi/dbcenter-go"

func main() {
    db := dbcenter.New("./data")
    products := db.Collection("products")
    
    // Insert some products
    products.InsertMany([]bson.M{
        {"name": "iPhone 15 Pro", "price": 999},
        {"name": "Samsung Galaxy S24", "price": 899},
        {"name": "iPad Air", "price": 599},
    })
    
    // Fuzzy search - FuzzyWuzzy-style API (pg_trgm auto-loaded)
    results := products.FuzzySearch(dbcenter.FuzzyOptions{
        Query: "ipone",  // Typo-tolerant!
        Field: "name",
        Threshold: 0.3,
    })
    
    // Or use direct similarity scoring
    score := products.Similarity("iPhone", "ipone")
}

#include <dbcenter.h>

int main() {
    DBCenter* db = dbcenter_new("./data");
    Collection* products = dbcenter_collection(db, "products");
    
    // Fuzzy search (pg_trgm auto-loaded)
    FuzzyResults* results = collection_fuzzy_search(
        products,
        "ipone",  // Typo-tolerant!
        "name",
        0.3
    );
    
    // Or use direct similarity scoring
    float score = collection_similarity(products, "iPhone", "ipone");
    
    fuzzy_results_free(results);
    collection_free(products);
    dbcenter_free(db);
    return 0;
}

import com.dbcenter.DBCenter;
import com.dbcenter.Collection;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        DBCenter db = new DBCenter("./data");
        Collection products = db.collection("products");
        
        // Insert some products
        products.insertMany(Arrays.asList(
            Map.of("name", "iPhone 15 Pro", "price", 999),
            Map.of("name", "Samsung Galaxy S24", "price", 899),
            Map.of("name", "iPad Air", "price", 599)
        ));
        
        // Fuzzy search - FuzzyWuzzy-style API (pg_trgm auto-loaded)
        List<Map<String, Object>> results = products.fuzzySearch(
            "ipone",  // Typo-tolerant!
            "name",
            0.3
        );
        
        // Or use direct similarity scoring
        double score = products.similarity("iPhone", "ipone");
    }
}

const { DBCenter } = require('dbcenter');

const db = new DBCenter({ path: './data' });
const products = db.collection('products');

// Insert some products
await products.insertMany([
  { name: 'iPhone 15 Pro', price: 999 },
  { name: 'Samsung Galaxy S24', price: 899 },
  { name: 'iPad Air', price: 599 }
]);

// Fuzzy search - FuzzyWuzzy-style API (pg_trgm auto-loaded)
const results = await products.fuzzySearch({
  query: 'ipone',  // Typo-tolerant!
  field: 'name',
  threshold: 0.3
});

console.log(results);
// [{ name: 'iPhone 15 Pro', similarity: 0.67, ... }, ...]

// Or use direct similarity scoring
const score = await products.similarity('iPhone', 'ipone');
console.log(score);  // 0.67

library(dbcenter)

db <- dbcenter_new(path = "./data")
products <- db_collection(db, "products")

# Insert some products
collection_insert_many(products, list(
  list(name = "iPhone 15 Pro", price = 999),
  list(name = "Samsung Galaxy S24", price = 899),
  list(name = "iPad Air", price = 599)
))

# Fuzzy search - FuzzyWuzzy-style API (pg_trgm auto-loaded)
results <- collection_fuzzy_search(products,
  query = "ipone",  # Typo-tolerant!
  field = "name",
  threshold = 0.3
)

print(results)

# Or use direct similarity scoring
score <- collection_similarity(products, "iPhone", "ipone")
print(score)  # 0.67

from dbcenter import DBCenter

db = DBCenter("./data")

# Create geo collection (PostGIS auto-loaded)
stores = db.geo_collection("stores")

# Insert locations - simple dict, no SQL!
stores.insert_many([
    {"name": "Store A", "lat": 40.7128, "lon": -74.0060, "city": "NYC"},
    {"name": "Store B", "lat": 34.0522, "lon": -118.2437, "city": "LA"},
    {"name": "Store C", "lat": 40.7589, "lon": -73.9851, "city": "NYC"}
])

# Find nearby - no SQL needed!
nearby = stores.find_within_radius(
    lat=40.7128,
    lon=-74.0060,
    radius_km=5
)

# Distance calculation
distance = stores.distance_between(
    from_id="store_a",
    to_id="store_b"
)

# Check if point is within polygon
is_inside = stores.contains_point(
    polygon_id="delivery_zone_1",
    lat=40.7128,
    lon=-74.0060
)

use dbcenter::DBCenter;

let db = DBCenter::new(Some("./data"))?;

// Create geo collection (PostGIS auto-loaded)
let stores = db.geo_collection("stores")?;

// Insert locations - simple structs, no SQL!
stores.insert_many(vec![
    json!({"name": "Store A", "lat": 40.7128, "lon": -74.0060, "city": "NYC"}),
    json!({"name": "Store B", "lat": 34.0522, "lon": -118.2437, "city": "LA"}),
    json!({"name": "Store C", "lat": 40.7589, "lon": -73.9851, "city": "NYC"})
])?;

// Find nearby - no SQL needed!
let nearby = stores.find_within_radius(40.7128, -74.0060, 5.0)?;

// Distance calculation
let distance = stores.distance_between("store_a", "store_b")?;

// Check if point is within polygon
let is_inside = stores.contains_point("delivery_zone_1", 40.7128, -74.0060)?;

package main

import "github.com/heyobi/dbcenter-go"

func main() {
    db := dbcenter.New("./data")
    
    // Create geo collection (PostGIS auto-loaded)
    stores := db.GeoCollection("stores")
    
    // Insert locations - simple maps, no SQL!
    stores.InsertMany([]bson.M{
        {"name": "Store A", "lat": 40.7128, "lon": -74.0060, "city": "NYC"},
        {"name": "Store B", "lat": 34.0522, "lon": -118.2437, "city": "LA"},
        {"name": "Store C", "lat": 40.7589, "lon": -73.9851, "city": "NYC"},
    })
    
    // Find nearby - no SQL needed!
    nearby := stores.FindWithinRadius(40.7128, -74.0060, 5.0)
    
    // Distance calculation
    distance := stores.DistanceBetween("store_a", "store_b")
    
    // Check if point is within polygon
    isInside := stores.ContainsPoint("delivery_zone_1", 40.7128, -74.0060)
}

#include <dbcenter.h>

int main() {
    DBCenter* db = dbcenter_new("./data");
    
    // Create geo collection (PostGIS auto-loaded)
    GeoCollection* stores = dbcenter_geo_collection(db, "stores");
    
    // Find nearby - no SQL needed!
    GeoResults* nearby = geo_collection_find_within_radius(
        stores, 40.7128, -74.0060, 5.0
    );
    
    // Distance calculation
    double distance = geo_collection_distance_between(
        stores, "store_a", "store_b"
    );
    
    // Check if point is within polygon
    bool is_inside = geo_collection_contains_point(
        stores, "delivery_zone_1", 40.7128, -74.0060
    );
    
    geo_results_free(nearby);
    geo_collection_free(stores);
    dbcenter_free(db);
    return 0;
}

Performance That Matters

Real-world benchmarks comparing dbcenter to popular alternatives

Fuzzy Text Matching

Lightning-fast trigram scoring

93x faster

10,000 records · similarity threshold 0.3

dbcenter (pg_trgm) 1.7ms

FuzzyWuzzy (Python) 154ms

Vector Similarity Search

Embeddings at production scale

2.4x faster

Benchmark (N=200) · cosine similarity · top-10

dbcenter (pgvector) 5.2ms

ChromaDB (SQLite) 12.3ms

Ready to Experience the Speed?

Start building with dbcenter in less than 60 seconds

Architecture that Scales

1

Lazy Binary Loading

Binaries are downloaded to `~/.dbcenter` only when needed, keeping your deployment light.

2

Hybrid API Layer

Use the MongoDB-like API for rapid development, or drop down to raw SQL for complex joins and analytics.

3

Process Isolation

PostgreSQL runs as a child process, managed by the Rust core, ensuring stability and resource control.

PostgreSQL Power.
Zero Dependencies.

Enterprise Grade. Developer Friendly.

Rust Core Performance

AI-Ready Vector Store

PostGIS Support

Fuzzy Text Search

Watcher Pattern

Zero Dependencies

See It In Action

Vector Embeddings (pgvector)

Fuzzy Text Search (pg_trgm)

Geospatial Queries (PostGIS)

Performance That Matters

Lightning-fast trigram scoring

Embeddings at production scale

Ready to Experience the Speed?

Architecture that Scales

Lazy Binary Loading

Hybrid API Layer

Process Isolation

PostgreSQL Power. Zero Dependencies.

Enterprise Grade. Developer Friendly.

Rust Core Performance

AI-Ready Vector Store

PostGIS Support

Fuzzy Text Search

Watcher Pattern

Zero Dependencies

See It In Action

Vector Embeddings (pgvector)

Fuzzy Text Search (pg_trgm)

Geospatial Queries (PostGIS)

Performance That Matters

Lightning-fast trigram scoring

Embeddings at production scale

Ready to Experience the Speed?

Architecture that Scales

Lazy Binary Loading

Hybrid API Layer

Process Isolation

PostgreSQL Power.
Zero Dependencies.