Enterprise-Grade Graph Database with Bi-Temporal Agent Memory

Features • Quick Start • Documentation • Examples • Contributing

</div>

🚀 What is QilbeeDB?

QilbeeDB is a high-performance graph database written in Rust, designed specifically for AI agent systems with advanced bi-temporal memory management. It combines the power of graph databases with sophisticated memory architectures to enable AI agents to maintain context, learn from interactions, and evolve over time.

The first graph database to natively integrate bi-temporal memory management (event time + transaction time) with support for episodic, semantic, procedural, and factual memory types.

✨ Features

🧠 AI Agent Memory

Native Memory Types: Episodic, semantic, procedural, and factual memory
Automatic Consolidation: Short-term to long-term memory transitions
Active Forgetting: Relevance-based memory pruning
Bi-Temporal Tracking: Track both event time and transaction time

⚡ High Performance

Rust-Powered: Zero-cost abstractions and memory safety
RocksDB Backend: High-performance storage with compression and bloom filters
Vectorized Execution: SIMD-optimized query processing
Cost-Based Optimization: Intelligent query planning

📊 OpenCypher Support

Full Query Language: Complete OpenCypher implementation
Pattern Matching: Complex graph pattern queries
Aggregations: COUNT, SUM, AVG, MIN, MAX
Path Finding: Variable-length path traversal

🔌 Multiple Protocols

Bolt Protocol: Neo4j-compatible for existing tools
HTTP REST API: RESTful JSON interface
gRPC Support: High-performance RPC (planned)

🏢 Enterprise-Ready

ACID Transactions: Full transactional support
Query Optimization: Cost-based query planner
Monitoring: Prometheus metrics and distributed tracing
Production-Grade: Battle-tested query execution engine

📦 Installation

Using Docker (Recommended)

# Pull the latest image
docker pull qilbeedb/qilbeedb:latest

# Run QilbeeDB
docker run -d \
  --name qilbeedb \
  -p 7474:7474 \
  -p 7687:7687 \
  -v qilbeedb-data:/data \
  qilbeedb/qilbeedb:latest

Docker Compose

version: '3.8'

services:
  qilbeedb:
    image: qilbeedb/qilbeedb:latest
    ports:
      - "7474:7474"  # HTTP REST API
      - "7687:7687"  # Bolt Protocol
    volumes:
      - qilbeedb-data:/data
    environment:
      - QILBEE_LOG_LEVEL=info
    restart: unless-stopped

volumes:
  qilbeedb-data:

Building from Source

# Prerequisites: Rust 1.70+, Git
git clone https://github.com/aicubetechnology/qilbeeDB.git
cd qilbeeDB

# Build in release mode
cargo build --release

# Run the server
./target/release/qilbee-server

Python SDK

pip install qilbeedb

🎯 Quick Start

Creating a Graph

from qilbeedb import QilbeeDB

# Connect to QilbeeDB
db = QilbeeDB("http://localhost:7474")
graph = db.graph("my_social_network")

# Create nodes
alice = graph.create_node(
    ['Person', 'User'],
    {'name': 'Alice', 'age': 30, 'city': 'San Francisco'}
)

bob = graph.create_node(
    ['Person', 'User'],
    {'name': 'Bob', 'age': 35, 'city': 'New York'}
)

# Create relationship
friendship = graph.create_relationship(
    alice, 'KNOWS', bob,
    {'since': '2020-01-15', 'strength': 0.8}
)

# Query with Cypher
results = graph.query("""
    MATCH (p:Person)-[:KNOWS]->(friend)
    WHERE p.name = $name
    RETURN friend.name, friend.age
""", {"name": "Alice"})

for row in results:
    print(f"{row['friend.name']}, age {row['friend.age']}")

Using Agent Memory

from qilbeedb.memory import Episode

# Get agent memory manager
memory = db.agent_memory('customer_service_bot')

# Store conversation episodes
episode = Episode.conversation(
    'customer_service_bot',
    'Hi, I need help with my order',
    'Hello! I\'d be happy to help. What\'s your order number?'
)
memory.store_episode(episode)

# Retrieve recent conversations
recent = memory.get_recent_episodes(10)

# Get memory statistics
stats = memory.get_statistics()
print(f"Total episodes: {stats.total_episodes}")

📚 Examples

Social Network

# Find common friends
results = graph.query("""
    MATCH (alice:User {name: $alice})-[:KNOWS]->(common)<-[:KNOWS]-(bob:User {name: $bob})
    RETURN common.name
""", {"alice": "Alice", "bob": "Bob"})

Knowledge Graph

# Semantic relationships
results = graph.query("""
    MATCH (concept:Concept)-[:RELATES_TO*1..3]->(related:Concept)
    WHERE concept.name = $topic
    RETURN DISTINCT related.name, related.category
""", {"topic": "Machine Learning"})

Recommendation System

# Collaborative filtering
results = graph.query("""
    MATCH (user:User {id: $user_id})-[:PURCHASED]->(product)<-[:PURCHASED]-(other:User)
    MATCH (other)-[:PURCHASED]->(recommendation)
    WHERE NOT (user)-[:PURCHASED]->(recommendation)
    RETURN recommendation.name, COUNT(*) as score
    ORDER BY score DESC
    LIMIT 10
""", {"user_id": 12345})

🏗️ Architecture

QilbeeDB is built with a clean, layered architecture:

┌─────────────────────────────────────────┐
│           Protocol Layer                │
│       Bolt | HTTP/REST | gRPC           │
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│             Query Engine                │
│  Parser → Planner → Optimizer → Executor│
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│             Graph Engine                │
│   Nodes | Relationships | Transactions  │
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│             Memory Engine               │
│   Episodic | Semantic | Procedural      │
└─────────────────────────────────────────┘
┌─────────────────────────────────────────┐
│           Storage Engine                │
│        RocksDB | Indexes | WAL          │
└─────────────────────────────────────────┘

Core Components

qilbee-core: Core data structures and types
qilbee-storage: RocksDB storage layer with bi-temporal support
qilbee-graph: Graph operations (nodes, relationships, transactions)
qilbee-query: Query engine (parser, planner, executor)
qilbee-memory: Agent memory management
qilbee-protocol: Bolt and HTTP protocol implementations
qilbee-server: Server orchestration and APIs

🎓 Use Cases

QilbeeDB excels in scenarios requiring both graph relationships and intelligent memory management:

AI Agent Systems: Customer service bots, personal assistants, autonomous agents
Social Networks: Friend graphs, influence networks, community detection
Knowledge Graphs: Semantic knowledge management, concept relationships
Recommendation Systems: Collaborative filtering, personalized recommendations
Multi-Agent Coordination: Agent collaboration, shared knowledge bases
Fraud Detection: Pattern recognition in transaction networks
Network Analysis: Infrastructure monitoring, dependency tracking

📖 Documentation

Comprehensive documentation is available at: https://docs.qilbeedb.io/

Key Sections:

🛠️ Development

Prerequisites

Rust 1.70 or later
Git
Build tools (gcc/clang, make)

Building

# Clone repository
git clone https://github.com/aicubetechnology/qilbeeDB.git
cd qilbeeDB

# Build all crates
cargo build

# Run tests
cargo test

# Build documentation
cargo doc --no-deps --open

Project Structure

qilbeeDB/
├── crates/
│   ├── qilbee-core/        # Core types and traits
│   ├── qilbee-storage/     # Storage layer (RocksDB)
│   ├── qilbee-graph/       # Graph operations
│   ├── qilbee-query/       # Query engine
│   ├── qilbee-memory/      # Agent memory
│   ├── qilbee-protocol/    # Protocol implementations
│   └── qilbee-server/      # Server application
├── sdks/
│   └── python/             # Python SDK
├── docs/                   # Documentation (MkDocs)
└── examples/               # Usage examples

🤝 Contributing

We welcome contributions from the community! Please read our Contributing Guide for details on:

Development setup
Code style guidelines
Testing requirements
Pull request process

Quick Contribution Steps

Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes and add tests
Run tests: cargo test
Commit your changes: git commit -m 'Add amazing feature'
Push to branch: git push origin feature/amazing-feature
Open a

QilbeeDB

Install / Use

README