Crates to interface with database management systems
Database management systems implemented in Rust. Store and query large amounts of data in an efficient manner.
Ergonomic wrapper for SQLite
Apache Parquet implementation in Rust
🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, and SQLite.
driver for Rust
🐚 An async & dynamic ORM for Rust
AMQP client library
in-memory query engine that uses Apache Arrow as the memory model
A safe, extensible ORM and Query Builder for PostgreSQL, SQLite, and MySQL
Rust wrapper for Facebook's RocksDB embeddable database
🔱 A dynamic query builder for MySQL, Postgres and SQLite
Native bindings to the libsqlite3 library
The official MongoDB driver for Rust
reading MaxMind DB format used by GeoIP2 and GeoLite2
Official Elasticsearch Rust client
Ergonomic wrapper for DuckDB
A native, synchronous PostgreSQL client
schema migration library for rusqlite using user_version instead of an SQL table to maintain the current schema version
An async extension for Diesel the safe, extensible ORM and Query Builder
AWS SDK for Amazon DynamoDB
framework for creating Postgres extensions
A fully typed LMDB (mdb.master) wrapper with minimum overhead
support for Rust
Powerful SQL migration toolkit for Rust
Rust driver for Neo4j
Rust client for Qdrant Vector Search Engine
An async client for Redis and Valkey
gitoxide project for shared worktree related types and utilities
Official Rust client for ClickHouse DB
A generic connection pool
SQLite and SQLCipher support for the r2d2 connection pool
binding
Async CQL driver for Rust, optimized for ScyllaDB, fully compatible with Apache Cassandra™
Rust wrapper for the Meilisearch API. Meilisearch is a powerful, fast, open-source, easy to use and deploy search engine.
persistent message streaming platform written in Rust, supporting QUIC, TCP and HTTP transport protocols, capable of processing millions of messages per second
client library implemented in rust
Install and run a PostgreSQL database locally on Linux, MacOS or Windows. PostgreSQL can be bundled with your application, or downloaded on demand.
A TDS (MSSQL) driver
Rust wrappers around Microsoft Azure REST APIs - Azure Cosmos DB
Driver for Rust
An OCI implementation in Rust
SQL Toolkit and ORM Library. An async, pure Rust SQL crate featuring compile-time Dynamic SQL
query language for JSON
A cloud native embedded storage engine built on object storage
Write ODBC Applications in (mostly) safe Rust
An ergonomic async client library for GCP BigQuery
FFI bindings to the sqlite-vec SQLite extension
database library
OpenAPI specification is a part of the Lance namespace specification. It contains 2 parts: The components/schemas, components/responses, components/examples, tags sections…
components/schemas
components/responses
components/examples
tags
Datafusion federation
Rustls integration for tokio-postgres
Apache ORC file format using Apache Arrow in-memory format
Postgresql wire protocol implemented as a library
The one-person framework for Rust
High level client bindings for FoundationDB
PostgreSQL parser that uses the actual PostgreSQL server source to parse SQL queries and return the internal PostgreSQL parse tree
Official OpenSearch Rust client
Arrow integration for pyo3
Native Delta Lake implementation in Rust
The package provides an interface to SQLite
QuestDB Client Library for Rust
Dead simple async pool for tokio-postgres
metrics for iroh
Auto-generated rust bindings for libpq
Parsing, writing, and evaluating BibTeX and BibLaTeX files
Selection kernels for arrow arrays
kvdb implementation backed by RocksDB
memcached client for rust
A partial port of elasticlunr.js to Rust for generating static document search indexes
Tokio based asynchronous MySql client library
Load data from databases to dataframes, the fastest way
Ergonomic wrapper for SQLite (libsql fork)
A very simple Google Bigtable client lib in Rust
Strongly typed Elasticsearch DSL
bindings
Async Cassandra DB driver written in Rust
The Spin Rust SDK makes it easy to build Spin components in Rust
extensible library for scheduling recurring tasks in rust
Core library for tree-sitter language pack - provides compiled parsers for 305 languages
Basic database traits for rust-analyzer. The concrete DB is defined by ide (aka ra_ap_ide).
ide
ra_ap_ide
Program for copying data between databases (pre-release)
AWS SDK for AWS Glue
Service for storing malicious, benign, or unknown files and related metadata and relationships
Google Cloud Platform bigquery client library
Write SQL queries in a simple and composable way
Transactional storage engine for Zarr designed for use on cloud object storage
Run a Postgresql database locally on Linux, MacOS or Windows as part of another Rust application or test
Language for Rust
The official Fluvio driver for Rust
Core crate providing a Delta/Deltalake implementation focused on interoperability with a wide range of query engines
The official Couchbase Rust SDK
DSN (Data Source Name) parser
A distributed message queue for Rust applications, on Postgres
SQLite storage backend for Deno KV
Easy support for interacting between SpacetimeDB and Rust
Memgraph database adapter for Rust programming language
Pure-Rust implementation of Fast Static Symbol Tables algorithm for string compression
Client for Rust
Safe binding for libpq
takes care of the accidental complexity of Rust backend projects so you can stay focused on what matters
Sqlx adapter for casbin-rs
RESP2 and RESP3 protocols
An extension for Diesel framework to support PostGIS geometry datatype
client for Snowflake
Apache Iceberg Rust implementation
Universal memory runtime for AI agents — episodic, semantic, and procedural memory with 8-signal fusion retrieval
Web server library for session-based queries using Arrow and other large datasets as data sources
High-Performance ORM for ScyllaDB
Dead simple async pool for redis
Core library for Memvid v2, a crash-safe, deterministic, single-file AI memory
fast, and secure WebSocket server for real-time applications
Extend the capabilities of DataFusion to support additional data sources via implementations of the TableProvider trait
TableProvider
Common library for the Shuttle platform (shuttle.dev)
Open source SQL database engine fully written in Rust with pure functional execution layer, easily swappable storage and web assembly support!
CLI tool for sentry-options for validation of schema and values
Generate type-checked Rust from your PostgreSQL queries
Drasi Core Cypher Parser
Executable skills for Agents
🧰 The Rust SQL Toolkit. An async, pure Rust SQL crate featuring compile-time checked queries without a DSL. Supports PostgreSQL, MySQL, SQLite, MSSQL, and ODBC.
Agnesoft Graph Database
PostgreSQL logical replication protocol library - parse and handle PostgreSQL WAL streaming messages
A complete library to interact with Docs (protocol v1)
Terminal UI for Redis - A modern TUI for managing Redis servers
Storage backends for conversations and responses
A parser for the PRQL query language
humane, typed key-value storage solution
A service and CLI tool for collecting SDLC/CI/CD events and dispatching them as CDEvents
A package manager for PostgreSQL extensions
Web's IndexedDB Storage backend for matrix-sdk
An OCI-based (synchronous or asynchronous) interface between Rust applications and Oracle databases
CQL data types and primitives, for interacting with ScyllaDB
A single-binary MCP server for MySQL, MariaDB, PostgreSQL, and SQLite
Object Identifier (OID) database
Build data user interfaces entirely in SQL. A web server that takes .sql files and formats the query result using pre-made configurable professional-looking components.
A no-frills async memcached client for Rust
High-level bindings for Faiss, the vector similarity search engine
A yaml-to-rust code generator for generating Rust code from yaml config files e.g. as found in openAPI.
Native bindings to the libduckdb library, C API
gRPC search server for Hermes
Compression, decompression, testing, diffing and patching functions for SQLite: gzip, brotli, bsdiff,
Google Cloud Platform rust client
A lean, efficient and fast persistent in-process key-value store
A keyboard-driven terminal UI for browsing, querying, and administering Turso and SQLite databases
A query builder for MySQL for Rust is designed to be flexible and easy to use
parser and runner
CouchDB library for Rust
AWS SDK for Amazon Athena
RDF data shapes implementation in Rust
Fast, robust, powerful, user-friendly pkgsrc package builder
Any storage. Any agent. One CLI
Migrator for writing sqlx migration using Rust instead of SQL
A feature rich TUI budget tracker app
Find geo information & proxy information based on the given IP using IP2Location BIN databases
A fast, driver-less TUI for browsing and editing PostgreSQL databases
🌿 SQL schema definition and discovery
A standalone database CLI migration tool
A flexible, type-safe SQLx query builder for dynamic web APIs, offering seamless pagination, searching, filtering, and sorting
Messaging Mediator service for Affinidi Messaging (DIDComm and TSP)
SQLite compatible database with CJK FTS5 full-text search
CLI for scythe -- SQL-to-code generator with linting and formatting
In-memory implementation of hash-db, useful for tests
Full cache based database，support transaction
An MCP server for storing and manipulating structured data using SQLite
A PostgreSQL-based provider implementation for Duroxide, a durable task orchestration framework
Async / distributed job runner
scripting analyses against crates.io's database dumps
Personal task-tracking
Rust client for sentry-options config system
language implementation of TiKV client
An extensible note taking system for typst
memory storage service with MCP interface for Claude Desktop
Internal implementation of diesels migration mechanism
Databend Driver for Rust
A compatible re-implementation of LevelDB in Rust
Client for Chroma, the AI-native cloud database
A pleasure to meet you. I am C-3p0, JSON-DB Relations.
The convenience of SQLite – but with PostgreSQL (Command-line application)
Event Sourcing Entity Framework
SpireDB command-line interface
gitoxide project dedicated to implementing a 'blame' algorithm
A high-speed SQL linter
Postgres Foreign Data Wrapper development framework in Rust
that bridges between tantivy and jieba-rs
A collection of different transport implementations and related tools focused primarily on web technologies
Rust client for The Movie Database (TMDB) API
A PostgreSQL monitoring TUI
MCP server exposing 17 code intelligence tools for Claude Code, Cursor, Windsurf, and Zed
PartiQL Values
low-level MbTiles access and processing library, with some tile format detection and other relevant heuristics
An async ORM for (postgres, mssql, mysql, sqlite)
Typed, local-first tabular data library with columnar in-memory storage
a CLI tool for polling the messages from your AWS DLQ instance
time series database designed specifically for storing and managing large amounts of blob data
SQLite-backed credential store for the keyring-core API
keyring-core
DynamoDB business logic and storage engine for Rustack
Redis async driver for Rust
An asynchronous futures based Redis client for Rust using Tokio
client library for the ChromaDB vector database
Kotlin language plugin for sqry
Production-grade Rust SDK for building DuckDB loadable extensions
A toolkit for building enterprise-grade batch applications
Idiomatic and safe MDBX wrapper
An in-process property graph database management system built for query speed and scalability
Roblox reflection database and ambiguous type resolution
Public abstract API of ADBC
Nix Version Index
Cypher parser and planner for Mesh
SPARQL 1.1 Protocol HTTP endpoint for pg_ripple — connects PostgreSQL 18 RDF triple store to the web
Sql library to use with scouter-server
Shell Query - CLI for capturing and querying shell command history
A component of the servo web-engine
High-performance mutable persistent vectors built on rawdb
different tools for projects using the diesel_cli
A fully spec-conformant XML library
A safe Rust API for libesedb
High performance Rust/PostgreSQL job queue (also suitable for getting jobs generated by PostgreSQL triggers/functions out into a different work queue)
CLI for the Rust Redis Vector Library
Enterprise-grade configuration loader for Greentic hosts
A boringly-named priority work queue system for doing async tasks
that provides utilities for working with the System for Cross-domain Identity Management (SCIM) version 2.0 protocol. (rfc7642, rfc7643, rfc7644)
Pylon — realtime backend as a single Rust binary. Schema, policies, server functions, live queries, auth — one process.
Read/Write Apache Arrow arrays from/to ODBC data sources
HNSW Approximate Nearest Neighbors in Rust, based on LMDB and optimized for memory usage
Secondary indices like PouchDB for RocksDB in Rust
Content-hashed delta sync for SQLite -- push, pull, and bidirectional sync to any pluggable target
Self-hosted, simple and privacy respecting website traffic tracker
Port of biocommons/hgvs to Rust
Light version of SQLite developed with Rust. Published as sqlrite-engine on crates.io; import as use sqlrite::….
sqlrite-engine
use sqlrite::…
Hashing functions for SQLite with aggregation support: MD5, SHA1, SHA256, SHA512, Blake3, FNV-1a, xxHash
Revolt Backend: Database Implementation
PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement
Apache Kafka compatible broker with S3, PostgreSQL, Apache Iceberg and Delta Lake
Native HDFS client implementation in Rust
Defines the logical types for arrow arrays
SQL runtime library for Feldera
Converts migration actions into SQL statements with bind parameters
tsk-tsk: keeping your agents out of trouble with sandboxed coding agent automation
Read & Write .dbf in Rust
Building blocks to observe database table changes in sqlite3
Full-featured async (tokio-based) postgres connection pool (like r2d2)
temporal graph library
distributed locking mechanism built on top of Async Redis
CLI for ferriorm ORM - init, generate, migrate commands
嵌入式内存数据库
DuckLake query engine for rust, built with datafusion
Workflow management system
Turtle/N3 parser
Kafka topics and schemas for Sentry
Drasi Core GQL Parser
high-performance, database-driven job queue for Rust with PostgreSQL and MySQL support, featuring job prioritization, cron scheduling, event streaming (Kafka/Kinesis/PubSub), webhooks…
Parser, formatter, validator, and language server for SQLite SQL — built on SQLite's own grammar
High-performance CLI tool for splitting large SQL dump files into individual table files
fast, embedded, transactional, key value store
PostgreSQL-first, offline schema migration tool with Django-like ergonomics
Apple frameworks bindings for rust
SQL as a Function for Rust
Core graph engine and reasoning primitives for m1nd
CLI for Tuitbot autonomous X growth assistant
A command-line tool for querying databases via ADBC
SQLite extension for graph queries using Cypher
High-level framework for building Model Context Protocol (MCP) servers
powerful database migration tool
Postgres support for the r2d2 connection pool
PowQL lexer, parser, planner, and executor for PowDB
Backend for Zenoh using AWS S3 API
Snowflake API bindings
CLI tool for Apache kafka. It allows you to navigate topics and search Kafka records.
Remote (KV Connect) backend for Deno KV
Lightweight, Flyway-compatible PostgreSQL migration CLI
async bb8 connection manager for Diesel
comparing two PostgreSQL databases
Iggy is the persistent message streaming platform written in Rust, supporting QUIC, TCP and HTTP transport protocols, capable of processing millions of messages per second
SQL data primitives. Use it to generate SQL queries, auto-generate SQL migrations, and more.
Structured access to the install-action manifests
ART-OLC concurrent adaptive radix tree
Efficient interface to SQLite that doesn't get in your way
ASIMOV Software Development Kit (SDK) for Rust
Start local postgres servers for testing without Docker
nu plugin to add parquet support
MVCC page-level versioning for concurrent writers
A lightweight SQL framework for sustainable database reliant systems
lex and sanitize SQL
pg_catalog compatibility for datafusion
LSP Brains core scoring engine — pure logic, zero I/O
High level bindings for the Falco plugin API
Ergonomic MongoDB ODM
managing MongoDB Atlas local environments
working with sqlite asynchronously
Core implementation layer for Azure Cosmos DB - provides transport, routing, and protocol handling for cross-language SDK reuse
Helios FHIR Server - A high-performance FHIR R4/R4B/R5/R6 server
Parser for Sigma detection rules, correlations, and filters
Noggrann - a CLI issue tracker and todo list with a project-local database
Rust interface to pkgsrc packages and infrastructure
Apache Arrow integration for hdbconnect SAP HANA driver
Runtime-agnostic DBMS engine for WASM environments
reading/writing KeePass 2 and KeePassX databases
Powerful model codegen
Core storage, data model, query engine, and indexing for Mnemo
Command-line interface for Zart — migrate, schedule, inspect, and manage durable executions
RustPython virtual machine
Generated library to interact with Scaleway API
Tokio-based Postgres wire-protocol logical replication client (pgoutput) with TLS and SCRAM
Connection string parsing in Rust (and WebAssembly)
The package provides bindings to SQLite
A Postgres TUI client that utilizes your terminal text editor for inserts & updates
HTTP server binary for LoraDB, exposing a Cypher-over-HTTP API
Google Cloud Platform spanner client library
A developer-friendly ORM for Rust with clean, expressive syntax
Command-line sqllogictest runner for DuckDB
Tools for working with GraphQL in Rust
Bindings to IndexedDB that default the transactions to aborting and can work multi-threaded
Runtime library for compiled Sage programs
Apache Arrow Flight
MCP Server for DNS Orchestrator - AI agent interface
Lowering and IR for Hamelin query language
Lint rules (sqlfluff-compatible) for the rigsql SQL linter
A link budget toolbox for satellite communications
loadable extension for SQLite that provides Joe's ULIDs
A Cassandra CQL driver, built on top of the DataStax C++ driver for performance and functionality
re-implementation of the Apache Cassandra cqlsh shell
easy to use ORM for SQLite databases
A SQL parser, optimizer, and transpiler library inspired by Python's sqlglot
mysql 数据库快速连接方法
Derive complete REST APIs from Sea-ORM entities — endpoints, filtering, pagination, batch ops, and OpenAPI on Axum
A matrix message logger with full text search support
API orchestrator for load distribution between runners
Generate the multiple programming languages structure based on the MySQL/PostgresSQL table structure
SQLite extension providing PGVector-like native vector types with HNSW indexing
Testcontainers modules for Supabase services used in integration testing
Combines the chalk-engine with chalk-ir
A lightweight SQL server that serves YAML-defined tables over standard SQL protocols
Set up a modern rust+react web app by running one command
Cloud-native TigerBeetle client for Rust with DNS-based service discovery
Trait for hash-keyed databases
A lock-free thread-safe concurrent ARENA based (heap backend or memory map backend) skiplist implementation which helps develop MVCC memtable for LSM-Tree
Optional dialect function catalogs for polyglot-sql semantic validation
Instance representation for panproto
Manage migrations, seeding and tests for your SurrealDB via CLI
Django-shaped batteries-included web framework for Rust: ORM + migrations + auto-admin + multi-tenancy + audit log + auth (sessions, JWT, OAuth2/OIDC, HMAC) + APIs (ViewSet, OpenAPI auto-derive…
Command line tool for file identification
In-memory SQL-like query engine and lightweight data store for testing and prototyping
Automatic OpenAPI 3.0 generation for Axum applications
A reliable job queue using PostgreSQL as a backing store
Command-line interface for OxiRS - import, export, migration, and benchmarking tools
The sabi data access library for Redis in Rust
Schema-optional, file-based project memory system
a database management tui
PostgreSQL metric exporter for Prometheus
A PostgreSQL SQL formatter
Migration tool for importing vectors from other databases into VelesDB
Derive macro for reading and writing types for redis usage, either through serde or format args
Connection telemetry middleware for diesel and tracing
Schema parsing and validation for Nautilus ORM
DWBase: agent-first immutable atom store, components, and tools
Rust SDK for S2
Sqlite storage backend for matrix-sdk
Background task processing for rust using apalis and postgres
Unofficial flatbuffers and tonic code of Apache Arrow spec
Postgres ORM with native double-entry ledger, graph relations, and atomic money operations for Rust
PostgreSQL schema management tool
A high-level DynamoDB table abstraction with get_item, query, update, filter, batch operations, pagination, and type-safe queries
Product OS : Store provides a flexible and higher-level framework for defining storage engines / database engines and the actions to read and write to those storage engines / databases…
AWS SDK for Amazon Timestream Query
A comprehensive Rust library for various utilities and helpers
Kotoba-specific Jsonnet implementation compatible with Jsonnet 0.21.0
A high-performance Rust client for streaming data ingestion into Databricks Delta tables using the Zerobus service
Rust Alchemy is Django ORM like lib for Rust
Extension for sqlite that provides transparent dictionary-based row-level compression for sqlite
CLI for the Omnigraph graph database
InfluxDB Rust driver
Redis Cloud REST API client library
Local-first anime and manga metadata catalog for Rust media servers
Turso/libSQL storage backend for the do-memory-core episodic learning system
A state machine database with WAL durability
Graph query engine for Lance datasets with Cypher support
Switchy database package
represents a library for managing AdGuard filter lists
parsing PCI ID tables
Intermediate representation types for Feldera Programs
The reference implementation of the Jubako container format
A globally distributed container orchestrator
REST API server for VelesDB vector database
Event sourcing and CQRS toolkit with SQL persistence, projections, and subscriptions
MCP (Model Context Protocol) server for MemMe memory engine
Rust-based worker for varfish-server
An async ORM for Rust supporting SQL and NoSQL databases
Core types crate for Terraphim AI
Distributed clustering and sharding for ruvector
Rust Project Template
highly-available, embeddable, raft-based SQLite + cache
Easily create user defined functions (UDFs) for MariaDB and MySQL
InnoDB file analysis toolkit
Lightweigt dynamic database queries for rusqlite
GeoPackage reader/writer built on top of rusqlite
SHV broker
An implimentation of controller-runtime's fake client for rust
parsing, manipulating, and analyzing molecular formulas
TypeDB Rust Driver
PostgreSQL management library for the LMRC Stack - comprehensive library for managing PostgreSQL installations on remote servers via SSH
SQLite-backed index for Homebrew formula and cask metadata with FTS5 full-text search
The name TegridyDB (short for TegDB) is inspired by the Tegridy Farm in South Park and tries to correct some of the wrong database implementations, such as null support, implicit conversion support, etc
Async ClamAV bindings for Rust
A lightweight TUI application to view and query tabular data files, such as CSV, TSV, and parquet
Standalone facade crate for observability operations
CLI tool for FCC ULS data retrieval and management
VIL Semantic Log System — zero-copy, non-blocking, structured logging with pluggable drains
Resumable state machine based Postgres tasks
A toolkit for building Redis modules in Rust
Kubernetes Custom Resource Bindings
Wire protocol and shared types for Kyomi Connect
An ORM with a focus on simplicity and on writing Rust, not SQL
Do painless migration 🦀
PartiQL AST
mysql binlog connector
ergonomic, high-level RocksDB wrapper for Rust. Features CF-aware optimistic & pessimistic transactions, advanced routing for merge operators and compaction filters, performance tuning profiles…
An extra set of tools for managing Supabase projects going beyond the possibilities of regular Supabase CLI
SQL query builder to easily build complex queries in Rust
A proxy for debugging MonetDB's wire protocol
Helsing's Rust bindings for sqlite3's lsm1 extension in stand-alone fashion
Public API facade
terminal database client focused on reliable SQL editing
PostgreSQL driver implementation for SQLx. Not for direct use; see the sqlx crate for details.
sqlx
A lightweight embedded time-series database with a straightforward API
A content-addressable storage (CAS) system optimized for large blobs with read-mostly access patterns
Object model manager for PostgreSQL
Fork of sqlparser with additional PostgreSQL features (PARTITION OF, SECURITY DEFINER/INVOKER, SET params, EXCLUDE, TEXT SEARCH, AGGREGATE, FOREIGN TABLE/FDW, PUBLICATION, SUBSCRIPTION…
Write-ahead logging
Core library for Treetop, a Cedar policy engine implementation
semantic code knowledge graph for faster AI-assisted development
DataFusion SQL Query Planner
Vim-modal SQL client: TUI front-end for sqlx-backed connections with LSP-aware editing
Generated Rust FlatBuffers bindings for Synapse schemas
A CLI tool to manage your multi-environment database configurations
Native bindings to librocksdb
postgres raw sql migration generator and manager
Core formatting and parsing utilities for Styx
🌱 Write sedders in RON
KeePass .kdbx database file parser with ehancements
powerful, async-first ORM for Turso Database with first-class support for Cloudflare Workers and WebAssembly environments. Features include automatic boolean conversion, upsert operations…
API
that provide information about countries
enduser-learnable-language for database queries
A asynchronous declarative ORM written in pure rust
PostgreSQL commands for interacting with a PostgreSQL server
an in-memory database in Rust for rows queried using bit (flag) columns
A Firestore path helper
that makes it easy to subscribe to PostgreSQL notifications
Database operations and storage layer for Nexus Memory System
Durable workflow engine with REST+SSE API on PostgreSQL 18 and SQLite backends. Embeddable library or standalone server (via assay-engine).
A lightweight, SQL-friendly ORM for Rust
Command-line interface for FlowScope SQL lineage analyzer
DiskANN is a fast approximate nearest neighbor search library for high dimensional data
Signaling types for the OpenTalk chat module
lightweight knowledge base for rust
The pagination powerhouse, built with Rust
受 pytdx 启发的 A 股数据获取库
Lightweight async wrappers for tokio-postgres, rusqlite, turso, and tiberius
local key-value store
A blazing-fast, native Redis GUI built with Rust and GPUI
Rust client for the AllSource event store — query, ingest, and fold events
Rust bindings for sentry-protos
It's like Redis but a bit rusty
An interface for leveldb
An ORM for people who love SQL
Search crates in a panamax mirror like cargo search
cargo search
A persistent PostgreSQL-compatible endpoint for DuckLake
MCP server for managing multiple Elasticsearch instances with raw Dev Tools-style query execution, per-instance memory, and shared docs
hosting platform for Rust applications that allows you to deploy all types of workloads by writing **only Rust code**
Terminal database client with Vim-style navigation
Infer a schema from JSON input, output as JSON Schema or human-readable format, and generate synthetic data based on the inferred schema
Cargo subcommand for 'pgrx' to make Postgres extension development easy
A profile converter for surge/clash
Tauri SQLite plugin using rusqlite
Stateless object storage buffer library for OpenData systems
Run the PostgreSQL server off a temporary data directory
Effortlessly yank and paste files blazingly fast in the terminal
Read and modify Minetest worlds
Database-like operations on Obsidian markdown files with YAML frontmatter
Tracing library powering cala stack
Core library for Things 3 database access and data models
sidekiq server and client using tokio
Bump allocator with thread-local recycling for bsql drivers
Subscribe Redis and Invoke Lambda with cargo lambda, for Local development
A Prometheus exporter for qBittorrent that provides detailed torrent metrics with support for categories and tags. Collects both per-torrent statistics and aggregated metrics grouped by categories and tags.
OpenTelemetry-compatible tracing for SQLx database operations in Rust
✅ Validate protobuf messages using protobuf annotations
An easy local data persistence layer, backed by SQLite
Distributed Neo4j-compatible hypergraph database with SIMD optimization
PostgreSQL to Any database library with Change Data Capture (CDC) and logical replication support
A CLI tool for generating models based on a SQL Database using SQLx
A standalone, pure Rust gRPC wire protocol for GQL (ISO/IEC 39075)
Command-line application to run a Postgres database
Experimental PowerSync SDK for Rust applications
Command-line interface for AxiomMe data runtime
Minimal append-only WAL (Write-Ahead Log) optimized for Raft consensus
Restore a rocks database from object storage
Predict your next shell command based on history — like shell autocomplete, but MORE stupid
Drasi Core Middleware
geotechnical ground modeling and soil parameter analysis
A toolkit for building valkey modules in Rust
Reporting structures for GTFS Guru validator
Core library for the SAP framework
个人使用构建后端服务器
An app starter for traditional web apps
reusing SQL
writing the CodeTracer db trace format
Durable activity queue and worker system
Tembo Stacks for Postgres
ClickHouse Arrow Client for Rust
Concurrent URL status checker that captures comprehensive metadata in SQLite
A complete library to interact with Spanner (protocol v1)
A reasonably fast configurable embedded key-value sensor database
SQL code generator
Query AST, builder, and SQL compiler for the fathomdb agent datastore
A lightweight, embeddable DynamoDB emulator backed by SQLite
A high-performance concurrent key-value store and log engine in Rust
Bolt DB Port in Rust
Standard types used by AHQ Store
Backend for Zenoh using RocksDB
Rust parser for nextcloud config files
Universal, schema-bearing data handle for the Vantage data framework
redb fork with AES-256-GCM page encryption and zstd compression
A high-performance, modular Rust library for parameterizable SQL query management with support for SQLite and PostgreSQL
modern DataFrame / Data Engineering / Data Analysis library that combines the familiarity of DataFrame operations (like those in PySpark, Pandas, and Polars) with the power of SQL query building…
Process Mining library for working with (object-centric) event data
不可变数据结构与事务系统基础
Type-safe SQL query wrappers
AWS SDK for Amazon Elasticsearch Service
SQL query tool for CSV/JSON with both interactive TUI and non-interactive CLI modes - perfect for exploration and automation
Cabal file parser and Hackage package loader for the Haskelujah compiler
client for the Baserow API
client library for the Notion API
Terminal UI database browser for SQLite, PostgreSQL, and MySQL
Redis Enterprise REST API client library
Medical history records — allergies, conditions, family history, surgical history
CLI binary for bones issue tracker
A file-based way to edit postgresql databases (procedures, views, triggers) without GUI
Official MTGJSON Rust SDK — Query Magic: The Gathering card data via DuckDB
Typed Rust client SDK for lattice-db — wraps the NATS request/reply protocol
bindings for Rust with Multiple Pattern and Streaming Scan
go standard library implementation in rust. gostd 是Go标准库的rust实现
A high-performance geographic database with countries, states, cities, and more
gRPC server for zopp secrets manager
YantrikDB database server — multi-tenant cognitive memory with wire protocol, HTTP gateway, replication, auto-failover, and at-rest encryption
Lightweight synchronous IPC client for the running-process daemon
Rust based Firebase library
building SQL queries
Tools of the Chewing (酷音) intelligent Zhuyin input method
Session storage abstractions for Model Context Protocol (MCP) servers
Core library for Postrust - PostgREST-compatible REST API for PostgreSQL
lightning-fast graph data access to ArangoDB
schema definition language - CLI
custom database
Migration management for diesel
Oxigraph CLI tool and SPARQL HTTP server
Query planner: name resolution, WHERE analysis, join ordering
Generates OSM heatmap tiles from GPX tracks
A relational algebra library for Rust
High-level async SQL Server client with type-state connection management
Eure core library
Infrastructure automation API, allowing programmatic access to all Exoscale products and services
Small Rust CLI for tmux session selection and creation
High-level SDK for building durable workflows with runtara
High-performance MCP server that gives LLMs sub-millisecond access to your Zotero library
A low-level, zero-overhead Rust implementation of the Postgres wire protocol
A migration management library for applications using PostgresSQL, MySQL or SQLite
Turning SQL queries into Rust functions
in-process, distributed database with materialized view support
功能强大的数据库迁移、同步、运维工具，支持自动分库分表、慢查询检测、数据对比、备份恢复，提供多语言SDK
Command-line tool for Soot web framework project scaffolding
Unified meta-crate for the Aqueducts data pipeline framework
Dashboard collecting every movie in your friend group that tells notifies everyone on telegram whenever a new one came in
macOS clipboard memory backed by SQLite and searchable from agent runtimes
fzf-powered connection picker for sqlit
A real-time AIS data decoder
Broccoli is a simple, fast, and reliable job queue for Rust
PostgreSQL logging handler for outlet HTTP request/response middleware
Large-scale Sparse Merkle Tree backed by pluggable storage - RocksDB backend
client for Apache TinkerPop™
Automates upgrades and pulls remote databases, files, and firmware for the Flipper Zero
A distributed cronjob library
Convert SQL query results to JSON without struct mapping, supporting MySQL/PostgreSQL/SQLite/Odbc
Toolkit to build plugins for picodata.io DBMS
GlueSQL - Open source SQL database engine fully written in Rust with pure functional execution layer, easily swappable storage and web assembly support!
ring queries in high-dimensional vector spaces
object_store implementation for Native HDFS client
Migration runtime and schema builder for lift
An ergonomic sqlite library with compile time guarantees
Command-line interface for AimDB - development and administration tool
no_std filter expression engine for tracepoint-like events in operating systems
Serializable do/undo library
Time zone data providers
Sync Readwise Reader documents into a PostgreSQL database
.bit language parser, IR, interpreter, and toolkit
Shared storage backend abstraction for InferaDB services
CLI messenger for agent-to-agent encrypted communication over Nostr
An almost-safe, near-zero-cost, feature-complete, unabashedly non-abstract wrapper around LMDB
Database abstraction layer built on mysql_async with derive macros
Structured execution telemetry event schema used across VT Code crates
high-performance CLI tool to bulk-insert documents into Google Firestore from a JSON file
Core manifest, diff, SQL rendering, and export primitives for pgroles
Agent-first database control CLI with least-privilege execution
Tank (Table Abstraction and Navigation Kit): the Rust data layer. Simple and flexible ORM that allows to manage in a unified way data from different sources.
Compile-time-checked PostgreSQL queries with a pure-Rust wire protocol driver
A command-line application for interacting with git repositories
ayb makes it easy to create, host, and share embedded databases like SQLite and DuckDB
Lightweight, Rust-native ATProto labeler
Language Server Protocol implementation for PostgreSQL and PL/pgSQL
Fixed-length, sliceable URL identifier system for efficient database storage and querying
Storage abstraction layer with SQLite backend and repository pattern
Kafka sink stage for the ECL pipeline runner (Avro + Schema Registry)
Rust SDK for Synap - High-Performance In-Memory Key-Value Store & Message Broker
Diesel filter is a quick way to add filters and pagination to your diesel models
Core runtime traits and builders for the Saola type-safe ORM
Generate pattern based random data for mysql
Buoyant Data distribution of delta-kernel
OMM database layer
Lateral movement tracker for anything! A DFIR tool that parses forensic artifacts and visualizes lateral movement in graph databases. Written by Toño Díaz (@jupyterjones)
QuickPeach's typed plugin host runtime and import model
Access the PARSEC database for stellar evolutionary trajectories
SQL parser for contextdb with GRAPH_TABLE and vector extensions
A graph-first, embedded multi-model database engine
Real-time streaming for Aegis database
Python runtime + pyo3 bindings for Cloacina. Split out of the main cloacina crate so binaries that don't execute Python don't transitively link pyo3 (CLOACI-T-0529).
Nostr-native dispute coordination daemon for the Mostro ecosystem
TUI to index once, enrich with metadata, and browse a flat snapshot in a 3-pane layout with multiple modes
Database for CITA
Implements various git object databases
Shared observability utilities for Feldera services
Module loader and project management for Sage
A command-line database service for tracking strategic intent, tasks, and events
bus — Lightweight CQRS Library for Rust
A high-performance multi-level cache library for Rust with L1 (memory) and L2 (Redis) caching
HyperLogLog implementation in rust
asynchronous background jobs implemented with pluggable backends and runtimes
Revolt Backend: API Models
Code-first database toolkit for SurrealDB - schema definitions, migrations, query building, and typed CRUD (Rust port of oneiriq-surql). Published as the oneiriq-surql crate; imported as use surql::....
oneiriq-surql
use surql::...
mssql 数据库快速连接方法
Persistent fact stores for Mangle
Driver for TDengine - a timeseries database and analysis platform
Physical operators and query execution for Mesh
A complete library to interact with datastore (protocol v1beta3)
Bindings to librrd to create and interact with round robin databases created with Tobias Oetiker's rrdtool (https://www.rrdtool.org/)
Memorix is an open source next-generation in-memory ORM
A batteries-included MVC web framework for Rust — built on ntex + Floz
The convenience of SQLite – but with PostgreSQL (Library package)
Python Celery-inspired queuing library for Rust, using cron for scheduling and SurrealDB for storing queues, metrics, and schedules
Performance benchmark tool for Postgres queries
Vietnamese Lunar Calendar - Core calculation engine
Core SDK library for model operations across platforms
Compile-time conditional queries for SQLx
Shared types and validation schema for PAI-Kernel governance daemon · enforces growth-signal denylist on KernelContext per PAI-CD v2.2
MoosicBox profiles package
Rust-based utility for comparing the state of a list of tables in an Amazon RDS database with data stored in Parquet files on Amazon S3, particularly useful for change data capture (CDC) scenarios
compare two databases and generate a diff for MariaDB
KIP (Knowledge Interaction Protocol) base on Anda DB
Clickhouse Data Synchronization Pipeline
Apache SedonaDB Rust API
A proxy and pooler for Postgres
Slotted-page heap, B+tree indexes, and WAL for PowDB
Aurora DSQL connector for SQLx
Patient biomarker database CLI — longitudinal tracking, trends, and export
Influxdb 2 client library for rust
The Movie Database (TMDb) API for async Rust
An ADBC connection pool implementation using r2d2
CI pipelines defined in Rust instead of YAML
Universal database-to-PostgreSQL replication CLI. Supports PostgreSQL, SQLite, MongoDB, and MySQL.
Rust bindings to simple, a SQLite3 fts5 tokenizer which supports Chinese and PinYin
Transactional materialized views with incremental refresh for PostgreSQL
An enterprise-grade database abstraction layer for Rust with built-in permission control and connection pooling
Type system for KyuGraph: physical types, logical types, and typed values
client library and CLI for the Infracost Cloud Pricing API
A beautiful TUI SQL editor for PostgreSQL
Constant Quark Database (CQDB)
couchdb follower
HeliosProxy - Intelligent connection router and failover manager for HeliosDB and PostgreSQL
shortcut tool related to database fields
A CLI client for ReductStore written in Rust
A scraper for CVMFS servers
High-performance PostgreSQL vector database extension v2 - pgvector drop-in replacement with 230+ SQL functions, SIMD acceleration, Flash Attention, GNN layers, hybrid search, multi-tenancy…
Claude Code conversation archive tool with SQLite + FTS5
Sync'eM ALL - File/ Screenshot sync application with SFTP support, and web dashboard
Schema validation library and CLI for sentry-options
Careful with That Lock, Eugene
thread-safe, transactional, and concurrent in-memory key-value store for Rust. Offers ACID guarantees with Serializable Snapshot Isolation (SSI) and optional durability via a Write-Ahead Log (WAL)…
Time-series storage engine — Postgres-backed metric persistence, windowed aggregation, and range queries
A fast Rust reimplementation of sqlacodegen: introspect PostgreSQL, MySQL, SQLite, or MSSQL schemas and generate SQLAlchemy models or cross-dialect DDL migrations
Shared Azure helpers for Apache OpenDAL services
Replays applied migrations to rebuild a baseline, then diffs against current models to compute the next migration plan
prkserver is a CLI tool that helps create a backend server in Rust using Axum or Actix Web and SQLx. It configures everything based on a provided config.toml file.
prkserver
config.toml
AbsurderSQL - SQLite + IndexedDB that's absurdly better than absurd-sql
MCP server for SAP HANA database
FlowFabric EngineBackend impl — Valkey FCALL backend
Wayland clipboard manager with fast persistent history and multi-media support
Product OS : Service Handler is a full implementation of the Javascript feathers endpoint framework handling reads and writes to services in the same manner so that a Product OS server is compatible with FeathersJS
SQLite virtual tables for querying cloud object store metadata using OpenDAL
Fleece (binary json) support for serde
Maintain ratings & playcounts for your mpd server
An educational Rust relational database (RDBMS) inspired by CMU 15445
SQLite backend for the dbrest REST API
TypeScript code generator for the Forge framework
Command-line tool for detecting schema drift in PostgreSQL JSONB columns
Persistent Merkle Tree in Rust
Persistent memory engine for AI coding assistants
A modern, real-time database with streaming and analytical capabilities
SQL library
Pure Rust library for reading Microsoft Access (.mdb/.accdb) files
lightweight tool designed for efficiently dumping and restoring MySQL databases. Whether you need to create backups, restore databases, or transfer data between servers.
Knowledge base and temporal experiment tracking for the Soma runtime
A memory engine for conversational AI agents, inspired by neuroscience and Buddhist psychology
interacting with the local and export data of Pioneers Rekordbox DJ software
Format-preserving YAML feature extraction
Data Stream processor written in rust
Logic and datatypes for interacting with VirusTotal
A native, asynchronous PostgreSQL client
TCP/Unix socket server, connection handling, and command dispatch for Kōra
A high-performance memory-mmap hybrid search engine built for AI, combining dense vector, sparse text, graph relations, and JSON metadata
Core types, IDs, config, and utilities for mvm
Faithful Rust equivalents of C# System.Data.SqlTypes with SQL NULL semantics, checked arithmetic, and three-valued logic
Production-ready ORM with migrations, database services, connection pooling, and query builder
sql dialects for sqruff
GraphQL framework for AWS Lambda with SeaORM and multi-tenant support
ODBC ffi bindings
Type-safe request validation for RustAPI. Wrapper around the validator crate with deep framework integration.
validator
Interactive CLI and REPL for VelesDB with VelesQL support
Polyglot code generation backends for scythe
Based on SLED, KV storage similar to Redis, supporting key-value,Maps,Lists,TTL,Counters
Pipeline orchestration library for LMRC Stack with reusable build, test, and deployment steps
MCP server for agent task workflows with phases, prompts, gates, and multi-agent coordination
A good friend for r2d2
Rust atom catalog, phase algebra, and sys handler atoms for Tigrbl
Customizable multi-tier cache with L1 (Moka in-memory) + L2 (Redis distributed) defaults, expandable to L3/L4+, cross-instance invalidation via Pub/Sub, stampede protection, and flexible TTL scaling
redb embedded storage backend for do-memory-core episodic learning system (cache layer)
Fast OpenAPI parser that turns imperfect specs into a stable output schema with actionable diagnostics
Resource Group module: hierarchical resource group management with GTS type system
Core types, storage, schema, and protocol for MQDB
Local GraphRAG memory for LLMs in a single SQLite file
Create permanent-ish environment variables that you can share between sessions
Array abstractions for Apache Arrow
Lightweight durable job execution engine backed by Postgres
Distributed task library for Rust, inspired by pynenc
Ergonomic wrapper for DuckDB - forked from duckdb-rs to add support for duckdb_scan_arrow
bare-bones and lazily loaded database for small projects
下的轻量级 ORM 框架，借鉴了 Java MyBatis 的设计理念，强调 SQL 与业务逻辑分离。它结合 Rust 的类型系统与宏机制，支持编写原生 SQL 并自动映射结果，兼容…
SDK for developing Cortex plugins — tools, skills, and extensions
read Gnucash file
Command line helper for QA workflows
A command-line tool to tail message db
Dynamodb distributed lock client
A native graph database implementation in Rust with built-in JSON support and SQLite-like simplicity
Shared database entity definitions and connection helpers for the microsandbox project
core library to access Tsurugi for Rust
A SQL query builder library for Rust
A SQL compatibility layer that transpiles Trino and Redshift SQL to DuckDB SQL
A PostgreSQL Query Builder
Agnesoft Graph Database Server
wrapper around Client and ClusterClient, like go-redis UniversalClient
A high-performance graph database with Gremlin-style traversals and GQL query language
Automatically connect newtypes to Diesel using their wrapped type
A persistent database table based on b-tree
Provide a User Authentication and privilege Token Checks. It requires the Axum_Session library.
An eBPF Program Manager
Sidecar infrastructure services for mik (storage, kv, sql, queue)
A sqlite-based cognition kit for long-term agent language models
OSIS - Object Storage with SmartID. Distributed, human-readable IDs and object storage.
Driver for Amazon's QLDB Database implemented in pure rust
TUI activity monitor for PostgreSQL — pg_stat_activity, locks, top queries and replication in one terminal pane
Low level DBMS in Rust focusing on datasets
An (unofficial) Rust library for querying db-ip.com data
High-performance async Redis client for Rust with automatic cluster support, multiplexing, and advanced features
A fully generated & opinionated API client for the Slack API
Ave actor model
Compatibility layer for Sea-ORM when crossing a Rust-to-Rust FFI boundary
CLI for Konarr
rbatis ORM TDengine driver
Callable Redis Implementation
A high-performance SQLite wrapper for WebAssembly with OPFS support
AWS SDK for AWS Cost Explorer Service
A high-performance PostgreSQL-backed job queue for Rust applications
High-performance job queue library for Rust using Redis with auto-retry, connection pooling, async handlers, and multi-consumer fair distribution
Fallible Async State Machines
A very simple wrapper to handle locked storage of items
SQL parser fork with Aurora DSQL extensions (CREATE INDEX ASYNC). Based on sqlparser 0.61.0.
Community-maintained Rust implementation of Celery (fork of rusty-celery)
Rust client for the Bank of Japan time-series statistics API
Mnemo MCP memory server — runnable binary; install as cargo install mnemo-mcp-server, run as mnemo
cargo install mnemo-mcp-server
mnemo
Stop dangerous database migrations before they reach production
Wire protocol types and codec for the Iggy binary protocol. Shared between server and SDK.
Personal usage MySQL executor
Pangenome file formats based on SQLite
A drop-in replacement for sqlite3 CLI with enhanced features
that writes to a .dat file as key, value in binary format
配置文件读取与写入
A robust, crash-resistant queue implementation that persists all data to disk using SQLite
A RESP-based in-memory cache server written in Rust, inspired by Redis. Includes a CLI client.
Alpha research ORM for Rust. Facade crate for premix-core and premix-macros (not production-ready).
Initialises postgresql_embedded clusters as root while handing off filesystem work to nobody
Workload-aware blast radius forecaster for PostgreSQL migrations
Derive diesel boilerplate for using enums in databases
Tasker's PGMQ wrapper with PostgreSQL NOTIFY support
An opinionated framework to work with Elasticsearch
Rust-idiomatic wrapper around mongocrypt-sys
A fully defined liberty (std. cells in VLSI) data structure, efficient parser & formatter
The SaaS RS SDK
fast n-ary leanIMT implementation with persistence
Virtual Private Database for PostgreSQL — tenant isolation at the connection level
Analysis utilities for Hamelin query language
Type system definitions for smelt
Database schema parser and language agnostic generator
Rbatis adapter for casbin, support database save and load rules
C++ language plugin for sqry
Persistent cognitive memory for AI agents and robots — Hebbian learning, knowledge graph, spatial recall. Zenoh/ROS2 native. Single binary, runs offline.
A declarative visualization language that extends SQL with powerful data visualization capabilities
SQLite database for MDK that implements the MdkStorageProvider trait
GQLite is a Rust-language library, with a C interface, that implements a small, fast, self-contained, high-reliability, full-featured, Graph Query database engine
A type-safe SQL query builder for Rust
A Kubernetes job orchestrator tool library
A production-grade, cross-platform, single-binary Apache Iceberg REST Catalog
Diff Nix
The sql abstraction layer
providing methods and procedural macros to minify SQL code, optionally at compile time
High-level job queue implementation using fx-mq-building-blocks
A thin ODM layer for mongodb
Connection pooling for SQL Server with sp_reset_connection support
Memory with a Conscience
Blazing fast pure Rust Spatial Bench data generation library
A powerful mock server supported by a plugin system
Stores based on RocksDB for NextGraph
A minimalistic SQLite crate which ships the amalgamation variant and provides a tiny Rust API
FHIR resource validation engine
An extension to rust-postgres, adds support for PostGIS
pure Rust SDK for working with Clickhouse with the native protocol in async environments with minimal boilerplate and maximal performance
Merkle-CRDT graph engine for distributed, conflict-free knowledge graphs
A high-performance CLI tool for indexing and querying Markdown files for AI agent. Obsidian-compatible.
A command-line interface for ScopeDB
PostgreSQL named arguments
Store files in a time or index based directory hierarchy, automatically deleting the oldest files if the size limit is reached
A Tantivy-based indexing server with OpenRPC socket interface
Local-first document database with CouchDB replication protocol support
A distributed transactional key-value database powered by Rust and Raft
Diff changes between JSON schema files
A examination generator library that generates different quiz sets for all students so that each student may have a different quiz set from the quiz sets of the others
Apache Ignite v2 Client
Lookup for MAC Address vendor details
client-side library
Postgres-first async ORM-ish library with type-level loaded/unloaded relations
working with Elasticsearch APIs on Golem Cloud
XML Schema type information
Pure-Rust Bolt v5.x wire protocol library
Cedar policy schema definitions for REX authorization
Custom LSM-tree storage engine with WAL, MemTable, SSTables, bloom filters, and leveled compaction
Rust wrapper for the tap ATProto utility
High-performance graph database engine with traversal algorithms and pattern matching
An orchestrator crate for Mago, coordinating various components to provide a unified PHP tooling experience
Local data persistence for Aranet sensor readings
Columnar in-memory cache for AI/ML inference workloads
Query Kubernetes with SQL
PostgreSQL infrastructure for systemprompt.io AI governance. SQLx-backed pool, generic repository traits, and compile-time query verification. Part of the systemprompt.io AI governance pipeline.
Bolt wire protocol implementation (PackStream encoding, chunked framing, handshake, message types) for Mesh
Parse, manipulate and emit EML_NL documents
mantra offers a lightweight approach for requirement tracing and coverage
mantra
YAML 1.2 loader - Rust binding for libyamlstar
in-memory, write-on-update database that is persisted to an append-only transaction file
Rust client library for Geode graph database with full GQL support
interacting with a filemaker api
Roblox library for Lune
Immutable, event-sourced, nosql, write-side database system
This's a run-time loadable extension of SQLite fts5, supports Chinese and pinyin word segmentation and search
Snowflake-like 64-bit unique ID generator with PostgreSQL BIGINT-friendly i64 IDs
MDQL — a queryable database where every entry is a markdown file
Full-text search infrastructure for Fabryk (Tantivy backend)
dioxus component that provides browser and hardware information
高性能 CLI 工具：流式解析达梦数据库 SQL 日志并导出到 CSV/JSONL/SQLite
Core type definitions for Kimberlite
High-performance event metrics with pluggable storage backends
Cross-platform module for semantic validation of Versa data
Full-featured async (tokio-based) redis connection pool (like r2d2)
A lightweight data sync engine: poll, delta, sink
Vestige orchestration layer — hybrid search and embed ingest over Store + EmbeddingProvider
CLI tool for file management, including compressing, extracting, renaming, and organizing files
B-tree storage engine
validate json schema
Japanese text tokenizer with deinflection support
A Swiss army knife for Claude Code and multi-agent toolkits
SQL database toolkit for Synaptic: ListTables, DescribeTable, ExecuteQuery (read-only)
Core Calimero infrastructure and tools
MariaDB metric exporter for Prometheus
A preprocessor for mdbook to add GraphQL playgrounds
OCI/Docker image manifest, index, and layer types
A real-time comprehensive Mode S and ADS-B data decoder
CLI crate for nils-memo-cli in the nils-cli workspace
Lint SQL files for Aurora DSQL compatibility
Any database. Any form. Zero hassle.
Apalis board contains a number of crates useful for building UIs and apis for managing Apalis task queues
Automatic performance capture and analysis for production applications in Python using a custom columnar database written in Rust
Elegant, clean Rust development framework
Bundled reflection database for Roblox projects
Schema-driven structured similarity for tabular data - the Similarity Contract engine for DistX
meant to make SQL queries simple and communication between various SQL versions easy
Material database and formula parsing for Monte Carlo particle transport
PostgreSQL persistence layer for the Runledger durable job and workflow system
Query-intercepting proxy server for TypeDB with validation and audit logging
A PostgreSQL-backed namespace prefix registry for CURIE expansion and prefix management
reimplementation of LiteDB made for vrc-get
OpenTalk database functionality
Operator and developer CLI for the kiromi-ai-memory store: append, search, snapshot, regenerate, migrate-scheme, gc, audit-tail
Compliance reporting and verification for Kimberlite
A presto/trino client library
Accessing the Engine DJ library database
Idempotent proxy server
Fluvio API for SPU
SQLx for Cloudflare D1
cdb (constant database) format with 64-bit support
Autonomous relational database management system with MVCC, time-travel queries, and full ACID compliance
Content-addressed versioned substrate for AI agent memory - the core of mnem
Plans, tasks, waves, Thor gate, reaper — orchestration engine
TeaQL core, SQL, runtime, dialect, and macro crates for model-driven data access
Convert SQL CREATE TABLE statements from stdin to cargo loco generate scaffold commands on stdout
cargo loco generate scaffold
Directed Acyclic Graph (DAG) structures for query plan optimization with neural learning
Model Context Protocol (MCP) server for SQLRite. Exposes a SQLRite database to LLM agents over stdio.
A thin wrapper around RocksDB
Persistent memory for Claude Code — single binary, zero subprocesses
CLI that ingests Claude Code transcript JSONL files into a DuckDB database for usage / cost analysis
CST parser for the rigsql SQL linter
Durable execution framework — multi-step workflows with persistence, retries, and observability
Shared code for Rex
tibet-zip Transparency Mirror: sled-backed distributed trust database
Enhanced Visitor implementation for sqlparser
Azure IoT Operations Connector
zero-downtime schema migration tool for Postgres
A programmable, ACID-compliant, document-database inspired by CouchDB
A CMSIS-SVD base structures
A thread-safe database pool for running database-tied integration tests in parallel
A high-performance MySQL client
Ratings website that uses Chess style rankings
A light-weight local json database
A terminal-based PostgreSQL monitoring tool with live TUI
Anda DB is a Rust library designed as a specialized database for AI Agents, focusing on knowledge & memory
PostgreSQL performance database insights
Code analysis and security scanning for Qryon
An MCP server for SQLite with fine-grained access control
Foundational library for creating Cedar-based asynchronous authorizers
一个用于逻辑与比较运算的表达式求值库
Binds to official firebird client lib
Language Server Protocol implementation for SurrealQL
SDK for generating invoices in schemas FA (2), FA (3), PEF (3), PEF_KOR (3) and FA_RR (1)
System SDK for building User-Space Capsules for Astrid OS
writing MaxMind DB
A no_std Redis client
法令標準XMLスキーマ対応ライブラリ
Generated gRPC clients for the Yandex Cloud API
Drasi Core
Font database and loading utilities for Typf
DWARF debug information parsing and querying for Rust debugging tools
Command line tool for exporting PostgreSQL tables or queries into Parquet files
ReductStore Client SDK for Rust
CLI for at-rust-go: scaffold, dev, migrate, build AT Protocol API projects
A small library with a limited set of Google Cloud Storage operations
Runtime executors and gateway for the Forge framework
Append-only event log for personal knowledge management with semantic chunking using SQLite
Schema-first database toolkit - migrations, diff, lint, and query generation
working with API requests. Part of Bomboni library.
Interactive CLI tutorial for learning HelixDB
Directory tracker for easy jumping
Perfetto Prost protobuf bindings used by tracing-perfetto-sdk
A Rust-only fork of CocoIndex, a modular, high-performance ETL and data transformation library
DynamoDB Streams business logic and storage engine for Rustack
REC23 CRM
SCIP indexer for PostgreSQL
thin wapper of failsafe-rs to provide circuit breaker captilites to bb8
Shared data types for Swivel source retrieval and chunking
some XSD datatypes for SPARQL implementations
CLI – cozy local databases in seconds
SochDB Kernel - Minimal ACID core with plugin architecture
The history crate for Atuin
Minimal implementation of the Arrow specification forked from arrow2
Typer for sql
A command-line SQL formatter that reads SQL from stdin and writes formatted SQL to stdout
All your history in one file
Hashtree-based app update discovery, artifact selection, and install helpers
Core types and helpers for docx-mcp
Hasura-style GraphQL ORM for PostgreSQL — one SQL per request via json_agg
SQLx MCP Server - Secure multi-database CRUD operations via Model Context Protocol
API-only Database Application Written by Rust
SQL parsing, validating, formatting, and dialect translation library
MySQL driver implementation for SQLx. Not for direct use; see the sqlx crate for details.
Type-safe query builder for the Prax ORM
PostgreSQL connection pool utilities for BES tooling
Layered NNTP download engine: persistent per-connection workers, priority-aware dispatch with cascade-retry, pipelined batch fetching. Pure fetch layer — no decode, no assembly.
Types for storing persistent data about media
EXPERIMENTAL: actor layer for xaeroflux
AHQ Store Developers' CLI
Data-source name (DSN) parser for Gel and PostgreSQL databases
model for tibba
A lightweight, fast and easy-to-use implementation of a persistent and optionally encrypted in-memory database
A Redis-compatible command-line client written in Rust, supporting Redis, Dragonfly, and KeyDB
A Query Check Language written in Rust
Redis Streams messaging layer for Mecha10
A lightweight FoundationDB CLI and helper library for creating spaces, tuple subspaces, and running structured FDB queries. Designed for development.
Pure Rust driver for Oracle databases - no OCI/ODPI-C required
Universal wire format for Shape values - serialization and type metadata
A powerful and easy-to-use PostgreSQL connector for Rust with connection pooling and read/write cluster support
Generate fully typed rust code from your gel schema and inline queries
In-memory SQL database with transaction support, connection pooling, and MVCC
command line tool to count the lines of code in a directory and returns a JSON match to shields.io's dynamic endpoint requirements
Aggregates security advisories from GHSA, NVD, OSV, CISA KEV, and more
Core episodic learning system for AI agents with pattern extraction, reward scoring, and dual storage backend
resilient task execution and orchestration
Redis-backed async job queue for Rust, with optional web dashboard
Types, type aliases and diesel ORM definitions for superposition
Redis watcher for Casbin-RS
Unified Asheron's Call protocol, game data, and CLI tools
bb8 connection manager for Tiberius
Query DSL for Helix Enterprise
WARNING! UNSTABLE AND WILL BE YANKED! Snapshot of official tigerbeetle client before release
Cerememory procedural store implementation
Smart grep over Magellan code maps with schema-aligned JSON output
Client
will expose opinionated debugging stubs most useful for tokio based async programs
LoraDB — embeddable in-memory graph database with Cypher query support
Interface with SQL databases
resilient redis client
a small lib allowing to store callback that will be triggered at a specified date
Quickly compare your SQL data with clarity and style
Tiered storage layer for memos - Memory Management System
Task storage abstractions for Model Context Protocol (MCP) servers - durable state machines for long-running operations
SeaORM storage plugin for Torii
General search parser
TypeScript codegen and manifest types for SeamJS CLI
Access the Gaia ESA Archive for astronomical data
A powerful SQL query builder and ORM for sqlx with CRUD operations
Exporting datafusion query engine with postgres wire protocol
Delta-State JSON CRDT
types and utilities for developing Versa client applications in Rust
Master Patient Index (MPI) - A healthcare patient identification and matching system
Raft consensus for AIngle clustering
The generators for cronus API spec
A database dump utility with pluggable provider support
Snowflake Arrow Database Connectivity (ADBC) driver
A high-performance PostgreSQL-backed URI dictionary service for assigning unique integer IDs to URIs
A command-line interface for interacting with SlateDB databases
client
A development tool for viewing SQL tables in web browsers, easily integrable as an Axum layer
Server client interactions
Buffer and Invocation Record Database - storage layer for shell command history
Database migration DSL for the rok ORM ecosystem
A Postgres proxy with built-in safety features
A fully generated & opinionated API client for the SendGrid API
Auto-generated rust bindings for libmysqlclient
responsible for storing and retrieving data about a user's music library to and from an embedded surrealdb database
Schema representation for panproto
Large peptide database for mass spectrometry
X12 transaction set grammars and schema definitions
Oxigraph RDF store wrapper with named graph support for Geoff
convert JSON schema to EmmyLua annotations
Wikijump API provider and database manager
SQL analytics layer for TX-2 ECS - one-way synchronization from ECS to SQL databases
A generalised API key pool for torn-api
MariaDB UDF bindings for tjson-rs — parse and render TJSON from SQL
Lightweight SQLx PostgreSQL connection pool routing for primary/replica separation
Kubernetes CRDs for cloud-native-pg
Plugin system for Reinhardt framework - easy to create, distribute, and install
Stupendously fast and easy GraphQL Query Language handling
Postgres Data Viewer with powerful CLI and rich data visualization
Typed Rust client SDK for lattice-sql — SQL frontend for lattice-db
Protocol-agnostic API abstraction gateway
gRPC services for Mesh
Idiomatic and safe LMDB wrapper
high-performance Rust implementation of Poker Query Language (PQL), enabling SQL-like queries for poker analysis and calculations. This project is a spiritual successor to the original…
An AI-native embedded database
The invisible database: causal, consistent, and everywhere—without configuration
UTF table format used in CRIWARE CPK files
CLI for parsing, validating, linting and evaluating Sigma detection rules
User and Tenant management for Saas applications
Pure functional expression language for panproto enriched theories
Typed, time-aware IDs built on UUIDv8
Memory and knowledge base for agents
Native bindings to libSQL
My Pet Rust ORM
Drasi Core Abstract Syntax Tree
Core framework: AppState, config, app builder for at-rust-go
HwhKit PostgreSQL integration
SQL transpiler for Polars. Converts SQL to Polars logical plans
TUI for ToDo lists
A high-performance, asynchronous PostgreSQL driver for the Chopin framework
A minimal web application framework with Lua scripting and PostgreSQL integration
Page-level SQLite database access using sqlite_dbpage virtual table
A socket client library for VoltDB server supporting both sync and async operations
PostgreSQL integration for robopoker training and strategy storage
A Tower service for asynchronous Redis request/response performed over a managed, multplexed connection
Asynchronous, HA (master-master) PostgreSQL driver on top of libpq
A self-hosted backend for Deno KV
Rust driver for the Apache AGE. Based on postgres package
DB Movas client in Rust
Priority Queue on Redis
schema-aware wire format with stateful transport
help parse macOS UnifiedLogs
Mesh replication agent for sync-engine nodes
Core utilities and primitives for TempestDB
Tari cryptocurrency wallet library
interacting with Money Manager EX data and logic
Write expressive database migrations in Rust
A pure Rust SQLite reader library for WASI environments
External integrations for mcpr: cloud event sink, API client, and SQLite request storage
Fast, self-hosted query engine for structured JSON logs
A generic GraphQL-to-SQL OLAP query engine library
web framework inspired by ExpressJS with ORM support for MongoDB, MySQL, SQLite, and PostgreSQL
Embeddable high-performance analytics database
Porcelain for adding metadata to any git object without rewriting history
Deneyimsel bir sql yardımcı küfesidir. UYARI: bu bir ORM aracı değildir. Amaç sql yazımı ve kullanımında basit cümlecikler için kolaylık sağlamaktır.
Shared components for tasker orchestration and worker systems
inspecting the contents of a flake
Core traits and logic for modular transactional outbox pattern in Rust
Mecha10 core runtime and foundational types
Derive macro for generating DTOs, repositories, and SQL from a single entity definition
Schema library for SpacetimeDB
pgbaits 用于操作数据库数据的增删改查
Disintegrate PostgresDB implementation. Not for direct use. Refer to the disintegrate crate for details.
disintegrate
Runtime support crate for FlowLog — re-exports timely/differential-dataflow and provides helpers used by flowlog-build-generated code
A CLI for PocketBook that preserves notes and highlights after EPUB metadata edits by relinking the old file hash to the new one in the device databases
Apache Parquet Variant Batch Processing
Conveniently inspect an SQLite database file in the terminal
A client library for the EventsourcingDB by the native web
Shared libraries and utilities for Nitrolaunch crates
TypeDB database integration for DogRS - adapters, utilities, and TypeQL query builders
Composable SQL builder and argument collector
rust infras
framework for elegantly configuring complex applications
An in-memory database that replicates a reasonable subset of Postgres functionality to make unit tests that rely on a database to run
A persistent B+ tree using freqfs
SQLite VFS with sub-50ms cold queries from S3 + page-level compression and encryption
Core SQL parsing, catalog building, and type inference for scythe
Real-time token usage monitor for Claude Code (cc) with cost tracking
that provides some queries for the drug central database
Core engine for Kafka backup and restore operations with point-in-time recovery
Official Rust SDK for WOWSQL - MySQL Backend-as-a-Service with S3 Storage
Efficient Rust library for calculating optical response of metallic nanoparticles using Drude model and Rayleigh approximation. Supports Au, Ag, Al materials.
Core library for syncing and scoring health data from Garmin Connect and Intervals.icu
Fuzzy URL opener for the terminal
All in one (aka Aio) database with async support. Based on sqlite, bevy_reflect and tokio, includes a dead simple API to be used (no SQL needed just pure Rust). Comes with automigration.
Lightweight, Flyway-compatible PostgreSQL migration library
An in-memory graph database
A schemaless, high-performance database written in Rust, designed for speed and scalability
downloading and extracting PostgreSQL archives
FUSE filesystem backed by a postgres database
VelesDB mobile bindings for iOS and Android via UniFFI
Agent-friendly token efficient SQL Server CLI tool for database inspection
Redis Vector Library
reading and writing PostgreSQL dump files
MySQL support for the r2d2 connection pool
Analyze SQL
wrapper around some key-value storages
Genome annotation based on Rust and RocksDB
bundled libsqlite3 library
Core library for the Agent Orchestrator — task scheduling, runner, and persistence
PostgreSQL metadata storage backend for Hardy BPA
functions for managing SQLite connections in a server application
SBO3L storage: SQLite persistence + hash-chained audit log
Pulse Control Plane — API key management, region routing, and project orchestration
Minimal safe Rust implementation of ODBC
Database provider implementations for Kyomi Connect
Connect to Snowflake
A refreshingly simple incremental computation library
Turso/libSQL async database driver for rbdc
Git-style visual diffs for SQLite databases. Inspect, compare, snapshot, and generate SQL migrations.
Low level Postgres protocol APIs
Core library for Star Wars galaxy exploration, search, routing, and unknown-planet workflows
Rust support for reading and writing the LCM data format
term hashmap used for indexing
A lightweight local job queue backed by SQLite
TDS 7.4 server for Iridium SQL
Parse, validate, and convert Common Query Language (CQL2) text and JSON
Diesel ORM backend for libSQL (Turso) — local, remote, replicas, async, OpenTelemetry
Immutable collections, schema hooks, and federated search for hashtree
REST API client for KPN Data Services Hub
Pure Rust library to read and write CDB files
SQL query extension library for handling pagination and sorting in relational databases
cli tool for open.go.kr
Docbox core business logic and functionality
A high-performance, multi-dialect SQL Language Server Protocol (LSP) implementation in Rust
Async rqlite client for Rust
schema for the CodeTracer db trace format
Data processing and transformation pipeline
Schema-validation of CityJSON/Seq datasets
follows clean architecture principles and provides a DynamoDB store implementation
Trust Registry
Type-safe SQL builder for Postrust
Experimenting with a simple Mongo-backed caller/worker bridge that keeps tracing context alive
🧭 A GraphQL framework for SeaORM
An abstraction layer on mongodb
Velr native runtime for Linux x86_64
SQLite-backed per-origin permissions store for buffr
Storage abstraction and implementations for ironflow run tracking
ElasticSearch Query Builder
Rust bindings for the ELSTER Rich Client (ERiC)
Database modeling engine: conceptual (ER) to logical (relational) transformation and SQL DDL generation. A Rust reimplementation of the core engine of brModelo.
ActiveRecord based on SQLx for Postgres
Boot helper + extension setup glue for lex hosts (lexd CLI, lexd-lsp). The future home of Engine::builder() for embedders.
Tansu protocol services and layers
consuming ScyllaDB CDC log for Rust
IntelliWallet Core - Password manager library with AES-256 encryption
Blazing-fast Go type system service —— Vibe Coding toolchain
a type-safe, ergonomic interface for performing CRUD operations on Amazon DynamoDB tables
A small async database facade for MariaDB/MySQL, Postgres, and SQLite
Convex to Rust code generation CLI for type-safe Rust clients
Error-recovery SQL parser for smelt data transformation framework
Zsh-compatible completion system for zshrs — SQLite FTS5, menuselect, zstyle
A CLI for fetching and visualizing MongoDB diagnostic data
Official Rust client library for ekoDB - A high-performance database
Contract manifest types, validation, and digest utilities for Trellis
Key-value storage for Synaptic agents: Store trait and InMemoryStore
DIAL engine - Deterministic Iterative Agent Loop for autonomous AI-assisted software development
high-performance multiplexing bridge between MCP (Model Context Protocol) and LSP (Language Server Protocol). Enables LLMs to access IDE-grade code intelligence across multiple languages…
Rust bindings for tracker
An experimental table format with extensible index support
netidx embeddable database
Efficient local storage and Amazon S3-compatible data synchronization for time-series data, leveraging Parquet for storage and DataFusion for querying, all wrapped in a simple and intuitive API
AWS DynamoDB utilities for Rust
Protobuf schema for running-process daemon IPC
Migration utility for SeaORM
Passive JSON schemas for VT Code utility and file tool surfaces
Parsers and tools to interact with iMessage SQLite data
Firefox Application Services
A complete library to interact with Firebase Realtime Database (protocol v1beta)
fast, plug and play firestore lib
OpenAPI support to Loco framework
Unified public API for the horsies task queue and workflow engine
Self-describing binary trace format with schema registry
Extract Postgres locks from a given SQL statement
Passive audit sinks for Gaze metadata-only redaction logs
A flexible, human-friendly query language for searching and filtering structured data
An ORM framework with a usage style similar to Linq, supporting Sqlite, PostgresQL, MySQL, MSSQL
A lightweight, thread-safe temporary data storage system designed for efficient handling of transient data in Rust applications
Revolt Backend: User Presence
A lightweight, high-performance embedded database written in Rust with ACID guarantees
XBRL parser and validation
Apache Paimon
A complete library to interact with Cloud Redis (protocol v1)
working with ArangoDB APIs on Golem Cloud
SQLite persistence provider for WFE
AWS SDK for Amazon NeptuneData
Redis IO plugin for Polars
ADBC FFI and driver exporter
A self-hostable observability and analytics platform for LLM applications
Persistent SQLite storage for NexCore Brain working memory
Key-Value storage layer for TempestDB
A lightweight and simple ORM for Rust built on top of sqlx
HighConcurrency, RealTime, InMemory storage inspired by erlang mnesia
Settings for opentalk-controller
WAE Database - 数据库服务抽象层，支持 Turso/PostgreSQL/MySQL
Django-style database layer for Reinhardt framework
A thread-safe vector database for model inference inside LMDB
A trait and derive macro for mapping Rust types to MongoDB collections with automatic pluralization
🌍 A CLI & library for decoding IP addresses into state, postal code, country, coordinates, etc without internet access
OpenTalk caching of redis data in local memory
Domain-neutral trait surface for structured marking schemes (lattice + constraints + projection + local ambiguity)
Create Stripe-style prefixed database IDs that are type-safe and portable
Shared utilities and types for Things 3 integration
A JSON query language for filtering, transforming, and validating JSON documents
Polyglot persistence layer for Helios FHIR Server
A native PostgreSQL interval type
Secra backend framework with lifecycle, config, and integrated SDK utilities
Prometheus Rust exporters base crate with optional boilerplate
Persistence layer for a shop system
Safe SQL for Rust — if it compiles, the SQL is correct
Runner abstraction for executing Lutra programs
PostgreSQL support for vitrail
client for GreptimeDB gRPC protocol
A super simple, embedded, encrypted database like SQLite, using pipe-separated files and age encryption
A high-performance, memory-safe key-value store
SQL database plugin for elizaOS - Rust implementation with PGLite and PostgreSQL support
Tiny, strongly-typed data mapper for SQLite
A connection pooling library for ClickHouse in Rust, built on top of deadpool
Async Rust client for Mapepire — Db2 for IBM i over secure WebSockets
A personal library manager CLI written in Rust
100% openCypher-compliant graph database with Python bindings
Safe Rust re-implementation of libmagic
Architecture Checker — Rust-based multi-language architecture linter
CLI for the Diesel crate
Core async search engine library with WASM support
A RRDCached (RRDtool) client library
GitQL parser
Shared SDK for model operations across platforms (API, WASM, Native)
(進化) - GitOps-native database migration operator for Kubernetes
Safe Rust wrappers for BLPAPI session, request, and response primitives
Core traits and types for Terraphim haystack integrations
Cognitive layers: structured XML specifications with version control and machine-verifiable traceability
Flat file database
一个中国节假日工具，可自动调用互联网开放节假日API（接口坞），生成包含PostgreSQL或MySQL的表结构+INSERT语句的SQL文件，用于每年年底国务院发布第二年节假日信息后…
Autonomous thought tracking and knowledge management for AI systems
PartiQL Logical Model
rqlite database client with optional extra convenience
knowledge base implementation for rust
PostgreSQL schema-as-code management tool
Protocol definitions for the Graft storage engine
Oracle Rust SDK for the NoSQL Database
analyzing data lake table health across multiple formats and storage providers
Lift migration parser and CLI tooling
SQL REPL for Data Frames
AWS SDK for Amazon EventBridge Pipes
Codebase context engine for Claude Code
Database Query Tool with Deadpool. Query Wrapper Tool. Orm Tool
command-line tool for managing and operating Redb databases. It provides various commands to create, delete, query, and edit database tables.
Command-line interface for the geodb-core geographic database
A high-performance, thread-safe RocksDB wrapper
Async ORM for TypeDB built on type-bridge-core-lib
High-performance embedded vector database for Browser, Node, and Edge
Prefixed identifier library
Diesel adapter for casbin-rs
Implement Create, Read, Update, and Delete (CRUD) methods for sqlx
Dead simple async pool utilities for sync managers
Generate rust/typescript codes from schemas specified by Yaml/JSON
Backend for Zenoh using InfluxDB v1.x
Storage backend for Raphtory
DuckDB database driver for RBDC
High-performance Kafka streaming toolkit with advanced filtering and transformation
C2A TlmCmd DB data model
Configuration crate for Cortex Memory system
Virtual Backend Reality engine - stateful mock servers with persistent virtual databases
PII analyzer and anonymizer for dbmcp
A generic API for interacting with key-value stores that can be selected at runtime
A Nushell plugin for querying Google BigQuery
Database migration engine for Nautilus ORM
Part of the Ora scheduler framework
Add dtrace probes to Diesel connections
A framework for building SQLite extensions in Rust
Async PostgreSQL LISTEN/NOTIFY pub/sub client built on tokio-postgres
High-performance Redis client for Rust with multiplexing
Background task processing for Rust applications with Tokio, Diesel, and PostgreSQL
write CSV/Arrow/Parquet files concurrently
Intermediate Representation types for Datalog query plans
AWS SDK for AWS RDS DataService
Hand-written recursive descent SQL parser
Zero-overhead, compile-time MSSQL service for Rust — stored procedures, async CRUD, connection pooling, static dispatch
Command-line interface for Aegis database
Abstract data persistence in a safe and unified way
aim of this project is to deliver a swiss army knife module to aid software engineers for building full stack solutions for their applications. Utilizing the Rust programming language…
decoding and encoding Waveform Database format files
Event store built for Dynamic Consistency Boundaries
Rust in-memory engine for Tigrbl with row-store and column-store strategies
Embedded event-sourcing framework built on eventfold
Parser for sql
A helper package for quickly setting up an influxdb client from environment variables
Universal database CLI for connecting, querying, exporting, and syncing across multiple database engines
A terminal ToDo application
Canonical tickerforge YAML spec tree for Rust (same content as the Python tickerforge-spec-data wheel)
SQL dialect definitions, backend capabilities, and dialect-aware CST printer
MoosicBox json utilities package
A directed graph workflow system in Rust
The server of PoloDB, compatible with MongoDB
Semantic analysis and name resolution for KyuGraph Cypher queries
in-memory graph database
Abstraction over multiple key/value storage engines that supports transactions
CKM (Codebase Knowledge Manifest) — pure Rust core library. The SSoT for all language wrappers.
Reader Writer Concurrency Setup for Sqlite3
General purpose tools for axum web framework
High-performance Redis-compatible server on redb with vector database support
A synchronous pure rust database driver for SAP HANA(TM)
Type-safe SQL generator for Cloudflare D1 + Rust
Kubernetes CRD bindings for CloudNativePG
A comprehensive development tools UI library
Virtual filesystem abstraction layer
Unofficial rust implementation of the Iceberg table format
Agent-First CRUD store MCP server — 1 daemon per table, schema.yaml driven, SQLite backend
HelixDB is a powerful, open-source, graph-vector database built in Rust for intelligent data storage for RAG and AI
An micropb-powered crate for working with OpenTelemetry Protobuf types and OTLP-gRPC
pgsql
Interact with the Exoware API in Rust
Xugu driver implementation for rbatis. The Rust SQL Toolkit and ORM Library. An async, pure Rust SQL crate featuring compile-time Dynamic SQL
PostgreSQL adapter for Seesaw event-driven runtime
Interactive REPL and CLI for PowDB
Execution runtime control plane and repositories for Oris
Go code generator for Styx schemas
CLI tool for Sentinel ORM — migrations, codegen, and schema management
Code generator for ferriorm ORM - generates type-safe Rust client code
Core types, traits, and error types for contextdb
detector backend
Fluvio API for SC
Core library for sql-to-csv: SQL dump parsing, DDL conversion, and CSV/TSV emission
transforming geospatial data using DuckDB and ingesting it into a PostGIS database
A SQLite extension which uses Graft to replicate to and from object storage
DB2 connectivity using CLI Driver
A terminal-based Todos + Pomodoro timer written in Rust
Tagged event-stream queries over atomr journals
On-premise database agent for Kyomi — connects your data warehouse securely
interfaces with an articles database
S3-compatible BlobStore implementation for searchlite (AWS S3, R2, MinIO)
Core types, traits, and pattern engine for reflect
orm database mysql mssql sqlite
A database schema converter and migration engine for MySQL and PostgreSQL
Rust wrappers for the NoSQL database YottaDB
SQLite persistence for Evolve (projects, configs, experiments, sessions, signals)
A database benchmarking tool for Apache Cassandra
RocksDB bindings for Rust
enhance SeaORM
API for building custom transforms
A Zero-Overhead, Type-Safe ORM for Rust that runs optimized SQL
Pure calendar/RRULE expansion library
SQLite database adapter for better-auth-rs using Diesel ORM — compile-time verified queries, 65 methods across 10 traits
PostgreSQL companion for teams not using Rails or Django. Migrations, introspection, diffing, and more.
Asynchronous handle for rusqlite library
Security vulnerability auditing for Python packages
Shared database capabilities for Miden node
A duplicate of trace obfuscator implemented in the agent and documented in https://docs.datadoghq.com/tracing/configure_data_security/?tab=net#trace-obfuscation
Database ORM with relationships and migrations for Oxidite
Deterministic Greentic capability resolution helpers
A high-performance PostgreSQL client
Redis client abstraction for the Fabryk knowledge fabric
A personal database for data sovereignty with AI-powered ingestion
CLI for Garmin Connect API - activities, health metrics, and more
Mongo Rust driver built on top of the Mongo C driver
Client for the ElasticSearch REST API
Pluggable storage backends (memory, file, PostgreSQL, NATS) for AI agent state and threads
Expression evaluation for Hamelin query language
LMDB bindings
Database layer for the Meritocrab reputation system
A tiberius-compatible API bridge over Microsoft's mssql-tds crate. Migrate from tiberius with minimal code changes.
Content-addressable store for .bit documents
Key-oriented log database built on SlateDB
Core library for Floe, a YAML-driven technical ingestion tool
that provides a macro for generating type-safe database ID types for SeaORM
Rust OLTP CRUD and bulk handler semantics for Tigrbl
internal: sqlxo trait definitions and DTO types
Async ClickHouse client using the native TCP protocol with LZ4/ZSTD compression and TLS support
Salesforce Apex language plugin for sqry - semantic search with platform-specific metadata
A spatial memory palace for AI agents with semantic vector search, knowledge graphs, and MCP tools
Database abstraction layer for Zeph (SQLite and PostgreSQL backends)
Columnar storage engine for KyuGraph with buffer management and S3 support
CLI utilities for handling RDF Linked Data with Taganak
MySql protocol primitives
Routa Harness Monitor - multi-agent control plane with task/run/workspace/evidence domain model, policy evaluation, and real-time TUI
Tamper-proof audit logging system for LLM workflows with hash chain integrity
CLI for VecLite
agent framework with LangChain-compatible architecture
A high-performance, latch-free log-structured storage layer built for modern flash storage and multi-core systems
Core runtime for loading and executing Interstice WASM modules
AWS SDK for AWS Application Discovery Service
Database abstractions used by the Omry backend
Database implementations for StateSet iCommerce
Shared error types for the Kotoba ecosystem
Shared contracts for rdump CLI, SDK, and MCP surfaces
In-memory DMBS that store datas in thread
Wire protocol (RESP-like) for GrumpyDB — shared between server and client drivers
MongoDB ODM for Rust inspired by Mongoose
Concurrent/Parallel SPICE (HSPICE) parser, under building
PostgreSQL database schema parser and DDL generator with PostGIS support
Distributed ID generation — HeerId (64-bit) and RanjId (128-bit UUIDv8) with configurable precision
Local datastore for persistent AI agents with graph, vector, and full-text search on SQLite
Embedded graph database with Cypher queries — no server, no subscription, no cloud
TQL language implementation for TempestDB
SQL Server to Rust type mappings and conversions
AINL graph-memory substrate - agent memory as execution graph
Infinite Skills. Finite Context. - Unified MCP server aggregating tools and skills with 99% token reduction
Declarative data validation engine using invariants executed on Polars DataFrames
test sqlx with PostgreSQL and MySQL. It will automatically create a database and drop it after the test.
Sigma rule conversion engine — convert rules to backend-native query strings
A lightweight Language Server Protocol (LSP) implementation for DBML (Database Markup Language) files
Fork, simulate, and merge engine for ClawDB agents
L2 services for ArkheForge Runtime: projection observer, manifest loader, policy, rate limiter, audit receipts, crypto-erasure coordinator, process-protection shim. Builds on L0 arkhe-kernel + L1 arkhe-forge-core.
Plugin to add support for uuids in sqlite
Provide a redis client and cluster client pools
Bidirectional relay binary for pg_tide — bridges outboxes/inboxes with NATS, Kafka, HTTP webhooks, Redis, SQS, RabbitMQ, and more
Terminal-first AST dependency graph and session memory engine for AI coding agents
High-performance vector database & RAG memory layer - hybrid search, embeddings, RAPTOR trees, BM25 fusion, and semantic retrieval for AI systems
Shared layout engine that produces a LayoutPlan from a Diagram
Generate Rust structs from database schema introspection
Client for typesense
Clinical notes & timeline CLI — longitudinal patient knowledge base
Crontab types package for graphile_worker, a high performance Rust/PostgreSQL job queue
Extensible SQL Lexer and Parser with support for ANSI SQL:2011
Types for using ahnlich_client_rs AI proxy and in-memory vector DB
Postgres-backed Web APIs
Next Generation ORM based on sqlx
External system connectors for LaminarDB - Kafka, CDC, lookup tables
Chroma-provided crate for api-types used in the Chroma API
Ontology semantic layer for SparrowDB
Event log and state persistence for CLASP routers
Lib for mairie360 APIs
OS level monitor for recording window focus and input events from os_monitor
Rust port of EPICS std module (epid, throttle, timestamp records)
Fast columnar computation engine powered by a zero-dependency C17 core
Proper Elasticsearch exporter
tui for sqlite
Fundamental types, traits, and protobuf models for denokv
Generated Rust SDK crate for trellis-sdk-auth
Async HTTP client for Bunny.net Database SQL pipeline API — native and WASM (Bunny Edge Scripts)
Database layer: SQLite and PostgreSQL pool and migrations for at-rust-go
Storage abstraction for MDK that wraps OpenMLS storage backends
static analysis engine for TypeScript and JavaScript
Binary format types and serialization for the Icechunk storage engine
Velr embedded property-graph database (Rust driver, beta)
Rust client for Apache Spark Connect
SeaORM integration for paginator-rs with entity pagination support
OpenTimeline CRUD
GeekORM Commmand Line Interface
A boilerplate eliminator for rusqlite
Distributed locking as a service — one binary, simple HTTP API, SQLite persistence, optional GitHub OAuth
Rusqlite OLTP backend for Rhei HTAP engine
JMESPath is a query and transformation language for JSON
Client bindings for Noria
Standalone vector database with SQL, SPARQL, and Cypher - powered by RuVector WASM
RPC framework with Redis-based logging, configuration, error storage, and MCP client support
Kubernetes operator for pgroles — reconciles PostgresPolicy CRDs
Apache Cassandra database driver for Prax ORM - pure Rust async driver via cdrs-tokio
Embedded local database engine for ClawDB — an agent-native cognitive database
OTLP ingestion worker for Cloudflare Pipelines and AWS
REST API bindings for Feldera
async large file database/cache
Flyway-rs project, Database change control,similar to flyway in Java
JSON Patch (RFC 6902) library and CLI with optional schema-aware paths for stable array element addressing
Reusable Postgres + DuckDB database infrastructure: connection pooling, caching, batch operations, and migrations
experimental LRU store
postgres 数据库快速连接方法
TypeDB Protocol
KnowDB loader and SQLite-backed query facade for the Warp Parse stack
Testing helpers for the redis crate
redis
Read Write Delete (block u8: key, data) to bucket file
Key-Value capability for use with crux_core
Turso SDK kit
A user-friendly library for interacting with debugging information of Rust compiled artifacts using DWARF
Terminal TUI to select Claude Code providers from cc-switch and launch claude
CLI utilities for Vantage data framework
Virtual database engine bytecode interpreter
A Yesql inspired macro for using SQLite SQL in Rust
Command Line Client for DataFusion query engine
The daemon crate for Atuin
distributed database that uses the flake algorithm to generate unique IDs
Memvid-backed persistent memory and lexical store for Rig agents
Databend Native Command Line Tool
Fortress Core Library - Enterprise Security. Core library for Fortress secure database system with multi-layer encryption.
Official Rust client driver for Skytable
argon2id bearer verification + scope enforcement + ApiKey store (Auth Path 2, alpha.5)
GraphQL function implementations for Drasi
Self-hosted REST API server for MemMe memory engine
PostgreSQL 16 DDL to SQLite3 DDL schema converter
GP2-based Graph Rewriting Language - ISO GQL-compliant queries, MVCC+Merkle persistence, and distributed execution
Thin wrapper around SQLx that emits OpenTelemetry spans and metrics following the database client semantic conventions
OpenTimeline web API
EdgeBase Admin SDK — server-side admin operations
Static analysis tool for SQL queries with 20 built-in rules for performance, security, and style
Write-time validation for AI-generated code — catches hallucinated imports, wrong signatures, invalid enums
Limbo series extension
Native OpenAPI 3.1 specification generator for RustAPI. Integrates Swagger UI.
A CLI tool for interacting with Feldera
Query an ODBC data source and print the result as csv
Confluence document loader for Synaptic
Column, expressions, functions, and UDFs for robin-sparkless (Polars-based)
Kellnr is a self-hosted registry for Rust crates with support for rustdocs and crates.io caching
Official Rust SDK for Nexus graph database
Rsync-based file transport between mesh nodes
General-purpose Postgres-backed multi-site content and custom data storage
Schema Guard: Relation Database (Schema) Management tool
easy migrator for Turso
Structured error types for FrankenSQLite
Core types and database models for SparkTest
A database Table implementation and friends
Core scheduling primitives for Zart — task polling, skip-lock, and storage backend abstraction
Proxy layer between ScyllaDB driver and cluster that enables testing ScyllaDB drivers' behaviour in unfavourable conditions
Use-case agnostic utilities for redb, featuring sharded roaring bitmap tables
Embedded SQLite storage layer for the Otelite OTLP receiver
Always-on memory agent for Nexus Memory System
Streaming JSON query engine for Postgres 17
Command line client for the MarpleDB API
Cross-platform secret store for Common Agent Runtime
A modern, keyboard-first PostgreSQL CLI
Google Cloud Spanner backend for SeaORM
storage engine
A lightweight wrapper for database operations based on sqlx, enabling fast CRUD operations
Manages models/migrations directories and naming-case preferences
sharded bitcask key-value storage optimized for NVMe
Well documented and easy to use RethinkDB Rust Driver
A lightweight, comprehensive and familiar database driver for the SnowflakeDB written natively in Rust
Danube messaging core types and traits
KV-storage engine based on minimal perfect hash functions with optional PGM indexing for Rust
CLI client for IndraDB
Typed, async PostgreSQL driver for Tokio that speaks the wire protocol directly
Shared workflow domain model (types + store traits) for the assay workflow engine, auth layer, and dashboard
Page cache and journal management
Pulumi schema reader
Planning, apply, and state engine for Alembic
Docbox database structures, logic, and migrations
Core library for AiMem — give your AI a memory. Hybrid search + knowledge graph over Turso.
SQL query builder for Reinhardt framework
Safe and idiomatic SQLite bindings
Convert Rust values into SQL Server-compatible literal expressions, enabling dynamic SQL generation without parameter count limitations
A complete library to interact with SQL Admin (protocol v1beta4)
Replication protocol for libSQL
Command-line utility for SQLx, the Rust SQL toolkit
Macro-based Rust ORM focused on developer ergonomics
Persistence layer for the Replay event sourcing library (PostgreSQL and in-memory backends)
Costs extension crate for GroveDB
Small shared helpers for generating checked-in OpenAPI YAML from typed FastNEAR service DTOs
FlowFabric core types, partition math, key builders, error codes
Define database schema's as HCL files, and generate idempotent SQL migrations
Write Ahead Log(WAL) implementation using tokio
Database-agnostic core for the dbrest REST API
SeaORM-based database core utilities and repository abstractions
A modular sync and async client for the Elasticsearch REST API
A high-level, type-safe MongoDB model implementation
SQLite loadable extension for Honker. Adds honker_* SQL functions (queues, streams, scheduler, pub/sub) to any SQLite client.
extentions and utilites for working with postgres
Low-level protocol implementation for Gel database client. For applications, use gel-tokio. Formerly published as edgedb-protocol
Redis-based idempotency provider for the oxide-outbox
Define CRUD microservices in Rust — deploy with a single command
SurrealDB migrator
PostgreSQL storage backend for Mnemo
HTTP server for the Omnigraph graph database
Core types (Token, Span, Segment) for the rigsql SQL linter
PostgreSQL storage backend for zopp secrets manager
SQL abstract syntax tree node types
SQL template engine that composes reusable SQL fragments with parameterized bindings
Rust-based client for comparing the state of a list of tables in an Amazon RDS database with data stored in Parquet files on Amazon S3, particularly useful for change data capture (CDC) scenarios
open-source job queue library. It ships as a Rust crate that drops into any project. No broker, no sidecar, no managed service, no signup. The only dependency is a Postgres database…
help export a YNAB budget to a database
Compile-time guarded ORM for PostgreSQL — your data's guardian from compile to production
FFI bindings to LevelDB
VegaFusion SQL dialect generation and connection implementations
Private crate for the streaming execution engine for the Polars DataFrame library
quick microservices in Rust
Rust client for comparing two PostgreSQL databases
AWS SDK for Amazon Neptune Graph
Shared benchmark infrastructure for vibesql benchmarks
A CosmosDB-based provider implementation for Duroxide, a durable task orchestration framework
A regex extension for rusqlite
rustls-backed TLS for tokio-postgres without a required crypto backend
Persistence layer for Sage agent checkpoints
LanceDB embedded vector store for Synaptic — serverless embedded vector database
Core engine for RabbitMQ backup and restore operations
handling Abstract Syntax Tree of OCA bundle
Core library: config, models, database layer for riley-leaderboards
A fast, keyboard-driven PostgreSQL client for the terminal
Diagnostics node that publishes Docker and system resource metrics
一个高性能的达梦数据库 sqllog 日志解析库，提供零分配或低分配的记录切分与解析功能
flexible database connection library for Rust based on SeaORM, supporting PostgreSQL, MySQL, and SQLite with configurable connection pooling
Per-key stats, hot-key detection, and memory attribution for Kōra
An experimanntal redis like Key-Value-Store client and server
Rust bindings for the TDB database library
Sql Entity Graph for pgrx
pgrx
A caching service for your cli commands using redis
SeaORM ToolKit
Databend Client for Rust
A oci database adapter for diesel
NPS — Neural Communication Protocol frames (AnchorFrame, DiffFrame, StreamFrame, CapsFrame, HelloFrame, ErrorFrame)
A TUI for accessing Teleport databases
A fully typed LMDB (mdb.master3) wrapper with minimum overhead with support for encryption
Conformance test suite for rakka-persistence journal and snapshot implementations
SQLite persistence layer for Zakat ledger and event storage
Schema definitions for Falco events
Redis based background jobs queue
registering JSON objects in PostgreSQL with canonicalisation and caching
Highly opinionated Axum helpers
PostgreSQL client configuration and connection management
Core types, traits, and configuration for the Apiary distributed data processing framework
Command line tool to interactively query SQL databases
Rust protobuf bindings for GreptimeDB APIs
Rust parts of the PowerSync Tauri SDK
Error types for FraiseQL v2
Small migration tool for relational databases
Velr native runtime for macOS universal
A SQL database browser with TUI interface (SQLite & PostgreSQL)
Workspace management library for indexing, search, and sync of file-based documents
PostgreSQL runner for Lutra
A easy and simple library for interaction with DynamoDB
MySQL-family storage backend for the Philharmonic substrate, using sqlx. Targets MySQL 8, MariaDB, Aurora MySQL, and TiDB with LCD-compatible SQL only.
Apache Iceberg Rust REST API
Central signal processor coordinating all Brain OS subsystems
clients for different databases with lightweight interface
Standalone background processor binaries for the Affinidi Messaging Mediator (Redis-only, horizontal scaling)
Nautilus ORM command-line interface
SQL engine backed by the Exoware API
Rust interface to MPD using libmpdclient
A storeable vec
Built-in operators and combinators for Pulse dataflows — map, filter, join, window, and custom processing logic
Array data abstractions for Apache Arrow
Official Rust SDK for HyperspaceDB gRPC API
SDK of KIP (Knowledge Interaction Protocol) for building sustainable AI knowledge memory systems
Cube.js pre-aggregation storage layer
snowflake-rs fork: cancellation, async, streaming, multi-statement, bind params, structured types, retry middleware
Cognitive memory engine for persistent AI systems
Prefect CLI - a fast Rust CLI for managing Prefect deployments and flow runs
LLM-powered long-term memory engine — Rust core with Python bindings
Transport implementations for Plexus RPC: WebSocket, HTTP/SSE
cross-platform CLI tool to track working hours, lunch breaks, and calculate surplus time
A lightweight, high-performance embedded database for Rust
WASI bridge for ReifyDB test suite
Point-in-time recovery tool for Deno KV
pib-service core datatypes
Rust port of the Firebase JS SDK
Terminal UI dashboard and CLI for Rhei HTAP engine
CLI and runtime for the Forge full-stack framework
AWS SDK for Amazon DocumentDB with MongoDB compatibility
Unified client library for Redis, PostgreSQL, MQTT, Mycelium, Hetzner, HeroDB, and OpenCode
OpenTelemetry-compatible tracing instrumentation for SeaORM database operations
Easily store and retrieve data from TiKV with a derive
CLI for the Engram AI agent memory system
Unified telemetry system for monitoring and observability
Common utilities and types for SpireDB
Generates the schema of all tables in msql as a structure
High-performance tiered sync engine with L1/L2/L3 caching and Redis/SQL backends
JSON Schema validator
Macro-first SQL toolkit with compile-time checked queries, optional migrations on top of sqlx
Ultra-fast Rust client for ContextLite - the high-performance context engine for retrieval and AI applications
public ledger server tools and services (for the PLC)
强大的跨数据库ODM库，支持自动索引创建、统一接口和现代异步架构
SQL-first cross-language type-safe code generator — core library
Database driver boundaries for TSQL
An SQLite implementation of an event repository for cqrs-es
Database Build System
Dead simple async pool for rusqlite
The core library for the Outer Wilds Mod Manager
Database layer on TiKV with indexing, relationships, transactions, and built-in transactional outbox with partitioned scheduled pub/sub with consumer groups
Single-file, low-level and space efficient storage engine with filesystem-like API
Knowledge storage, retrieval, and graph infrastructure for cognitive systems
Traits et helpers génériques pour jointures parent/enfant
Native validation with portable schema interchange
SQLite storage backend for mi6
A GraphQL validator
A generic framework for on-demand, incrementalized computation (experimental)
Exposition for metriken metrics
Command-line interface for AxiomSync data runtime
Blazingly fast, async-first, multi-database ORM for Rust (PostgreSQL, MySQL, MongoDB)
Grep-like CLI with hybrid semantic and keyword search
Friendly Rust types for working with Cap'n Proto CodeGeneratorRequest schema data
Oracle PL/SQL language plugin for sqry - semantic search with Oracle-specific metadata
The jq of Parquet. Inspect, transform, and operate on Parquet files from your terminal. S3, GCS, Azure support. CLI tool.
The package provides SQLite
Core of SQLx, the rust SQL toolkit. Not intended to be used directly.
— SQL-first Reverse ORM for Rust, Built for the greater DX and for the AI Era
Message queuing backend for Rust using apalis and Amqp
A versatile Rust toolkit for self-use
A Google APIs client library generated by tonic-build
Application use cases and machine contracts for cargo-governor
RESP2/RESP3 wire protocol codec
Alias for tibet-zip-mirror — Transparency Mirror for distributed trust
A robust, safety-first library for managing PostgreSQL database schema migrations with both sync and async support
contains generated low-level grpc code from YDB API protobuf, used as base for ydb crate
AST index and dependency graph server for code intelligence
Fully Homomorphic Encrypted Distributed Database with Zero Trust Architecture
API for Skynet plugin
Distributed Compute
cargo rustango new <name> — Django-style project scaffolder for the rustango framework
cargo rustango new <name>
Single-binary, single-file, local memory shared by every MCP client
ADBC driver manager
Oracle driver for rbdc
A Postgres implementation of an event repository for cqrs-es
SQLite persistence layer for cinderblock using SQLx with generated query building and dynamic filters
A Redis-based distributed synchronization and data structures library for Rust
An abstraction layer for SQL databases (PostgreSQL, MySQL, SQLite, MSSQL)
Local observability and audit tooling for Claude Code sessions
Immigrant database schema definition
Apache Iceberg Rust Sql Catalog
Bio-inspired embedded knowledge graph engine — pure Rust, zero runtime deps
ORM
macro for implementing helpful errors
Jazz local-first relational database core, runtime, client, and CLI
Server-global state storage for MCP entity registries (tools, resources, prompts) — pluggable backends for cross-instance coordination
using RocksDB as read-only lookup table (after initial bulk import)
Command-line interface for Grafeo graph database
See ormlite
ormlite
An versioned and forkable embedded Key-Value database
High-performance Redis-compatible server for Feox DB
Embedded database for serverless and edge runtimes, storing data as Parquet on S3
Asynchronous Yandex ClickHouse client library
A convenient SQL query builder for rusqlite with HTTP query parameter parsing support
MVCC layer with versioned keys, snapshot isolation, OCC transactions, and TTL key expiry
Structs representing sql queries, enabling query building, migrations, and more
RDF-star and SPARQL-star grammar support for quoted triples
Core SDK for building Danube connectors
query engine, empowering you to query everything
A small entity-based embedded database with a minimal no-SQL relationnal model, written in pure Rust
JSON1 functions and virtual tables
A logstash inspured key value extractor
Data models for GTFS (General Transit Feed Specification)
Async ms sql server connection pool simple impl of deadpool
Load data from databases to Apache Arrow, the fastest way
Wasmtime host implementation for a SQL component WIT interface. Enables Wasm components to interact with SQL databases via the WebAssembly Component Model.
Lightning-fast CLI for data analysis: explore, filter, transform Parquet/CSV/Excel files with SQL-powered operations
CLI utility for interacting with SWC neuronal morphology files
Agnesoft Graph Database API (Client)
Tenant-scoped helpers for Axum + sqlx + Postgres. Tenacious about row-level isolation.
Wire protocol types and serialization for Nautilus ORM
Generate Rust structs from ClickHouse rows
Type-safe wrapper for redis-server and redis-cli with builder pattern APIs
An incomplete implementation of a Rust client and server. Used as a larger example of an idiomatic Tokio application.
Profile expansion helpers for Greentic capability declarations
Rust driver for ArangoDB
TLS support for tokio-postgres via tokio-rustls
HA Kuzu/LadybugDB with one line of code. Leader election, journal replication, write forwarding — just your app + an S3 bucket.
Raft-backed distributed dataset for high availability and horizontal scaling
Archiving abstractions for the Omry project
Metric catalogs and scorecard validation for Firkin
Core data structures, CRDT event model, and projection engine for bones
CLI toolkit for the .bit language
Temporary fork of sqlx-postgres with unreleased fixes. PostgreSQL driver implementation for SQLx. Not for direct use; see the sqlx crate for details.
Ultra-fast embedded Write-Ahead Log. Zero dependencies.
High-performance embedded SQL database with MVCC, time-travel queries, and full ACID compliance
Helper macros for registering typed decoders in pg_debyte
Rust Client for Montycat - High-Performance NoSQL Database. The Fastest, Safest, and Most Elegant Database Client Ever Built in Rust.
SQL interface for SpireDB
Ankurah storage engine using Postgres
Vector executor for contextdb — cosine similarity, HNSW indexing, pre-filtered search
Long-term memory for AI coding agents
Command-line Parquet file viewer written in Rust
Unified storage layer for Astrid - SurrealKV (raw KV) and SurrealDB (query engine)
Replay and projection library for seesaw event processing
Allows access to the Scarb manifest fields documentation
Layer - Explicit obligation, the only executable layer
Shared domain types for oneiros
Conversions between Rust and Postgres values
Common Table Expressions for Diesel
An opinionated implementation of CQRS/Event Sourcing with pluggable storage backends (InMemory, PostgreSQL, MongoDB, SurrealDB)
DomnerTech-SqlClient is for connect to SQL like MSSQL and PostgreSQL
Pluggable S3-compatible object storage — core library with PostgreSQL and filesystem backends
High-performance vector database engine written in Rust
Fast, zero-config ETL in a single binary for transforming data between formats and databases
DDL and serialization for key-value storage
Schema types and binary framing for gibblox sidecar artifacts
Symbol extraction, workspace index, and name resolution for PostgreSQL
Official EventStoreDB gRPC client
Actor Model Library
Minimal rust wrapper for the telegraf/influxdb protocol
A netbox API client used as a reference for the Nazara project. Generated from the schema of https://demo.netbox.dev/
Command-line interface for ggsql
Make Delta pruning visible. A CLI that shows step-by-step how partition pruning and data skipping reduce candidate files in a Delta table.
Persistence layer (SQLite today; designed to grow to PostgreSQL per roadmap)
Configuration management for CipherStash libraries and products
A compile-time safe async ORM for PostgreSQL powered by SQLx
Core SQL lineage analysis engine
SQLite driver for bsql — direct FFI, arena allocation, dedicated-thread pool
FHIR RESTful API implementation for Helios FHIR Server
containing some helpers, used internally in the reading and writing of the CodeTracer db trace format
SQLite driver implementation for SQLx. Not for direct use; see the sqlx crate for details.
A lightweight ORM/SQL builder for Cloudflare D1 and SQLite
Schema types for LSP extension test files
AWS SDK for Amazon MemoryDB
Provide locked access to test databases
Write-Ahead Log for AIngle clustering and replication
Backend for Zenoh using InfluxDB v2.x
TLS support for tokio-postgres via native-tls
Plugin system for the WRAITH AI coding agent
Various helper types and macros for diesel
diesel
Adds support for PostgreSQL full text search to Diesel
Generated types based on the JSON-Schema for json_schema
Schema/query compiler for Omnigraph. Zero Lance dependency.
CLI, stream mode renderer, interactive TUI, scheduler, store, and API
AWS SDK for Timestream InfluxDB
ORM and QueryBuilder
Embedded graph database with full ACID transactions, HNSW vector search, dual backend support, and comprehensive graph algorithms library
Framework
Rust bindings for liblmdb on the mdb.master branch
State store implementations for Rigatoni CDC/Data Replication: Memory, File, Redis for distributed state management
AWS SDK for Redshift Data API Service
Abstract Syntax Tree definitions for vibesql SQL parser
A typed facade over aws-sdk-dynamodb with expression builders and batch/transaction support
Rust-first microservice framework inspired by go-zero engineering practices
Generate random test data for any mysql database schema
高性能 Memcached 协议兼容服务器，支持双层缓存和持久化存储
A client for generating embeddings and reranking with Voyage AI
GitHub Action support for Lintel — creates Check Runs with inline annotations
trait framework for data repository patterns
A focused todo CLI
Zero-allocation tag-based publication filtering for Sockudo
Generic batching sink framework for obs: triggers + retry + spool + escalation with a pluggable BatchBackend trait
Postgres-native background job queue — transactional enqueue, heartbeat crash recovery, SKIP LOCKED dispatch
PostgreSQL backend implementations for Rustvello
an async ORM for Rust
Transaction management and concurrency control for ReifyDB
A batteries-included client wrapper for DynamoDB
Serialization framework for ORM
Sqllogictest built-in engines
tokio-postgres / deadpool-postgres adapter for NextSQL runtime
DynamoDB implementation for FakeCloud
provide minimal tracing support that can be turned off to zero cost
tracing
moduforge 搜索服务 - SQLite 后端
PostgreSQL-specific diesel SQL function extensions
Event bus abstraction for zopp
Async TCP server for PowDB with binary wire protocol
Elasticsearch-compatible HTTP adapter for searchlite (translates ES query DSL to native API)
SQLx integration for paginator-rs with PostgreSQL, MySQL, and SQLite support
SQL generation utilities for Hamelin query language
Maybe an ORM
Avro, JSON and Protocol buffer validation with conversion to Apache Iceberg, Delta Lake or Parquet via Apache Arrow
SQLite C API compatibility shim for drop-in replacement
Convert JSON Schema to GBNF
A lightweight, real-time embedded database with built-in PubSub, reactive queries, background workers, and intelligent caching
Localization support for VibeSQL using Project Fluent
Shared types for MS SQL source and bootstrap plugins
MongoDB in rust, simplified
Convert between SQLite/DuckDB databases and CSV directories
OpenTimeline core
Apache Arrow object_store storage backend for icechunk
Hyper performant polyglot Database driver
Auto migration generator for SeaORM — diffs entities against live DB and generates migration files
The inner database abstraction layer from rorm
VectorXLite: A fast and lightweight SQLite extension for vector search with payload support
Time series engine for Aegis database
JSON import/export for XFA form data. Experimental — part of the PDFluent XFA stack, under active development.
Store traits and implementations
Shared SDK for enwiro plugin authors: logging, gear schema, plugin protocol types
Opinionated alternative CLI and library to interact with the MongoDB Atlas Admin API
SPARQL 1.1/1.2 HTTP protocol server with Fuseki-compatible configuration
Standalone ingest-to-pgvector: source -> chunker -> embedder -> extractor -> table. int8 BGE by default; bakeoff matrix evaluator built in. Cross-language wire-format compatible with the Python chunkshop package.
chunkshop
Tensor Train decomposition, delta encoding, and RLE compression for tensor data
PostgreSQL broker implementation for CeleRS with FOR UPDATE SKIP LOCKED
Build pipeline management — compile, package, and artifact management
Shared Contrail log schema and protocol types
Command-line interface for TideORM
SQLite wrapper using async Rust
Command-line interface for Cloacina task orchestration engine
type-safe workflow engine for Rust, inspired by PocketFlow and optimized for LLM applications
TypeScript type definition emitter for oa-forge
Automatic GraphQL API generation from PostgreSQL schemas in Rust
A RDF Stream Processing engine in Rust, supporting RSP-QL queries with sliding windows and real-time analytics
HTTP SQL adapter plugin for smugglr -- supports Turso, rqlite, SQLite Cloud, and custom endpoints
Shared implementation helpers for triblespace procedural macros
Derivable crud helpers for sqlx. Write your SELECT, INSERT, UPDATE and DELETE queries once and reuse them for all your entities.
Axioms Metrics Processing Language
Foreign Function Interface implementation for DataFusion
A high-performance key-value store backed by PostgreSQL unlogged tables
Protocol buffer definitions for SpireDB
File-based tree storage
A tools crate used by KunoiSayami's projects
SQLite database layer with SQLx for multi-tenant storage
CLI tool for AvocadoDB - deterministic context compilation for AI agents
Shared type definitions for the Sage language
PostgreSQL persistence provider for WFE
Schematic version control for panproto — git-like VCS for schema evolution
A complete library to interact with Firebase Cloud Messaging (protocol v1)
parsing data files in the Unicode character database
A next-generation, type-safe ORM for Rust inspired by Prisma
A toy SQL parser for a subset of the Oracle dialect
Abstract Syntax Tree representation for Prisma Schema Language
A fast, embedded database for Rust. Minimal dependencies. No C code. No build scripts.
The native Rust implementation for Apache Hudi
State management utilities for Pulse — provides windowing, aggregations, and persistent operator state
A secure and stable database backup synchronization system with automatic file transfer and verification
Durable append-only storage for PAI-Kernel governance state · GovernanceStore trait with SQLite backend per PAI-CD v2.2 Identity Layer
Zero-config SQLx wrapper and database integration for the Oxide web framework
Lightweight Rust library for Microsoft SQL Server using dataset and datatable
writing sorted Parquet files using Apache Arrow
For testing if Sea Orm Migrators are reversible
CLI tools for RON (Rusty Object Notation)
Passive JSON schemas for VT Code collaboration and HITL tools
Core IR types and validation for Alembic
Schema catalog for KyuGraph: node/rel table entries and DDL management
SDK for Dameng Database (DM8) with ODBC support
Parquet-backed text2sql engine and CLI for schema-first querying workflows
Rust bindings to Kusto.Language for KQL validation and language services
Object Agent Mapping framework for distributed systems and agents
Cypher function implementations for Drasi
TIBET Cortex Audit: blackbox-met-window audit trails with tibet-vault integration
Database library to be used in pib-service
Immigrant DMDL codegen
Ghost tile afterlife — dead agents live on through decaying knowledge tiles
Config for dbmcp
Evolution and Genome Management - Genotype operations for FEAGI
Certificate store for rpgpie, based on openpgp-cert-d
SQL database engine with SQL:1999 compliance
CLI for yauth migration management — cargo yauth init/add-plugin/remove-plugin/status/generate
An embedded property-graph database in Rust with a GQL query language, RocksDB-backed ACID storage, graph algorithms, and Python bindings
Imports CSV data into an SQLite database
Ankurah storage engine using IndexedDB in the browser
Safe Rust bindings for the NeuG C++ graph database engine
BIT type support for duckdb-rs
A wrapper implementation of UUID providing binary diesel bindings for SQLite and PostgreSQL, and redis serialization support
A lightweight, embedded document database with ACID transactions and MVCC support
Neuroscience-grounded memory system for AI agents. ACT-R activation, Hebbian learning, Ebbinghaus forgetting, cognitive consolidation.
A server software to run a smol_db instance
Sync Asana data to a local SQLite data warehouse
FURNACE - AI-powered code generation and analysis MCP server with knowledge graph and tiered search
HwhKit Redis/Dragonfly integration
Rust runtime and executor for compiled Tigrbl kernel plans
DataFusion sqllogictest driver
Apache Parquet I/O operations for Polars
A nushell plugin to interactive with mongodb
Event generator library for Varpulis demos and testing
A parser for TDLib's Type Language definitions
SQLite projection helpers for moire snapshot tables (entities, scopes, edges, events)
Unified database facade for LaminarDB
JSON-based local database plugin for elizaOS - no SQL required
support crate for Ditto: dittolive-ditto is the crate we intend for you to interact with
RESP protocol types and codec for redis-tower, backed by resp-rs
Limbo crypto extension
Code Mode validation and execution framework for MCP servers
Query AWS RDS Data from the command line
Agnostic migration toolkit library
Json wrapper type for JsonB data handling in diesel
Manage migrations across fleets of SQLite databases
Wait-free 4-level 64-bit pagetable for roughly-contiguous keys
High-performance PostgreSQL to Meilisearch connector
A lightweight, embeddable Key/Value store. Inspired by SQLite. Vibe coded over a holiday.
Memory backends (in-memory, SQLite, Redis) for the IronClaw AI agent framework
Admin panel functionality for Reinhardt framework
Rust language bindings for XA Distributed Transactions
Append-only evolution memory and pipeline for Oris EvoKernel
Ringworld — ancient, subversive, ingenious — or a type-safe MongoDB builder library
An async Vinted API wrapper
Base GraphQL abstractions
A query builder using rust concepts
versatile tool for managing SQL database versions, using JSON to define structures and simplify migrations across environments
MCP server for MenteDB, the cognition aware database for AI agent memory
A pager for tabular data
Cassandra protocol implementation
High-performance mutable archive format with SQLite VFS support
AviUtl2のプラグイン・スクリプト開発に便利なコマンドラインツール
Docbox multi-backend search abstraction
CLI and MCP server for Ruvector
macOS automation bridges (AppleScript, Shortcuts, App Intents) for Common Agent Runtime
rsql is a CLI for CockroachDB, DuckDB, LibSQL, MariaDB, MySQL, PostgreSQL, Redshift, Snowflake, SQLite3 and SQL Server
Helper types for sea-orm-migration testing
Distributed locks for Rust with multiple backend support (PostgreSQL, Redis, MySQL, MongoDB, file system)
A database that stores JSON data rows as compressed text within the zTXt chunks of PNG image files
Automatic Migration Tool for Charybdis ORM
Core types and traits for HTTP-based database backends
Database abstraction layer for tursotui
PostgreSQL pg_trgm extension support for Diesel
MoosicBox search package
Key-Value Database Wrapper
Fortress - Enterprise Security. A highly customizable, secure database system with multi-layer encryption.
An interactive TUI (Terminal User Interface) for browsing and inspecting key-value stores (Redis, Memcached, etc.)
A dead-simple, pluggable, binary-sorted key-value store for Rust with FoundationDB-style keys. In-memory and SQLite backends. Zero-boilerplate and easy iteration.
Knowledge graph engine for codebases — tree-sitter parsing, SQLite graph store, FTS5 search, flow detection
in Rust
Code generation layer for TupaLang
FlowFabric cross-partition dispatch and background scanners
reading and writing Bear.app notes via the local SQLite database
Redis-backed distributed cache stampede prevention with leases, fencing tokens, SWR, and tagging
A file-based storage engine that stores structured data as Markdown files with YAML frontmatter
A postgres database engine for rust that builds on top of tokio-postgres and deadpool
Database connectivity module for XDL - supports PostgreSQL, MySQL, DuckDB, SQLite, ODBC, Redis, and more
MRP Types
Database layer for WiFi-DensePose
PostgreSQL migration tool that keeps your schema files as the source of truth
Command line interface for Slumber. Not intended for external use.
AI knowledge graph with persistent memory across sessions
A lightweight and extensible data storage library in Rust
embedded SDK — ACID transactions, AES-256 encryption, WAL durability, 6 storage engines. The SQLite alternative built in Rust.
managing PostgreSQL extensions
Terminal UI for browsing MCAP topics and decoded messages via mcapdecode
The dotfiles crate for Atuin
Transaction engine with WAL and MVCC for KyuGraph
Adds support for the PostgreSQL ltree extension to Diesel
ORM code generator
Iron-oxide fast embedded database - nanosecond-level key-value storage
A CLI client for muDB, a RESP-based in-memory cache server written in Rust
Rust realtime, stream, transfer, and datagram verb metadata for Tigrbl
Rust wrapper for TidesDB, a fast and efficient key-value storage engine
Web server and API for MDQL — a queryable database backed by markdown files
Sys package with installer and bindings for mongoc
Database management for trader brokerage data with a MongoDB backend
Switchy database connection package
Pipe-based query language for security event analytics
Table sharding and replication engine (DynamoDB-like) for the Garage object store
DataFusion client for long-term storage of scouter data
bb8 connection pooling impmentation for the MongoDB database
Codegen module for Pulumi Gestalt
Arrow integration for SeaORM
Embedded Drasi for in-process data change processing using continuous queries
Databend Rust Tcp Test Container
Driver library for using SeaQuery with SQLx
Terminal-based SQL database viewer and editor with vim-style navigation
A lightwight ORM and Query Builder for postgres
High-level database client with migrations, pooling, and AI model management for BurnCloud
An associative memory system using spreading activation with SQLite FTS5 full-text search
A high performance data storage solution written in rust
Rust bindings for the rego-cpp Rego compiler and interpreter
Rust SDK for DuckLake
Command-line tool to query, modify, import and export Sled key-value databases
WASM bindings for Iridium SQL
Linter for Postgres migrations & SQL
SQL serialization layer for Toasty database drivers
Raphtory storage interface
Correctness-first bidirectional Salesforce and Postgres sync engine
Revolt Backend: Configuration
Offline-first PostgreSQL sync plugin for Tauri apps
Firebird client library
database/service benchmarking framework
Rust query builder for SpacetimeDB
Official KurrentDB gRPC client
AWS SDK for odb
Bootstrap runtime core crate for the Greentic-X workspace
Production-grade relational database connectivity for rivven-connect
Database introspection, version detection, and privilege checks for pgroles
Weaviate vector database integration for Synaptic
Generates tonic-compatible gRPC stubs for flatbuffers RPC services
Superfast, multithreaded document generator for MongoDB, operating through CLI. Generates millions of documents at maximum speed, utilizing all CPU threads.
State persistence and recovery for LLM workflow orchestrator
Source SDK for Drasi
Operator CLI + MCP server: canonical corpus second: semantic index second to aicx
MCP server interface for Mnemo memory database
Apache Iceberg Glue Catalog Support
Relational data structures, iterators and algorithms
JWT (Ed25519, audience-scoped, mandatory kid, tenant_id D3-complet) + RevocationStore + JwtService (alpha.5)
AWS SDK for AWS Database Migration Service
A dynamo-like key/value database written in rust
LMDB-backed content-addressed blob storage for hashtree
Django-style management command framework for Reinhardt
Platform-specific functions for SQLX dbs
Database backends for django-rs: PostgreSQL, MySQL, and SQLite drivers
Low-level access to SQLite's VDBE bytecode engine
Delta compression for Sockudo WebSocket messages
CLI tool for building and managing Hermes search indexes
CLI for the oag OpenAPI code generator
Logical plan and expression representation for DataFusion query engine
Procedural macro for generating type-safe SQL expressions for accessing nested JSON fields in PostgreSQL with Diesel ORM
Semantic (hybrid) search MCP tools for Fabryk
MCP server for Sparrow Ontology — ontology-aware semantic layer over SparrowDB
Apache OpenDAL Monoiofs service implementation
Types for the SpacetimeDB client API messages
Redis component for rust-camel
Shared storage foundation for OpenData databases
DuckDuckGo search client library for duckduckgo-cli
A lightweight Rust alternative to mem0 — long-term memory for AI agents
Well-known schema hashes and routing key constants for the MARS protocol
Lightweight SQLite WAL sync to S3/Tigris
Semantic memory for AI agents - local-first, MCP-native
Zero-boilerplate Repository Pattern for modern Rust applications. Write SQL traits, get async implementations with sophisticated pagination, streaming, batch operations, and more. Seamlessly…
A tiny database connection pooling library for PostgreSQL
Output formatters (human, JSON, SARIF) for the rigsql SQL linter
high-performance embeddable, durable, adaptive, and optionally cloud-native key-value storage engine
Core types, traits, and error surfaces shared across XLOG
Rapid Log Analysis
Key-value store component for Loro, a high-performance CRDTs framework
Ergonomic ORM for Rust with compile-time safety and Django-like query API
Document store engine for Aegis database
Reflection queries for postgres-static-analyzer
CLI tool for RustRails project management
an eventsource implementation on top of kurrentdb
Embeddable commerce library - the SQLite of commerce operations
The types used with the fully typed LMDB wrapper, heed
Dead simple async pool for diesel
A fast code symbol indexer for AI coding agents
knowledge fabric — umbrella crate re-exporting all components
Embedded database for agentic AI systems — collective memory for multi-agent coordination
Database migration functionality of pib-service
Semantic search over storage-backed embeddings for Nexus Memory System
Revolt Backend: Permission Logic
Memory library for the fiddlesticks agent harness framework
Universal relational schema intelligence for SQL databases (Postgres, MySQL, SQLite, ClickHouse). Understand your database before you touch it.
PostgREST URL-to-SQL parser for Rust and WASM
An SQL query builder with a pleasant fluent API closely imitating actual SQL
Runtime library for ferriorm ORM - database client, filters, query execution
Internal: SQLite persistence layer for mxr
Reasoning engine for distributed backend & AI orchestration. Coordinate services, databases, and AI agents with business rules (GRL).
Reusable LLM agent loop with tool-calling and lifecycle hooks
An embedded, persistent key-value store with high write throughput and durability
derive macro to manage structs persistence in FoundationDB with secondary indexes automatic management
CLI tool for reading Microsoft Access (.mdb/.accdb) files
Rust SDK for Codex
Core storage engine, query executor, and catalog for ORMDB
A lightweight, blazingly-fast in-memory key-value store inspired by Redis
WebAssembly bindings for RuVector graph database with Neo4j-inspired API and Cypher support
Host-facing bindings and mappers for Greentic WIT packages
building AWS Athena User Defined Functions in Rust
Data quality, reconciliation, and validation across different data stores
SQL dialect definitions (ANSI, TSQL, PostgreSQL) for rigsql
TUI client for Bolt-compatible graph databases (Mesh, Neo4j)
Public API types for Feldera
Rule-based query planner for contextdb
Serverless Workflow specification compliant workflow engine
osquery implementation to query system information
Xugu driver implementation for SQLx. Not for direct use; see the sqlx crate for details.
Real-time streaming support with Kafka/NATS/MQTT/OPC-UA I/O, RDF Patch, and SPARQL Update delta
High-performance embedded graph database
key-value storage with support for multiple backends
Rust bindings for libmdbx
Claude Code に海馬を足す MCP サーバ。特異性が高い瞬間だけを長期記憶化する surprise-aware memory store. Pure Rust、SHODH-compatible schema、Apache-2.0/MIT dual-licensed.
Knowledge graph for ChronosVector — typed entities, relations, and multi-hop reasoning
SQLite database layer for Flow feature management with WAL mode and event logging
RocksDB-backed storage engine for Mesh
A zero cost and lightweight ORM operations for SQLx
HTML language plugin for sqry
Universal, extensible query builder for SQL databases
A GraphQL printer
A K.I.S.S. sequential storage engine
Django-inspired database migrations for Diesel
terminal-based time series database
Session, changeset, and patchset extension
A Lightweight JSON Document Database in Rust
Rust client SDK for Moon — high-performance Redis-compatible server with vector search and graph engine
Lightweight Apache Arrow data frame
Core query execution engine for the Saola ORM
Django-style shortcut functions for redirects, rendering, and 404 error handling
A lightweight, high-performance structured database server written in Rust
Core traits for Nomograph knowledge graph tooling
A parser for MySQL slow query logs that anonymises queries by replacing literals with placeholders
A lightweight database built in Rust
ORM-like API MongoDB for Rust
A TUI for MongoDB
Generate rpckit-compatible TypeScript schemas from jsonrpsee RPC traits
Supabase storage implementation following the official client libraries
Natural-language → SQL adapter for sqlrite-engine. Anthropic-first; OpenAI / Ollama follow-ups.
AWS SDK for Amazon SimpleDB v2
Helpers for Omry client applications that run integration tests against the Omry backend
A validator for the CSAF standard written in Rust
file-backed, human-readable key-value store with TTL support
Official Rust SDK for Rune distributed function execution framework
Official ClickHouse ADBC driver
A command-line tool to import CSV files into MongoDB
automatically generating Rust structs and CRUD functions from PostgreSQL tables
parsing BigQuery queries and extracting schema-aware, column-level lineage
The vsr command-line interface for very_simple_rest
Core building blocks for PostgreSQL extensions that decode bytea into JSON
Terminal UI and theme boundaries for TSQL
Node.js bindings for RuVector Graph Database via NAPI-RS
Chryso parser crate
Arrow data mapping and encoding/decoding for Postgres
A sqlc plugin that generates type-safe sqlx Rust code from SQL queries
Background task processing for rust using apalis and pgmq
A drop-in database migration library for PostgreSQL
Ankurah storage engine using Sled
Core SimpleAgents client API integrating providers and healing
Rust SDK for the Flex DB API — async, typed, minimal dependencies
Core engine for cgx — Tree-sitter parsing, DuckDB graph storage, git analysis, and clustering
REST API server for Mnemo
experimental database engine built to explore storage engines, query execution, and networking
Prometheus-compatible time series database built on SlateDB
WebAssembly bindings for geodb-core with simple JS API and embedded dataset
Redb storage adapter for the Nornir event sourcing library
In memory engine of the Polars project
Command-line interface for AutoModel — SQL-first Reverse ORM for Rust, Built for the greater DX and for the AI Era
Async streaming client for InfluxDB 2.x - query millions of rows without OOM
Command-line tool for Premix ORM (Migration management and more)
A modern Terminal User Interface (TUI) database management tool for PostgreSQL, MySQL, and SQLite
Query runner for PRQL
Intent classification and routing for Brain OS signals
Companion CLI for the Rust Oxide backend framework
Memory abstraction and page management for the wasm-dbms framework
TLS support for tokio-postgres via openssl
Input/output connectors for Pulse — integrates with external systems such as Kafka, Arrow, and Parquet
Database-agnostic row-to-JSON conversion for sqlx
SQL database broker implementation for CeleRS (MySQL)
Type-safe database schema generation for Rust with support for custom storage backends, automatic indexing, and layered cache architectures
Command-line interface for Azoth database
Interface for wasmCloud actors to access Key-Value stores (wasmcloud:keyvalue)
MCP server that lets LLMs query PostgreSQL, SQLite, and MySQL databases
个人使用数据库操作
High-performance data profiler with ISO 8000/25012 quality metrics for CSV, JSON/JSONL, and Parquet files
Postgres toolkit for Rust, powered by facet reflection
CLI binary and server entrypoint for Kōra
Fast embedded vector database with HNSW + ACORN-1 filtered search
Native bindings to the libduckdb library, C API; build loadable extensions
CLI / Library for Postgres schema migrations
A command line tool for inspecting MongoDB
Shared foundational types for icechunk
Query structure and type definitions for Saola ORM
Official Rust client driver for Anvil DB
Quantum Database with vector store, MPS compression, Grover search, and fault-tolerant storage
openCypher parser for KyuGraph with hand-written lexer and chumsky combinators
GraphQL support for Postrust
DynamoDB model types for Rustack
Shared storage infrastructure for the saku ecosystem
Async mysql connector
A powerful, type-safe query builder library for Rust that leverages key-paths for SQL-like operations on in-memory collections
DDB v2: A high-performance SQL interface for flat files written in Rust
Schema-only types for Greentic host configuration (no IO)
CLI for converting MCAP messages into JSONL, CSV, and Parquet via Arrow
Rust client for Valkey, built for FlowFabric. Forked from glide-core (valkey-glide).
interacting with the foxglove protos
A type-safe, fully generic, production-ready caching framework for Rust
A minimal memory layer for AI agents
Data replication and synchronization for ruvector
A modern PostgreSQL TUI client with autocomplete, syntax highlighting, and query formatting
working with duckdb asynchronously
SQL layer for LaminarDB with streaming extensions
Observer system for reactive business logic in FraiseQL v2
The output transformer of os-checker CLI, used to generate static data for os-checker WebUI
Database executors and connection management for Nautilus ORM
SQL Server-compatible Rust engine core for Iridium SQL
A Service/Layer based Kafka client
Bundled version of libpq
Stream PostgreSQL query results directly into Polars DataFrames via sqlx
Remote protocol for libSQL
Delegation orchestrator — copy, spawn, monitor, sync, notify
IcyDB — A schema-first typed query engine and persistence runtime for Internet Computer canisters
Schema parser and AST for the Prax ORM
Export your Zed editor AI chat history to Markdown files for archiving and LLM context
🧭 A GraphQL framework for Rust
A personal Rust ORM project built on SQLx, inspired by MyBatis-Plus
Unofficial implementation of the Iceberg table format specification
A query-building & utility crate for SurrealDB and its SQL querying language that aims to be simple
Server for dbmcp
MCP-native persistent memory tool for AI agents
Embed Styx schemas in binaries for zero-execution discovery
High level database access library based on 'odbc' crate that uses native ODBC drivers to access variety of databases
SQL database query language parser with support for standard SQL syntax and database operations
Vector catalog and semantic indexing subsystem for Frame microservices
CLI for Sparrow Ontology — ontology-aware semantic layer over SparrowDB
Cluster membership and partitioning for Mesh
A DBML parser for Rust
Official Rust driver for PyroSQL — PWire binary protocol
A Postgres pg_config wrapper for 'pgrx'
Fidius plugin interface and shared types for Cloacina workflow packages
High-performance Redis-compatible key-value store built with Rust
PartiQL Catalog Definitions
Runtime engine for the Omnigraph graph database
CLI command for vespertide (model template, diff, SQL, revision, status, log)
View layer aggregator for viewsets and views-core
OData V4 query string parser with AST and multi-dialect SQL rendering
Vantage extension for SQL databases (Postgres, MySQL, SQLite)
AI-native embedded multimodal database for embodied intelligence (robots, AR glasses, industrial arms)
Structured querying and timeline reconstruction for clawdstrike hunt
Connector to read polars dataframes from mongodb collections with full projection pushdown, including nested fields, and predicate pushdown
interacting with Mimer SQL, a high-performance relational database management system (RDBMS)
Epoch based storage flags for GroveDB
A CLI application to help deal with migrations
Base crate for ReductStore
SQL-first migration CLI
Client library for HeroIndex search server
SQL-first cross-language type-safe code generator — CLI
A high-performance MongoDB Shell implementation in Rust
Immigrant migrations generator for postgres SQL dialect
High-performance LMDB-based local storage library optimized for FFI integration with Flutter and cross-platform applications
Pinecone Rust SDK
A terminal-based PostgreSQL query execution and visualization tool with vim-like navigation
Wire protocol types for Vectorizer (RPC + gRPC). Shared between server and SDKs.
Async Rust client and CLI for EventDBX
Arrow-native graph processing engine with SQL interface
Manifest-driven backend adapter library and server runtime for e2ee-client-backend
Command line utility for SeaORM
DuckDB-backed SQL engine backend for winterbaume Athena and Redshift Data
Domain services and projections for the oneiros event-sourced brain
CLI for the Awa job queue
FlowFabric EngineBackend impl — Postgres backend (RFC-v0.7, Wave 0 scaffold)
XORE CLI - Command-line interface for search and data processing
Prometheus utilities for SpacetimeDB
MongoDB database adapter for ZoeyAI
Embeddable Graph Database Core (Rust)
Database layer for Kaccy Protocol - PostgreSQL, Redis, and distributed caching
AWS SDK for AWS Performance Insights
Apache OpenDAL GitHub service implementation
Local-first, explainable AI memory engine for embedded and service-based systems
Rust driver for Zeta4G graph database with Bolt protocol support
server sqlite database library for atuin
Fast, lightweight, in-process vector database with HNSW indexing, E8/H4 lattice quantization (up to 24.8x compression), metadata filtering, and PyO3 bindings
NetBox adapter for Alembic
High-performance collection management for Ruvector vector databases
— a lightweight document + event store for Rust, powered by Postgres
Core library for SQL static analysis against schema definitions
A type-safe, multi-backend key-value storage library for Rust with support for native (Sled, Redb) and WASM (IndexedDB) environments
FlowFabric server library and HTTP binary
CDC sync engine and query router for Rhei
General purpose migrate sql for axum web framework
Production embedded-KV backend for mnem - redb-backed Blockstore and OpHeadsStore
Shared error types, IDs, and configuration for the KyuGraph database
Ergonomic wrapper for couchbase-lite-core library
TIBET Cortex Store: JIS-gated vector storage with TBZ envelopes
Limbo extensions core
Raphtory GraphQL server
embedded NoSQL database using CSV files for storage
Logic for setting up and running Scouter event-driven consumers and producers
CLI for resolute: offline query cache and database migrations
Cache API for Deno
psql-inspired client for PostgreSQL
Command-line tools for UmaDB databases (integrity checks, utilities)
Revolt Backend: S3 and encryption subroutines
Rust Postgres engine for Tigrbl
Rustvello distributed task system CLI
SQLite for vectors — embedded AI memory engine
Range support for rust-postgres
A lightweight, persistent SQL engine in Rust
rsql formatters to output rsql results in various formats
Cargo subcommand for 'pgx' to make Postgres extension development easy
Exasol driver for the SQLx framework
Database-backed persistence implementations for the Rust deep agents SDK (Redis, PostgreSQL)
Cypher query parser and planner for SparrowDB
Typed macroes for qusql-mysql
Write servers that speak PostgreSQL's wire protocol
Tooling for converting JSON Schema into GLua annotations
A persistent datastore backed by RocksDB with fuzzy key lookup using an arbitrary distance function accelerated by the SymSpell algorithm
A data visualization and analytics component, especially well-suited for large and/or streaming datasets
Standalone SurrealQL parser extracted from SurrealDB
SQL language plugin for sqry
CipherStash SDK for searchable, in-use encryption for DynamoDB
Type-safe, extensible Rust library for managing multiple SQL databases and tables with sqlx
Rust OLAP analytical verb metadata for Tigrbl
Rust client for OpenSky Network Trino database
Pattern definitions and core matching logic for GritQL
API server for Aegis database
A lightweight embedded database framework for Rust — built on redb with layered cache, versioned backup, and domain-driven storage
Experimental Rust client for Apache Iceberg with WASM support for AWS S3 Tables and Cloudflare R2
Vantage extension for SurrealDB
Redis journal and snapshot store for rakka — sorted-set journal, hash snapshots, transactional batches
Pure Rust reimplementation of LMDB (Lightning Memory-Mapped Database)
Command Line Interface tool for GQLite
Common types and traits used across the CipherStash ecosystem
Terminal UI for DBiewLite — viewer for SQLite, DuckDB, and Parquet files
Query execution engine for Nautilus ORM
Unified Entity Card helpers for validating UEC JSON payloads
SQLite driver for SQLModel Rust
HwhKit MongoDB integration
SurrealDB integration for paginator-rs with multi-model database support
Bolt driver for Neo4j
zero dependency, tiny sqlite3 wrapper built for lodpm
CLI logging helper for repeated runs with metadata tracking
Migration engine for ferriorm ORM - schema diffing and SQL generation
An ORM for people who love SQL. Use the ormlite crate, not this one.
client library for atuin
Caching secret values to SQLite with encryption
A DynamoDB implementation of an event repository for cqrs-es
A SQL parser and semantic analyzer conforming to modern ISO SQL standards
chDB FFI bindings for Rust(Experimental)
Persistent PostgreSQL client for AI agents — SQL-native JSONL in, JSONL out
Standalone Cozo database
database migration manager
Multi-backend database abstraction for Hanzo Node - Supports LanceDB, DuckDB, PostgreSQL, and more
Rust client SDK for Dakera AI Agent Memory Platform
Mesh graph database server binary
APOC-compatible procedures and scalar functions for Mesh Cypher
Apache OpenDAL SFTP service implementation
OpenCypher Knowledge Base for Gollum
Persistence layer for Grafeo: WAL, container format, section I/O
Stream OpenTelemetry logs, metrics, and traces to Parquet files
Embedded vector database for approximate nearest neighbor search (experimental)
Storage abstraction layer for authx-rs: repository traits, in-memory store, and PostgreSQL adapter
CLI for pgroles — validate, diff, apply, inspect, and generate role policies
MongoDB database synchronization tool
Parse SQLite databases
Redis client integration for Armature - connection pooling, pub/sub, and DI-ready
A content-addressed graph database for versioned thoughts
ClickHouse Client with SeaQL integration
TDS (Tabular Data Stream) protocol for SQL Server. Publishable fork of microsoft/mssql-rs until the official crate lands on crates.io.
SQLite-backed jobs queue with atomic UPDATE...RETURNING leases
Application manager implementations for Sockudo
Query planner and logical plan optimizer for KyuGraph
Common types, identity encoding, and schema for Uni graph database
PostgreSQL (sqlx) component for hygiea
provide tools for Magi AI agents
High-performance multi-model database engine — KV, Graph, SQL, Vector Search, and Full-Text Search in one binary
2D CAD file format Rust implementation
Database abstraction layer for Holochain using sqlx
generated REST API bindings
Storage trait and shared types for icechunk
Backend implementation supporting the Hamelin query language in Trino
Client-side vector database built on IndexedDB with WASM
LLM provider abstraction, context assembly, and action dispatch for Brain OS
Rust framework for building analytical data services on Arrow Flight and DataFusion
Jena-style SPARQL algebra with extension points and query optimization
Apache OpenDAL Dropbox service implementation
Opinionated async Rust framework for building Mae-Technologies micro-services — app scaffolding, repo layer, middleware, and test utilities
Salsa-style incremental computation engine for sqry semantic code search
SQL parsing utilities for tursotui
Persistent cross-session memory store for OpenHawk agents — wraps aura
v2 - Compiled GraphQL execution engine for relational databases
Interactive SQL shell
MCP server for ctxgraph — exposes graph memory to Claude and other LLMs
Qdrant vector database integration for semantic search and RAG
A data concurrency control storage engine to Rustbase
Memory for AI Agents — store, recall, update, forget
netsky observability database
SQL Toolkit and ORM Library. An async, pure Rust SQL crate featuring compile-time Dynamic SQL gen system
SQL query builder for Saola ORM (PostgreSQL, MySQL, SQLite, MSSQL)
RAG/memory MCP server with LanceDB vector storage
Fast, parallel SQL dump to CSV/TSV converter. Supports MySQL, PostgreSQL, SQL Server, Oracle, and SQLite.
Fast and efficient vector graph database built on top of kvwrap
A CLI for tern migration tooling
tern
building and querying knowledge graphs using SQLite as the backend, with graph algorithms, vector search, and RAG support
pgrx glue for pg_debyte (GUCs and decode helpers)
Integration test suite for Toasty database drivers
ForgeKit runtime layer - Indexing and caching
Extension trait and procedure signatures for KyuGraph plugins
Limbo extension tests
Shared types, configuration, error handling, and Prometheus metrics for the raft distributed KV store
A key-value DB for converting structs into a DB of assorted json files
A lightweight macro system on top of sqlx
A neuro-symbolic semantic engine for OpenClaw, combining graph databases with vector operations
A GraphQL parser
A SQL database with vector similarity search capabilities
Unified replication formats for embedded databases. Physical (.hadbp) and journal (.hadbj) changesets with SHA-256 checksum chaining.
Dataset traits for the Vantage data framework
An ergonomic stack allocated String
An embedded single-file database for Rust
Approximate-nearest-neighbour (HNSW) vector index for mnem. Feature-gated alternative to the built-in brute-force index in mnem-core.
AWS SDK for Amazon Neptune
An easy timeseries database
High-performance embeddable OLAP cube library built on Apache Arrow and DataFusion, with support for dynamic aggregations, calculated fields, and incremental updates
Core vector database and neural routing inference engine
High-performance PostgreSQL wire protocol driver for Rust
MAG — Local MCP memory server with ONNX embeddings and semantic search
Interface for agent persistence
elephantry cli tool
Content Markup Language (CML) v0.2 parser, generator, validator, and embedding store for structured documents
Turso/libSQL HTTP API backend for db-http-core
small SQL query builder + derives for filterable ORM-ish patterns
Journal replication engine for graph databases. Logical WAL shipping via .hadbj segments to S3.
GraphQL façade for OxiRS with automatic schema generation from RDF ontologies
Internal diesel crate
SQL document and parsing boundaries for TSQL
AI-native SDK for SpireDB — RAG, code search, agents
⏳ Durable step functions via Postgres
A MongoDB implementation of the cqrs-es event store
SQL parser for Databend
GitQL Engine
A parser for ScopeQL queries and commands
Apache Jena TDB/TDB2 compatible RDF storage engine with B+Tree indexes
UI layer for sabiql
Type-safe SQL templates with Askama and SQLx
Nautobot adapter for Alembic
Python bindings for Briefcase AI
A terminal-based database client inspired by DataGrip
High-performance local vector database with HNSW indexing
Storage backends for crawled web data
A flexible schema specification and parser for information extraction tasks
powerful database migration tool for SurrealDB
Shared SQL dialect compiler (DDL + DML) for the Rusticx multi-database ORM
HTTP bindings for the oneiros service layer
Local vector RAG system for academic papers using LanceDB and FastEmbed
rsql duckdb driver
protobuf query language
DuckDB database driver for Prax ORM - optimized for analytical workloads
Dead simple async pool utilities for async runtimes
ReifyDB Query Language (RQL) parser and AST
SQL tokenizer with dialect support for the rigsql linter
framework for distributed systems and agents
Deno database API
The semantic memory engine for ClawDB — HNSW vector indexing and storage
key-value store based on LibSQL
Local-first multi-tenant memory store engine: Markdown/text content on object storage, metadata in SQLite, plugin-shaped embedder/storage/metadata, hybrid text+vector search
Tansu Kafka API compatible broker
MCP server exposing Tasker capabilities to LLM agents and developer tools
Storage extension crate for GroveDB
Fork of rocksdb crate for Noise
Verifies the connectivity and validity of objects in the database
PostgreSQL knowledge graph extension with graph algorithms and pgvector integration
ergonomic Redis client wrapper for Rust
Pluggable storage for Kernex: conversations, learning, and scheduled tasks
Session stores for pavex-session backed by sqlx
pavex-session
C language plugin for sqry
Knowledge management system for Miyabi - Vector database, embeddings, and search
management system with SQLite database and AI-assisted discovery
AWS SDK for AWS AppSync
Create random sub-samples from CSV files or PostgreSQL databases
Relational executor for contextdb — scan, insert, upsert, delete
Schema definition and migration support for SQLModel Rust
Event-sourced workflow engine for durable, long-running processes
Persistence layer for VEX Protocol
pgvector search backend for TinyQuant
Expression evaluation, type coercion, and function registry for KyuGraph
rsql driver
JIS-gated vector storage with TBZ envelopes
Embedded graph database with OpenCypher queries, vector search, and columnar storage
Common types, memory allocators, and utilities for Grafeo
Embedded vector database library for Rust - like SQLite for vectors
MongoDB persistence layer for AI agent conversations with context management
Server for database-mcp
Apache OpenDAL Cloudflare KV service implementation
Database agnostic expressions
Graph storage and traversal for ManifoldDB
A lightweight backend framework combining Actix-Web, SQLx, and declarative macros for rapid API development
Binder traits for connecting sea-query with postgres driver
Built-in routines (functions and procedures) for ReifyDB
Stateful graph engine for Cognis: typed Graph<S>, Pregel-style superstep executor, per-field reducers, interrupts, time-travel via checkpointers (in-memory, SQLite, Postgres), and streaming
GQLite bindings for the Rune programming language
Cache manager implementations for Sockudo
Table, Column, and operation traits for the Vantage data framework
Core Rust RAG engine with optional Flutter Rust Bridge integration
Private crate for schema utilities for the Polars DataFrame library
example crate for _SPEC testing
Query execution and processing engine for ReifyDB
High-performance ClickHouse integration for Apache DataFusion with federation support
Configuration types for the mem7 memory engine
A comprehensive, production-ready Rust client library for Supabase with full cross-platform support (native + WASM)
Admin CLI for the raft distributed KV store: put, get, delete, status, transfer
Rate limiter implementations for Sockudo
Core domain types for ferriorm ORM - zero external dependencies
Data-layer primitives for Shelly LiveView (schemas, changesets, repo, migrations)
validator for RDF data, implemented in Rust
A minimalist CLI for unDraw illustrations
Microsoft SQL Server database driver for Prax ORM
Swift FFI bindings for kiromi-ai-memory. Ships an XCFramework + Swift Package consumed by macOS/iOS callers.
Cognitive memory MCP server — persistent, structured, cross-session memory for AI agents
Rationale-tracing GraphRAG engine — auto-builds knowledge graphs from text with full traceability
Schema parser for ferriorm ORM - parses .ferriorm files into AST
A WebSocket client for interacting with the Satori database
SQL component for rust-camel (PostgreSQL, MySQL, SQLite via sqlx)
StartDB – Embedded NoSQL Database in Rust
Apache OpenDAL lakeFS service implementation
Core runtime and dataflow engine for Pulse — defines execution graph, operators, and streaming primitives
Core discovery framework for RuVector dataset integrations - find hidden patterns in massive datasets using vector memory, graph structures, and dynamic min-cut algorithms
A lightweight, ORM for PostgreSQL, built on top of SQLx
Query engine and database management for Grafeo
A CLI to query your Azure Cosmos DB instances
Native AWS S3 storage backend for icechunk
Trait Embedder + HTTP remote backends + embedder_id/dim invariants (local impl provided by gradatum-engine)
Query engine for Aegis database
Core engine for AvocadoDB - deterministic context compilation for AI agents
The Turso parser library
Agent Persistence
Apache Ballista + DataFusion + Iceberg companion crate for rig-compose. Scaffolding; iceberg-rust integration pending toolchain verification.
Sharded Pub/Sub broker for Kōra
opiniated SQLx ORM for PostgreSQL
Core functionality for rust-queries-builder - type-safe query builder for Rust collections
A MySql implementation of an event repository for cqrs-es
server database library for atuin
Core type definitions for FrankenSQLite
Model Context Protocol server for mnem - the AI-native, local-first memory substrate for agents
Django app scaffolding for Alembic
SQLite and HNSW vector storage layer for Brain OS
Rust SDK for the Shilp Vector Database API
Helper libraries for interacting with Hydrolix
Time-series optimizations for OxiRS semantic web platform
Embedding providers for MemMe — ONNX local inference, OpenAI, and Ollama
Export vespertide table definitions into ORM-specific models
PostgreSQL Stored Procedure reaction plugin for Drasi
Evaluation runners and output parsers for reflect
Common functionality for DataFusion query engine
Drasi Core Garnet/Redis Index Plugin
The SpacetimeDB SQL AST and Parser
Test support helpers for Iridium SQL server integration tests
Embedded log-structured key-value store with optional auth helpers
The official rust client of Apache Fluss (Incubating)
High-performance temporal vector database — treats time as a geometric dimension of embedding space
Pulumi schema returned as protobuf
that adds index-based query acceleration to DataFusion TableProviders
A tiny ORM for CRUD operations built on top of SQLx QueryBuilder
An opinionated wrapper around fjall
PostgreSQL persistence backend for RDAPify (query history, caching)
Core compiler and runtime support for very_simple_rest and the vsr CLI
Bindings for emulating a MySQL/MariaDB server
Typed embedded database for application data — user-facing facade over typra-core
SQL database connector for Saola query engine (PostgreSQL, MySQL, SQLite, MSSQL)
A database driver for ScyllaDB to be used with the Rust sqlx framework
Rust SQLite engine for Tigrbl
SQL validation and identifier utilities for dbmcp
Graph executor for contextdb — bounded BFS, DAG enforcement, typed edges
Turso sync engine
MVCC transaction manager for contextdb
Connection adapters and horizontal scaling for Sockudo
Drasi Core RocksDb Index Plugin
Session and Unit of Work for SQLModel Rust
Schema types, DDL generation, and migration file generation for yauth — zero ORM dependencies
DataFusion Query Optimizer
Raft consensus implementation: election, replication, snapshots, linearizable reads, leadership transfer, joint consensus
MongoDB migrations management tool (fork of kakoc/mongodb_migrator with all deps updated)
SDK for building ReifyDB operators, procedures, transforms and more
I can't believe it's a database | Simple embedded 3-in-1 database
Storage, query language, and plugin adapters for Grafeo
Hybrid semantic search with SQLite, FTS5, and HNSW — built for AI agents
Physical expression implementation for DataFusion query engine
SQLite driver for Toasty
An ergonomic and type-safe ORM for database interactions
SQL parser, planner, and optimizer for NodeDB
Protobuf serialization of DataFusion logical plan expressions
Apache OpenDAL hdfs service implementation
A lightweight AI utilities library for Rust
create sql models from sqlx database (currently just postgres)
working with SQLx in a structured and efficient way, both when developing and running
SQL dialect renderers for Nautilus ORM
PostgreSQL wire protocol server for Mnemo — accept SQL queries over pgwire
Datafusion flight sql server
SQL journal and snapshot store for rakka — sqlx-backed; SQLite default; Postgres / MySQL / MSSQL features
High-performance HTAP embedded database with Rust core
embedded vector database for local AI and RAG workloads
Type-safe SQL parser and builder with compile-time validation
RAG chat API with LLM integration and natural language to SPARQL translation
A high-performance, Postgres-backed ReBAC (Relationship-Based Access Control) engine inspired by Google's Zanzibar paper
Self-organizing graph memory for AI agents. Single binary, zero dependencies.
PartiQL Core
RAG-oriented SQLite wrapper for AI agent workloads
Multi-tenant coordination layer for KyuGraph: task queues, worker pools, tenant registry
ForgeKit agent layer - Workflow orchestration and AI loop
PostgreSQL UPSERT operations using sqlx
SQL validation and identifier utilities for database-mcp
SQLite-backed persistent memory and user profiles for Garudust AI agents
Rust SDK for AmateRS
Rust wrapper for librdb (Redis RDB parser)
Multi-vault registry + lifecycle (create/list/swap/delete) + forward-compat
Storage engine for Aegis database
MySQL Stored Procedure reaction plugin for Drasi
PostgreSQL storage implementation for oxide-outbox using sqlx
Point-in-time snapshots and backup for Ruvector vector databases
NAPI-RS bindings for ruvector-router-core vector database
PostgreSQL renderer for qcraft
PartiQL Expression Evaluator
Interactive graph visualizer for KyuGraph databases
rsql snowflake driver
Distributed AI Swarm Runtime
Tansu Auth
The scripts crate for Atuin
Vectorized query executor with optional Cranelift JIT for KyuGraph
Core domain types for TSQL
InfuseDB is a Document oriented KV database
Agent spawner for Terraphim with health checking and output capture
Episodic and semantic memory engine with hybrid search for Brain OS
Traits and types for logical plans and expressions for DataFusion query engine
Idiomatic Rust bindings for zvec vector database
Declarative SQL schema migrations
Chained-HMAC ledger of agent-on-agent deal envelopes (v0.4.0 P1-5). Substrate for Anthropic Project Deal-style commerce.
Lightweight serverless HTAP engine — Rusqlite (OLTP) + DuckDB/DataFusion (OLAP) with CDC replication
A Topology Ontological Clustering Engine for AI Agent Memory
Core engine for a Rust-native log-structured time-series table format (metadata log + coverage bitmaps)
Web Server Code Generator
Embedded database engine for agentic memory — relational, graph, and vector under unified MVCC transactions
A query DSL extension for SQLx
Apache OpenDAL OneDrive service implementation
Sync server for contextdb — NATS-based replication with conflict resolution
A blazingly fast, simple JSON database for Rust
Toolkit to easy use sqlx
Built-in tools (file ops, bash, web, LSP) for the WRAITH AI coding agent
high-performance memory system for AI applications with advanced RAG capabilities, vector-graph hybrid storage, and adaptive learning. Built with Rust for scalability and efficiency.
GQL Parsing library, including GQLS
Fast vector database with HNSW indexing for ARM64 and x86-64
An async Rust ORM that auto-generates tables and CRUD from structs
Interface for agent sql persistence
The SQLite of Vector Database in Rust
ADBC driver for Apache DataFusion
🐚 The sync version of SeaORM
parsing comments from sql files and using them for documentation generation
Pyarrow bindings
Type-safe SQL query builder for SQLModel Rust
Code generation from TOML schemas for crdt-kit: persistence layer with repositories, events, and sync
Database repository layer for Ceres with pgvector support
Query execution engine for SparrowDB embedded graph database
Hash index and index management for KyuGraph storage
Interactive CLI for contextdb — explore relational, graph, and vector queries in a REPL
MySQL driver for Toasty
CLI tool for the Prax ORM
PeeringDB adapter for Alembic
Conflict-free idempotent delta batches for KyuGraph ingestion
server postgres database library for atuin
Cognitive memory system for AI applications
Admin dashboard for Mnemo memory database
HTAP database: turso writes + DataFusion reads
Runtime abstraction used by SQLx, the Rust SQL toolkit. Not intended to be used directly.
AclPolicy trait + globset matching + ACLFilter visibility marker
Sql catalog for the unofficial Iceberg table format implementation
Storage engine (WAL, node store, edge store, CSR) for SparrowDB
Apache Iceberg DataFusion Integration
PartiQL conformance test runner
Distributed replication for Aegis database
rsql drivers library
Small educational in-memory vector database with REST API, append-only durability, brute-force search, and adaptive heartbeat feat for RAG hallucination mitigation
Proc macro for generating insert statements for sqlx
High performance query engine for both offline compute and online serving
PartiQL Type Definitions
Rust bindings to zvec, an in-process vector database by Alibaba
MS SQL Server Stored Procedure reaction plugin for Drasi
HTTP server for AvocadoDB - deterministic context compilation for AI agents
gRPC API server for Mnemo
Rust port of the skypydb reactive and vector database client
Code Generator for SeaORM
Binder traits for connecting sea-query with Rusqlite
SERVICE planner and GraphQL stitching for federated SPARQL queries
Query log files with SQL using DataFusion and regex pattern macros
Apache OpenDAL D1 service implementation
Binder traits for connecting sea-query with diesel
A Kafka API Proxy
Hierarchical vector memory for AI agents — perspectives, salience, aging, identity
Domain layer for sabiql
Backend-agnostic storage, tiered memory, and document management for the Brainwires Agent Framework
Command Line Client for Ballista distributed query engine
High-performance embedded property graph database with Cypher query support
Vector database for agentic applications
Fetch or produce (with validation when backed by a schema) messages to a topic
Turso sync SDK kit
A high-performance, in-memory vector database optimized for AI agent workloads
LLM abstraction layer for MemMe — OpenAI and Ollama providers
Hierarchical Attention Tree: 100% recall at 70x faster build times than HNSW. A new database paradigm for AI memory and hierarchical semantic search.
rsql core library for creating a command line SQL interfaces
Apache OpenDAL koofr service implementation
Monitoring and observability for Aegis Database
Next page?