awesome-repositories.com
Blog
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
ravendb avatar

ravendb/ravendb

0
View on GitHub↗
ravendb.net↗

Ravendb

RavenDB is a multi-model NoSQL document database designed for high-performance, ACID-compliant data storage. It persists structured information as schema-flexible JSON documents and utilizes a unit-of-work session pattern to track entity changes and batch modifications into atomic transactions. The platform is built on a distributed architecture that supports horizontal scaling through sharding and ensures high availability via multi-node, master-to-master cluster replication.

The database distinguishes itself through a self-optimizing query engine that automatically creates and maintains indexes based on runtime filtering patterns, eliminating the need for manual schema configuration. It includes a server-side scripting engine that allows for complex data transformations and automated background workflows directly on the database server. Furthermore, the system functions as an event-driven platform, streaming real-time document changes to external workers to facilitate asynchronous processing and reactive architectures.

Beyond core storage, the platform provides advanced search capabilities, including full-text, spatial, faceted, and semantic vector search. It integrates generative AI workflows by generating and storing vector embeddings, enabling context-aware similarity searches and automated data enrichment. The system also features comprehensive security primitives, such as X.509 certificate-based authentication, transparent encryption at rest and in transit, and detailed audit logging.

The project provides a web-based management studio and a command-line interface for cluster administration, monitoring, and configuration. It is available as a containerized deployment and supports integration with external systems through standard protocols and automated extract, transform, and load pipelines.

Features

  • JSON Document Storage - Persists structured data as schema-flexible JSON documents with support for nested objects and binary attachments.
  • ACID-Compliant - A multi-model NoSQL database that provides ACID-compliant storage, built-in indexing, and integrated AI-driven workflows for enterprise applications.
  • Visual Database Management - Provides a graphical management interface for monitoring, configuring, and interacting with the database server.
  • Atomic Field Operators - Ensures data consistency by executing compare-and-swap operations that prevent race conditions.

Búsqueda con IA

Explora más repositorios increíbles

Describe lo que necesitas en lenguaje sencillo: la IA clasifica miles de proyectos open-source curados por relevancia.

Start searching with AI
3,961 estrellas·855 forks·C#·4 vistas
  • Patch-Based Concurrent Updates - Uses optimistic concurrency to detect if a document was modified by another client since it was loaded, preventing accidental overwrites.
  • Atomic Transaction Coordinators - Defines default optimistic concurrency modes and controls atomic write behavior during cluster-wide transactions.
  • Data Consistency Models - Uses transactional sessions to ensure atomic operations and reliable state management.
  • Atomic Transaction Execution - Performs ACID-compliant operations across multiple nodes to ensure data consistency and atomic updates.
  • Document Deletion Operations - Performs create, read, update, and delete operations on structured data records.
  • Cluster-Wide Data Synchronizers - Executes ACID-compliant writes across a cluster that are tolerant to network partitions.
  • Database Backup and Restore - Reconstructs databases from full and incremental backup files, supporting both logical JSON dumps and high-speed binary snapshots.
  • Database Connection Management - Maintains persistent connections to database clusters with built-in authentication, topology tracking, and request caching.
  • Database Query Execution - Provides expressive query languages to retrieve and filter data from stored collections.
  • Database Sharding Architectures - Partitions large datasets across multiple nodes to achieve horizontal scalability and handle high-volume workloads.
  • Distributed Atomic Transactions - Ensures ACID-compliant writes across a partitioned cluster to maintain data integrity.
  • Distributed Cluster Execution - Performs ACID-compliant writes across a distributed cluster while maintaining partition tolerance.
  • Distributed Database Clusters - Supports highly available database clusters with automated replication, failover, and horizontal scaling across multiple nodes.
  • Distributed Sharding Architectures - Partitions large datasets across multiple nodes to achieve horizontal scalability and distribute processing load.
  • Data Partitioning - Distributes large datasets across multiple nodes to manage extreme storage volumes and maintain performance as data grows.
  • Document Patching Utilities - Performs partial updates to a document on the server in a single transaction.
  • Document Stores - Provides ACID-compliant NoSQL document storage for application data.
  • Full Text Search - Provides high-performance keyword-based search across document fields with support for configurable analyzers and result boosting.
  • Document Retrieval by Identifier - Fetches documents directly from internal storage using unique identifiers without invoking the search engine.
  • Inter-Node Data Synchronization - Maintains data consistency across a cluster by automatically replicating all writes between nodes.
  • JSON Document Stores - Persists structured data as schema-flexible JSON documents supporting nested objects and arrays.
  • Multi-Master Replication - Synchronizes document changes across multiple database nodes using master-to-master replication to ensure data availability and consistency.
  • Optimistic Concurrency Control - Enforces data consistency by checking for concurrent modifications during save operations to prevent lost updates.
  • Optimistic Concurrency Controls - Detects if a document was modified by another process since it was loaded to prevent overwriting changes via optimistic concurrency.
  • Persistent Storage Volumes - Binds database nodes to persistent storage volumes to ensure data, logs, and operational history survive pod restarts and rescheduling.
  • Automatic Indexing - Automatically creates and maintains indexes based on runtime filtering patterns to optimize performance without manual configuration.
  • Automatic Indexing Engines - Analyzes filtering criteria at runtime to automatically create and maintain optimal indexes for data retrieval.
  • Search Index Management - Provides comprehensive tools for configuring, querying, and maintaining search indexes to optimize performance.
  • Search Indexing - Retrieves documents using automated or custom indexes that process data asynchronously for high-performance search.
  • Distributed Data Indexing - Supports both static manual indexes and self-optimizing auto-indexes to ensure high-performance data retrieval.
  • Full Text Indexing - Provides high-performance indexing and retrieval of textual content, including support for complex queries and compressed storage.
  • Automated Indexing - Optimize data access by automatically utilizing indexes for all queries to ensure high performance and avoid full dataset scans regardless of total volume.
  • Search and Indexing - Creates static or self-optimizing indexes to control precomputation and query performance.
  • Index Definitions - Precomputes data using either manual static definitions for full control or self-optimizing auto-indexes.
  • Document-Based Querying - Retrieves filtered results from the database using a query language that leverages automated indexing.
  • Query Language Implementations - Uses a SQL-style query language to perform advanced searches including full-text, faceted, spatial, and similarity lookups.
  • SQL Query Execution - Retrieves data using a powerful SQL-style query language for flexible and precise data retrieval.
  • Database State Persistence - Anchors node data to persistent volumes to ensure state survives restarts or failures.
  • Asynchronous Indexing - Processes raw documents into searchable indexes in the background to maintain high performance during write operations.
  • REST API Interfaces - Exposes a comprehensive REST API for document retrieval, data uploads, and attachment management.
  • Cluster Coordination - Executes ACID-compliant writes across a partitioned cluster to ensure data integrity.
  • High Availability Clustering - Maintains high availability and data integrity through multi-node replication and cluster-wide ACID transactions.
  • Database High Availability - Distributes server nodes across separate machines to ensure the database remains active if a single node fails.
  • Server-to-Client Event Emissions - Enables clients to subscribe to server-side events for documents, indexes, and counters to eliminate polling.
  • Server-Side Event Subscriptions - Pushes real-time notifications to clients regarding document, index, and operation changes.
  • Real-Time Message Streaming - Streams real-time updates from the server to trigger immediate actions in client applications.
  • Typed LINQ Queries - Fetches data using LINQ, low-level API calls, or raw query language, automatically translating requests into optimized server-side lookups.
  • Data Encryption - Provides transparent encryption for data at rest and in transit without requiring application code changes.
  • Security and Access Control - Enforces robust server security using X.509 certificate authentication and fine-grained access control policies.
  • Sensitive Data Encryption at Rest - Protects stored data using authenticated encryption at the storage layer to ensure security if disk access occurs.
  • Data Sharding - Partitions database content into subsets across multiple nodes to enable horizontal scaling for large datasets.
  • Unit of Work Patterns - Uses a unit-of-work pattern to track entity changes and batch operations into atomic transactions.
  • Consensus Cluster Recoveries - Ensures administrative actions are executed in a consistent order across all nodes using majority agreement.
  • Database Performance Monitoring - Tracks critical system metrics and health indicators to facilitate proactive database maintenance.
  • Database Connectivity Drivers - Provides language-specific drivers to establish secure, persistent connections between applications and the database.
  • Cross-Shard Query Broadcasting - Executes queries against multiple database shards and merges results into a single dataset.
  • Multi-Agent Coordination Systems - Orchestrates specialized AI agents to handle complex tasks by routing work between them.
  • AI Agent Conversation Management - Orchestrates multi-agent interactions including support for attachments and integration with external providers.
  • Database-Native Agents - Executes database-native agents that query and act on data, supporting vector search and intelligent task automation.
  • Server-Side Agents - Configures server-side conversational components to autonomously handle requests and access database records.
  • AI Automation Workflows - Integrates AI agents and tasks directly into data operations to automate analysis and decision-making.
  • External AI Model Connectors - Configures secure links to external chat and embedding providers to enable AI-driven workflows.
  • Multimedia Processing - Automates the extraction and analysis of content from binary attachments like PDFs and images using AI models.
  • Model Interaction Proxies - Acts as a secure server-side proxy to orchestrate communication between applications and AI models.
  • Chat Model Interactions - Communicates with chat models to perform reasoning and summarization directly against stored data.
  • Contextual Embedding Generation - Prepends contextual text to data chunks before generating vector embeddings to improve search accuracy.
  • Conversational Proxies - Acts as a secure server-side intermediary between clients and AI models to manage conversations and trigger database actions.
  • Generative AI Integration Patterns - Embeds intelligent AI agents and vector search capabilities directly into database workflows to automate analysis and content generation.
  • Generative AI Tasks - Embeds generative AI tasks directly into application workflows to automate data analysis and content generation.
  • Natural Language Query Generators - Translates natural language descriptions into executable database queries to assist with data retrieval.
  • Text Embedding Generators - Creates vector representations of text chunks with optional contextual prefixes to improve search and retrieval accuracy.
  • Vector Embeddings - Converts document text into numeric vectors using built-in or external AI models to enable semantic similarity search.
  • Semantic Vector Search - Transforms stored content into vector representations to enable intelligent, context-aware search capabilities.
  • Data Exchange and ETL - Automates data movement and transformation between the database and external systems via ETL pipelines.
  • Data Pipelines and ETL - Transforms and exports data to external destinations like SQL or message brokers using ETL processes.
  • Data Processing and ETL - Provides automated extract, transform, and load pipelines to move data between databases and external targets.
  • Task Health Monitors - Provides a centralized dashboard to track the health and error status of data transformation and AI tasks.
  • Data Archiving - Moves old documents to archival storage to maintain accessibility while improving primary performance.
  • Document Content Optimizations - Optimizes storage by automatically compressing document content streams.
  • Automated Processing - Monitors database changes to automatically process document content using AI models for summarization and classification.
  • Distributed Cluster Transactions - Ensures ACID-compliant writes across a distributed cluster while maintaining partition tolerance.
  • Automated Enrichment - Provides automated document enrichment by monitoring collections and updating records based on AI model responses.
  • Analytics Integrations - Connects to external analytics platforms using standard protocols to import and visualize stored data.
  • Configurable Retention Profiles - Defines automatic policies for creating and purging document snapshots to manage storage usage.
  • Atomic Key Lookups - Retrieves documents by referencing cluster-wide consistent keys directly within database queries to ensure data integrity during lookups.
  • System Data Backup Schedules - Creates scheduled full and incremental backups to prevent data loss.
  • Scheduled Database Backups - Performs full and incremental backups of data on a fixed timetable.
  • Automatic Record Timestamping - Schedules the deletion of records by attaching a timestamp to their metadata.
  • Full and Delta Backups - Performs automated full and incremental backups to ensure data durability and disaster recovery readiness.
  • Bulk Data Import Management - Inserts large volumes of data into the database efficiently to minimize overhead.
  • Bulk Data Ingestion - Optimizes the ingestion of large volumes of data to minimize overhead and increase throughput.
  • Atomic Document Transforms - Updates documents in bulk using scripts to change data patterns without manual iteration.
  • Server-Side Script Executions - Runs logic on the server to perform complex updates, including renaming properties or cloning documents.
  • Change Data Capture Streams - Triggers background worker routines by subscribing to document updates to enable asynchronous processing pipelines.
  • Cluster Load Balancing - Distributes read and write requests across cluster nodes to optimize traffic and ensure reliability.
  • Cross-Database Data Transfers - Exports or imports database contents using a JSON format to facilitate data migration, backups, or synchronization.
  • Data Analytics Engines - Transforms and exports database documents into partitioned files to enable high-performance analytical querying.
  • Client-Side State Caches - Controls the size and duration of local data caches to optimize retrieval performance and reduce unnecessary network requests.
  • Cross-Request Data Caches - Caches database requests locally to minimize network latency and improve application responsiveness.
  • Data Change Subscriptions - Streams document changes to external workers as durable, ongoing tasks to ensure reliable background processing of data updates.
  • Document Updates - Triggers worker routines automatically when specific document fields are updated.
  • Data Compression Algorithms - Reduces storage footprint by automatically applying compression to document content.
  • Database Backup Management - Provides automated scheduling and retention policy management for database snapshots.
  • Time Series Data Storage - Collects and manages sequences of timestamped values with automatic compression and segmentation.
  • Specialized Data Extensions - Stores specialized data types including time series, binary attachments, and historical revisions alongside standard records.
  • Vector Data Connectivity - Links stored vector embeddings to generative AI models and autonomous agents to provide relevant document context.
  • Data Lifecycle Management - Manages document expiration, archival, and refreshing to optimize storage usage and maintain performance.
  • Data Import and Export - Transfers data between databases using JSON with optional scripts to transform or filter documents.
  • Database-to-Kafka Connectors - Streams document changes to Kafka topics using custom transformation scripts.
  • Data Integration Pipelines - Orchestrates data movement and transformation between the database and external systems like SQL and search engines.
  • Document Lifecycle Management - Cleans up expired documents or triggers re-processing based on defined schedules to maintain data freshness and storage.
  • File Attachment Systems - Stores binary files directly in the database or offloads them to remote cloud storage.
  • Binary Attachment Systems - Stores binary assets directly alongside documents to ensure they remain searchable and scalable.
  • Large Data Offloading - Stores large binary files in external object storage to reduce database size while maintaining access.
  • Uniqueness Enforcement - Prevents duplicate entries across a cluster by using atomic key-value pairs to reserve identifiers.
  • Data Redaction - Replicates and redacts data into dedicated databases for secure, limited-access sharing.
  • Spatial Querying - Supports spatial filtering and retrieval using radius searches, polygons, and coordinate-based lookups.
  • Data Replication - Executes custom scripts to filter, reshape, or split source documents into multiple destination collections during data synchronization.
  • Cross-Cluster Table Replication - Copies data from one database to another in a separate cluster to provide live replicas for disaster recovery and failover purposes.
  • Cluster Data Synchronizers - Synchronizes data across clusters to ensure high availability and disaster recovery.
  • Cross-Cluster Replication - Synchronizes indices and data patterns across separate database clusters to ensure high availability and disaster recovery.
  • Database Cluster Replications - Synchronizes data across clusters to ensure high availability and partition-tolerant ACID writes.
  • Data Revision Tracking - Maintains a complete history of document changes, allowing users to audit past states and revert to previous versions.
  • Query Projections - Transforms retrieved documents into specific field sets during query execution to optimize data transfer.
  • Data Sharding - Distributes terabytes of data across multiple nodes to achieve extreme horizontal scale.
  • Dynamic Shard Rebalancing - Moves data buckets between shards to balance storage load and resource usage while maintaining database availability and performance.
  • BI Tool Connectors - Provides connectors to bridge database data with business intelligence reporting tools.
  • Data Stream Subscriptions - Streams document updates to external workers for asynchronous processing to enable reliable event-driven architectures.
  • Data Synchronization Pipelines - Move and transform data to SQL databases, search engines, or data lakes via ETL pipelines.
  • Counter and Attachment Synchronizers - Transfers binary attachments, counters, and time series data to destination databases.
  • Data Transformation Scripts - Applies scripts to modify documents at scale or moves data between databases and external systems.
  • Client-to-Cluster Data Uploaders - Pushes batches of documents to external workers for processing with progress tracking.
  • Document-to-Search Index Synchronizers - Transfer document data from the database to external search clusters using automated extract, transform, and load processes to maintain searchable indices.
  • Document Chunking and Embedding Pipelines - Automates the ingestion pipeline by chunking documents and generating vector embeddings for semantic search and AI integration.
  • Database GUIs - Offers a web-based management studio for configuring and monitoring the database server.
  • Database Operations - Provides a visual interface for managing data, monitoring cluster health, and configuring database settings.
  • AI-Powered Analysis - Provides AI-driven analysis of database content to generate insights and troubleshooting support.
  • Relational Record Fetching - Retrieves associated records in a single request to eliminate redundant roundtrips and resolve performance bottlenecks.
  • Sharded Query Streams - Retrieves results from map-reduce queries across sharded databases using a streaming approach.
  • Shard-Specific Query Routing - Directs queries to a specific shard using document identifiers or prefixes to improve performance.
  • Flexible Scope Transactions - Determines whether a batch of changes executes on a single node or across an entire cluster atomically.
  • Database Version Migrations - Performs in-place data migration between major versions without requiring manual export and import processes.
  • Distributed Data Synchronization Systems - Propagates changes to external queues, storage, or analytical engines to maintain consistency.
  • SQL-like Queries - Retrieves and filters documents using a declarative, SQL-like syntax optimized for document structures.
  • Document Array Manipulations - Adds, modifies, or removes items from an array within a document using server-side logic.
  • Document Schema Enforcement - Validates document structure against defined rules during write operations to prevent malformed records.
  • Bulk Patching - Transforms documents across the database using scripts to update multiple records simultaneously.
  • Document Subscriptions - Executes worker routines automatically when specific fields in a document are updated.
  • Document Versioning - Assigns change vectors to migrated documents to preserve their correct order and history across shards.
  • Time-Series Value Trackers - Stores and queries sequences of timestamped values to support monitoring, activity tracking, and event-driven reporting.
  • External Document Synchronization - Transfers and transforms database documents to external destinations using automated background tasks.
  • Bulk Data Ingestion - Inserts a high volume of documents using an optimized process to reduce resource overhead.
  • External Data Integrations - Connects to external data sources and message queues to synchronize and enrich local database content.
  • External Embedding Imports - Stores pre-computed vector representations from external sources to facilitate similarity search for non-text content.
  • External System Integrations - Synchronizes data with external databases and analytics platforms using automated ETL and ingestion pipelines.
  • Similarity-Based Document Retrievers - Identifies and returns documents similar to a specified record by analyzing shared content fields and filtering out common stop words.
  • General Data Backups - Automates the creation of data snapshots and provides restoration processes to ensure data safety.
  • Geospatial Querying - Enables searching and sorting documents based on physical map coordinates and locations.
  • Dynamic Query Execution - Analyzes filtering criteria at runtime to automatically create or select an optimal index for retrieval.
  • In-Place Data Modifiers - Applies server-side scripts to modify or update large sets of documents efficiently without needing to retrieve them to the client.
  • Large Dataset Streaming - Processes query results one by one from the server to minimize memory overhead when handling large volumes of data.
  • Schema Validators - Enforces data structure integrity by applying predefined schemas to documents during storage operations.
  • Client Convention Configurations - Customizes how the client interacts with the database through configurable conventions and event hooks.
  • Large-Scale Dataset Management - Transfers a high volume of documents using an optimized process to reduce ingestion time.
  • Deferred Query Executions - Defines queries that execute on the server only when the application explicitly accesses the results to save network bandwidth.
  • Message Queue Integrations - Provides libraries and connectors for publishing documents to or ingesting messages from external message brokers.
  • Kafka Message Consumers - Consumes messages from Kafka topics and processes them into database documents using custom transformation scripts.
  • Time-Based Expirations - Cleans up documents automatically based on a defined expiration schedule.
  • First-Level Caching - Provides a session-scoped cache that maps entity identifiers to object instances to ensure referential integrity within a single unit of work.
  • Centralized Backup Configurations - Defines centralized backup configurations that automatically apply to all databases on a server.
  • GUI Management Tools - Provides a browser-based management studio for configuring the server and administering data.
  • Related Document Embeddings - Fetches and embeds data from related documents into the target record during transformation.
  • PostgreSQL Wire Protocol Implementations - Serves stored documents to external tools by implementing the standard PostgreSQL wire protocol.
  • Document Field Updates - Modifies specific fields within a document on the server in a single transaction.
  • Proximity Queries - Orders query results based on their calculated distance from a specific geographical point.
  • Query Performance Monitors - Provides granular, per-shard timing metrics for query execution to identify performance bottlenecks.
  • Result Streaming - Streams query results from the server to avoid the memory overhead of loading large datasets into the application.
  • Raw Query Interfaces - Allows submission of raw database-specific query strings to bypass abstraction layers for complex retrieval.
  • Real-time Data Subscriptions - Streams real-time document changes to external worker routines to enable event-driven architectures and asynchronous background processing.
  • Similarity-Based Related Document Retrieval - Retrieves a list of documents similar to a specific record by analyzing indexed fields to identify related content.
  • Map Index Definitions - Defines mapping functions using LINQ or JavaScript to specify which document fields should be indexed for efficient searching.
  • In-Process Engines - Runs the database engine within the application process to eliminate network overhead and simplify deployment.
  • Nested JSON Field Indexes - Flattens arrays within documents into individual entries to enable granular filtering and computation on specific items stored inside lists.
  • Dynamic Index Fields - Generates index fields based on document content at indexing time, enabling searches on properties not predefined in the index schema.
  • Cross-Collection Indexing - Aggregates data from different document types into a single index to enable unified querying and searching across polymorphic data sets.
  • Indexed Data Aggregations - Combines data from several distinct collections into a single index to perform unified reduction and aggregation operations.
  • Indexing Exclusion Filters - Applies filtering conditions directly within the index definition to improve query performance by narrowing the set of indexed terms.
  • Conditional Indexing - Narrows the scope of an index by applying conditional logic during the mapping process to reduce the volume of data scanned at query time.
  • Faceted Navigation - Enables users to slice and navigate large datasets by categorizing results into groups for intuitive exploration.
  • Faceted Search Engines - Provides backend logic for aggregating search results into categories and ranges to enable multi-dimensional data filtering.
  • Faceted Search Implementation - Implements faceted search to allow users to slice and navigate large datasets by categorizing results based on specific fields.
  • Search and Analytics Engines - Combines full-text, spatial, faceted, and semantic vector search capabilities with precomputed indexes for high-performance data retrieval.
  • Semantic Search Engines - Enables information discovery based on conceptual meaning and vector similarity rather than exact keyword matching.
  • Automated Indexing - Automatically generates and optimizes search indexes based on query patterns to ensure high performance without manual configuration.
  • Custom Field Indexing - Creates server-side indexes using LINQ or JavaScript functions to extract specific document fields for high-performance querying.
  • Full-Document Indexing - Aggregates all property values from a document into a single searchable field to enable full-text search without explicit schema definitions.
  • Partial Field Extractions - Provides the ability to extract and index specific portions of data, such as years from dates, to enable targeted search queries.
  • Spatial Indexing - Optimizes spatial search performance by selecting between bounding box, quad tree, or geohash strategies based on data requirements.
  • Index Memory Management - Configures search engine behavior and memory management to reduce resource consumption during indexing operations.
  • Name-Based Location Search - Finds and sorts documents based on geographic coordinates and spatial proximity.
  • Search Result Sorting - Orders returned documents by their physical proximity to a specific geographical point.
  • Server-Side Scripting - Runs custom logic on the server to perform complex data transformations or conditional updates.
  • Sharding Orchestration - Automatically routes client requests to the appropriate shards and aggregates results.
  • Cross-Shard Data Aggregation - Applies filtering logic after gathering results from all shards to ensure accurate global aggregation.
  • Sink Data Loading - Enables receiving and storing data streams directly into the database via sink configurations.
  • Spatial Indexing - Filters and sorts documents based on geographical coordinates or geometric shapes using indexed spatial fields.
  • SQL Query Interfaces - Executes custom SQL queries against stored collections for reporting and analysis.
  • Storage Lifecycle Management - Automates the archival, expiration, and versioning of data to ensure compliance and storage efficiency.
  • Storage Schema Validations - Enforces structural guarantees on documents using JSON Schema validation.
  • Cold Data Tiering - Moves old documents to an archive to maintain access while improving active system performance.
  • Stream Ingestion - Supports real-time streaming ingestion from external message brokers like Kafka or RabbitMQ.
  • Stale Data Purging - Moves rarely accessed documents to secondary storage to reduce disk footprint and improve performance.
  • Index Optimizations - Utilizes precomputed static and auto-indexes to accelerate query execution and ensure high-performance data retrieval.
  • Specialized Index Builders - Builds static or self-optimizing indexes to precompute data for high-performance retrieval.
  • Document-to-Relational Mappings - Extracts, transforms, and loads document data into relational database tables using custom mapping scripts.
  • Document-to-Warehouse Mappings - Streams document updates to a data warehouse by executing transformation scripts that map document fields to target table columns and handle atomic batch transactions.
  • Time-Series Data Modeling - Stores and aggregates high-frequency, timestamped data points natively for efficient time-based analysis.
  • Time Series Querying - Performs high-performance calculations and data retrieval over time-stamped values using flexible query expressions and pre-computed segment headers.
  • Time Series Inclusion - Pre-fetches related time series data during document retrieval to eliminate additional server round-trips.
  • Transactional Message Commits - Ensures data integrity by committing batches of consumed messages to the database as atomic operations, rolling back on failure.
  • Vector Search - Executes similarity searches on stored data using AI-generated embeddings to retrieve contextually relevant information.
  • Embedding Generation - Converts application data into AI-ready vector representations automatically for search and analysis.
  • Vector Similarity Search - Retrieves documents based on contextual relevance by comparing numeric vector embeddings.
  • Visual Similarity Searches - Matches images using visual similarity by comparing embeddings created from image data.
  • Advanced Search Techniques - Supports a comprehensive suite of search capabilities including full-text, faceted, spatial, and similarity lookups.
  • Application Version Enforcement - Validates container image versions and prevents accidental downgrades to ensure cluster stability during updates.
  • Automation Task Orchestration - Automates data movement and processing tasks with persistent error tracking and health monitoring.
  • Server Configurations - Applies database configuration options via environment variables for consistent, version-controlled deployments.
  • Database Audit Trails - Maintains a detailed audit trail of user connections and administrative actions for security and compliance.
  • Document Change Streams - Pushes batches of documents to a client for processing with server-side progress tracking.
  • Entity Identity Maps - Tracks loaded entity instances in the session to ensure object consistency and prevent redundant re-fetching.
  • Session Entity Trackers - Maintains a reference to retrieved documents within the current session to monitor changes and manage state.
  • Document Revision Tracking - Captures snapshots of documents over time to enable auditing and reverting to previous states.
  • Atomic Counters - Tracks numeric values using scalable, conflict-free counters.
  • Document-Associated Counters - Increments, deletes, or retrieves numeric counters associated with a document through server-side operations.
  • Global Client Conventions - Customizes global client behavior including serialization, ID generation, and caching to align with application requirements.
  • CLI and HTTP Server Interfaces - Provides both a graphical administrative studio and a command-line interface for server and cluster management.
  • Document Retention Policies - Expires or refreshes documents automatically based on defined schedules and policies to maintain data storage efficiency.
  • Database CLI Administration Tools - Supports database administration through both a web-based studio and a command-line interface.
  • Database Change Triggers - Monitors database document updates to trigger asynchronous worker routines and automated workflows.
  • Background Task Execution - Runs background operations to systematically process and enrich data using AI models.
  • Server CLI - Administers the database server using a command-line interface tool.
  • Database Transaction Monitors - Retrieves the current state of cluster-wide transactions awaiting completion to assist in debugging and observability.
  • Workflow Automation Triggers - Triggers external worker routines automatically when specific document fields are updated.
  • Agent Lifecycle Management - Provides built-in orchestration for AI agent conversations and lifecycle management directly within the database.
  • Automatic Compute Scaling - Adjusts compute and storage capacity dynamically to meet performance demands without interrupting service.
  • Cluster Node Roles - Manages cluster membership, node roles, and resource allocation through a centralized administrative interface.
  • Cross-Cluster Scaling - Partitions data across nodes and maintains high availability through automated replication and cluster-wide ACID transactions.
  • Cluster Upgrades - Upgrades cluster nodes one at a time, verifying cluster health and redundancy before proceeding to prevent downtime.
  • Environment Variable Configurations - Applies server settings and operational parameters using a declarative key-value convention.
  • Container Deployment - Packages the database as a container image for deployment across various operating systems and security-hardened environments.
  • Database Cluster Deployments - Provisions and manages database clusters using declarative resources to handle topology, storage, and networking.
  • Database Deployment Automation - Exposes programmatic interfaces to allow external systems to manage and interact with the database infrastructure.
  • Database Lifecycle Management - Manages the operational lifecycle of database instances including creation, deletion, and availability monitoring.
  • Subscription Progress Persisters - Persists subscription progress on the server to allow tasks to pause, resume, or failover to new nodes without losing data.
  • Coordinación de recursos distribuidos - Manages shared resource access across multiple nodes using cluster-wide locks to ensure consistent state.
  • High Availability Clusters - Maintains data consistency and high availability through multi-node replication, cluster-wide transactions, and automated failover.
  • High-Availability Task Schedulers - Runs highly available tasks like backups and data processing with automatic failover across the cluster.
  • Database Cluster Deployments - Automates the deployment and scaling of database clusters within Kubernetes using Helm charts.
  • Database Cluster Deployments - Automates the provisioning and management of multi-node database clusters within Kubernetes using pre-configured templates.
  • Database Cluster Orchestration - Automates the deployment and scaling of a database cluster within Kubernetes using Helm charts.
  • Database Deployments - Runs the database engine within isolated container environments to ensure consistent deployment across infrastructure.
  • System Metrics HTTP Servers - Exposes system performance metrics via dedicated HTTP endpoints for programmatic access.
  • Data Synchronization Batches - Tracks modifications to entities and synchronizes them in a single transaction to reduce network calls.
  • Server Lifecycles - Starts, restarts, and monitors the status of the database process to ensure availability.
  • Rolling - Upgrades database nodes serially by verifying cluster health before and after each node restart to prevent downtime.
  • Connection and Latency Optimizers - Improves performance by controlling HTTP and TCP settings like connection pooling, compression, and timeouts.
  • Storage Block Compression - Applies compression to data blocks stored on disk to optimize storage and bandwidth.
  • Message Queue Exports - Transforms and pushes document data into external queues using custom scripts to define mapping logic.
  • Low-Level API Interfaces - Provides specialized interfaces for granular control over query execution and advanced search operations.
  • Message Broker Consumers - Retrieves and processes messages from external message brokers into database documents using custom transformation logic.
  • Data Change Notifications - Streams real-time updates to external worker routines to enable event-driven architectures based on document modifications.
  • Deferred Attachment Handlers - Stores and manages large files externally with deferred downloading for data processing workflows.
  • Remote Attachment Linkers - Links documents to external files with support for deferred downloading and caching.
  • Numerical Action Counters - Maintains scalable, conflict-free numeric values associated with documents for tracking metrics.
  • Sensitive - Locks sensitive memory regions to prevent plaintext buffers from being paged to disk.
  • Entity Property Mappings - Adjusts how entity properties are mapped to JSON, including naming formats and handling of missing properties.
  • Audit Logs - Records connection history and user activity to maintain a built-in audit trail for security monitoring.
  • Client-to-Server Authentication - Secures client-to-server interactions using certificate-based authentication with configurable toggles.
  • Client Access Authorizations - Assigns security clearances to client certificates to restrict access to administrative and database-specific privileges.
  • Client Certificate Authentication - Verifies client identity using X.509 certificates to enforce granular access control for database resources.
  • PKI Certificate Authentication - Secures inter-service communication by using X.509 certificates for mutual TLS authentication.
  • Client Certificate Management - Provides tools to enable, disable, or rotate client certificates for managing server authentication.
  • Certificate Lifecycles - Automates the generation, validation, and renewal of TLS certificates to maintain secure cluster communication.
  • Schema Compliance Auditors - Identifies documents that violate a defined schema using background indexing without interrupting write operations.
  • Encrypted Backups - Secures database backups using custom or system-specific encryption keys to protect sensitive data.
  • X.509 Certificate Parsing and Validation - Implements X.509 certificate validation to provide robust server security and access control.
  • Automated Certificate Management - Integrates with certificate authorities to automate the issuance, distribution, and renewal of TLS certificates.
  • Data Access Permission Configurators - Provides granular control over data access through role-based permissions and row-level filtering.
  • Authenticated Encryption Channels - Ensures private and authenticated data transmission using client-side certificates and encrypted communication channels.
  • Secure Database Access - Provides secure, audited database connectivity through mutual authentication and full at-rest encryption.
  • Database Access for AI - Provides AI models with secure, controlled access to query database records during conversational sessions.
  • Server Certificate Management - Enables the export, import, and renewal of server certificates to establish secure inter-cluster communication.
  • Certificate Trust Managers - Manages client authentication credentials with support for toggling status and verifying trust chains.
  • Server Access Controls - Protects server access using X.509 certificates, transparent encryption, and fine-grained access control mechanisms.
  • Document Compliance Scanners - Scans stored documents against defined schemas to identify and report violations without blocking write operations.
  • Data Schema Enforcement - Validates document structure against defined JSON schemas to ensure data integrity and consistency.
  • Master-Worker Coordination - Manages concurrent access for multiple worker instances to balance document processing loads across a cluster.
  • Distributed Counters - Tracks distributed, conflict-free numeric values associated with documents to support high-concurrency operations.
  • Actor State Persistence - Saves actor events and snapshots to a durable database to ensure state recovery.
  • Hub-and-Spoke Data Flows - Manages data flow between a central hub and multiple connected sinks with configurable synchronization and filtering.
  • Clustered Task Distribution - Runs highly available tasks like data processing and backups with automatic failover across the cluster.
  • Large Dataset Optimizations - Creates and manages indexes to accelerate search performance and improve query efficiency across large datasets.
  • Asynchronous Data Processing - Streams document updates to worker routines for decoupled, reliable background processing of data changes.
  • Distributed Series Mergers - Merges concurrent modifications from multiple clients and nodes across a cluster automatically.
  • Distributed Work Queues - Assigns background operational tasks to available nodes and automatically reassigns them if a node becomes unavailable.
  • Database Performance Alerting - Configures custom alert triggers based on database health metrics to notify administrators of performance issues.
  • Automated Server Maintenance - Schedules recurring operations such as backups and data archival to optimize storage and ensure disaster recovery.
  • CLI Configuration Management - Manages server configurations and operations using a dedicated shell command-line tool.
  • Cluster Health Monitoring - Displays live diagnostic information and status updates for all nodes in a database cluster.
  • Automated Cluster Maintenance - Automates the deployment, scaling, and maintenance of database clusters to ensure a healthy state.
  • Shard Status Monitoring - Monitors the status and progress of bucket migrations across database shards.
  • Synchronization Failure Diagnoses - Provides a visual diagnostic interface to identify and resolve errors in data transformation and synchronization pipelines.
  • Backup Health Monitors - Tracks the status and health of backup operations through programmatic API access.
  • Index Document Linking - Links related documents within the index to ensure that updates to referenced content trigger automatic re-indexing of primary records.
  • Telemetry Exporters - Streams internal metrics to external observability platforms using the OpenTelemetry protocol.
  • External Access Configurations - Exposes database clusters to external traffic using ingress controllers and validated networking configurations.
  • Message Queue Integration - Provides built-in connectors to ingest event data from message brokers directly into document collections.
  • Event Stream Ingestion - Allows automatic ingestion of event streams from message brokers into database documents.
  • Metric-to-UI Mapping - Streams internal performance statistics to external time-series databases and visualization tools.
  • Metric and Performance Monitors - Tracks critical server performance metrics including IOPS, throughput, and garbage collection statistics.
  • System Health Monitoring - Provides comprehensive system health monitoring through integrated dashboards and operational telemetry.
  • Observability Studios - Manages the database through a bundled web-based administrative interface.
  • Custom Metric Scraping - Provides standardized Prometheus-compatible endpoints for scraping database performance metrics.
  • Security Audit Logs - Provides comprehensive audit logs tracking administrative actions and user connections to ensure system compliance and security visibility.
  • Server Health Monitoring - Exposes server health metrics via live dashboards, SNMP, and external monitoring integrations like Grafana.
  • Server Management Interfaces - Provides a graphical administrative interface and a command-line shell for server management.
  • Server Monitoring and Auditing - Records administrative actions and configuration changes to provide a comprehensive audit trail.
  • Server Operational Management - Sends low-level administrative commands to manage the server and cluster configuration.
  • Operation Progress Monitoring - Tracks the progress of bulk data import operations via asynchronous snapshots of processed documents.
  • User Operation Audit Trails - Records detailed trails of user operations and connections to provide a complete history of server activity.
  • System Performance Monitors - Tracks system-level performance metrics including resource utilization and IO statistics.
  • Background Task Execution - Processes documents systematically using AI models to perform automated enrichment and validation workflows.
  • Database Document Expirations - Cleans up old documents automatically based on a defined expiration schedule.
  • Document Identity Generators - Defines custom logic for generating document IDs and identifying ID properties on entities.
  • Event-Driven Databases - A system that streams real-time document changes to external workers and message brokers to support asynchronous processing and event-driven architectures.
  • Response Caching - Caches database responses locally to optimize performance during repeated data access.
  • Database Management Interfaces - Administrates the database using a web-based studio or a command-line shell tool.
  • Database Systems - ACID-compliant document database.
  • Databases and Storage - LINQ-enabled document database for .NET applications.
  • Embedded Databases - LINQ-enabled document database for .NET environments.

    • Historial de estrellas

    Gráfico del historial de estrellas de ravendb/ravendbGráfico del historial de estrellas de ravendb/ravendb

    Preguntas frecuentes

    ¿Qué hace ravendb/ravendb?

    RavenDB is a multi-model NoSQL document database designed for high-performance, ACID-compliant data storage. It persists structured information as schema-flexible JSON documents and utilizes a unit-of-work session pattern to track entity changes and batch modifications into atomic transactions. The platform is built on a distributed architecture that supports horizontal scaling through sharding and ensures high availability via multi-node, master-to-master cluster…

    ¿Cuáles son las características principales de ravendb/ravendb?

    Las características principales de ravendb/ravendb son: JSON Document Storage, ACID-Compliant, Visual Database Management, Atomic Field Operators, Patch-Based Concurrent Updates, Atomic Transaction Coordinators, Data Consistency Models, Atomic Transaction Execution.

    ¿Qué alternativas de código abierto existen para ravendb/ravendb?

    Las alternativas de código abierto para ravendb/ravendb incluyen: hazelcast/hazelcast — Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to… tporadowski/redis — Redis is a high-performance in-memory key-value store that functions as a distributed cache, message broker, and NoSQL… apple/foundationdb — FoundationDB is an ACID-compliant distributed transactional key-value store. It functions as a scalable database… redis/redisinsight — RedisInsight is a graphical user interface and management tool for browsing, analyzing, and administering Redis… sidorares/node-mysql2 — This project is a MySQL database driver for Node.js that establishes network connections and executes SQL queries… lancedb/lancedb — LanceDB is a vector database and columnar data store designed to function as a versioned dataset manager and vector…

    Alternativas open-source a Ravendb

    Proyectos open-source similares, clasificados según cuántas características comparten con Ravendb.
    • hazelcast/hazelcastAvatar de hazelcast

      hazelcast/hazelcast

      6,570Ver en GitHub↗

      Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and external data sources. What distinguishes Hazelcast is its use of a distributed consensus subsystem to maintain strongly consis

      Javabig-datacachingdata-in-motion
      Ver en GitHub↗6,570
    • tporadowski/redisAvatar de tporadowski

      tporadowski/redis

      9,987Ver en GitHub↗

      Redis is a high-performance in-memory key-value store that functions as a distributed cache, message broker, and NoSQL database. It provides sub-millisecond read and write access to data stored in RAM and can operate as a vector database for indexing high-dimensional embeddings. The system supports a wide range of data storage and synchronization primitives, including the management of strings, hashes, lists, sets, and JSON documents. It enables real-time data operations through atomic transactions, hybrid persistence using snapshots and append-only logs, and high-availability configurations

      Credisredis-for-windowsredis-msi-installer
      Ver en GitHub↗9,987
    • apple/foundationdbAvatar de apple

      apple/foundationdb

      16,446Ver en GitHub↗

      FoundationDB is an ACID-compliant distributed transactional key-value store. It functions as a scalable database engine that ensures strict serializability and data consistency across a cluster of servers using a shared-nothing architecture. The system is distinguished by its multi-region replication capabilities, allowing data to be synchronized across different datacenters for high availability and disaster recovery. It utilizes optimistic concurrency control to manage distributed transactions and employs a majority-based coordination system to maintain cluster state. The platform provides

      C++aciddistributed-databasefoundationdb
      Ver en GitHub↗16,446
  • redis/redisinsightAvatar de redis

    redis/RedisInsight

    8,556Ver en GitHub↗

    RedisInsight is a graphical user interface and management tool for browsing, analyzing, and administering Redis databases. It provides a visual environment for exploring key-value data structures, managing database instances, and performing data analysis across different operating systems and deployments. The tool distinguishes itself by providing dedicated visual managers for complex operations, including a vector database manager for configuring embeddings and similarity searches, a query workbench for executing raw commands and Lua scripts, and a performance monitoring dashboard for tracki

    TypeScriptdatabase-guiredisredis-gui
    Ver en GitHub↗8,556
    • Ver las 30 alternativas a Ravendb→