CBD - Codai Better Database (Enterprise Edition)

CBD Enterprise is a revolutionary high-performance vector memory system with enterprise-grade features including clustering, security, and gRPC server capabilities. Built with TypeScript and Rust for maximum performance and reliability.

🚀 Enterprise Features

🧠 Core Database

Vector Memory System: HPKV-inspired architecture with semantic search
Multiple Storage Backends: SQLite, CBD-Native, and enterprise storage
Embedding Models: OpenAI, local models, and custom embeddings
MCP Server: Model Context Protocol server for AI integrations

🏢 Enterprise Architecture

🔗 Clustering: Raft consensus-based distributed clustering
🔒 Security: JWT authentication, OAuth2, LDAP, and encryption
⚡ High-Performance Server: gRPC and REST APIs with monitoring
📊 Metrics & Monitoring: Prometheus metrics and health checks
🛡️ Enterprise Security: AES-256-GCM encryption and audit logging

📦 Installation

# Install from npm
npm install @codai/cbd

# Or with pnpm
pnpm add @codai/cbd

# Or with yarn
yarn add @codai/cbd

🚀 Quick Start

Basic Usage

import { createCBDEngine, CBDEnterprise } from '@codai/cbd';

// Create basic CBD engine
const cbd = createCBDEngine({
  storage: {
    type: 'cbd-native',
    dataPath: './cbd-data',
  },
  embedding: {
    model: 'openai',
    apiKey: process.env.OPENAI_API_KEY,
  },
});

// Store and search memories
await cbd.storeMemory('user-pref', 'User prefers dark mode', metadata);
const results = await cbd.searchMemories('dark theme preference');

Enterprise Setup

import { CBDEnterprise } from '@codai/cbd';

// Create enterprise instance
const enterprise = new CBDEnterprise();

// Initialize with enterprise features
await enterprise.initialize({
  security: {
    jwtSecret: 'your-secret',
    sessionTimeout: 3600,
    enableOAuth2: true,
    encryptionKey: 'your-encryption-key',
    requireTLS: true,
  },
  cluster: {
    nodeId: 'cbd-node-1',
    bindAddress: '0.0.0.0:8080',
    clusterPeers: ['cbd-node-2:8080', 'cbd-node-3:8080'],
    enableRaft: true,
    dataDir: './cluster-data',
  },
  server: {
    grpcPort: 8080,
    restPort: 8081,
    adminPort: 8082,
    bindAddress: '0.0.0.0',
    maxConnections: 1000,
    enableTLS: true,
    enableMetrics: true,
  },
});

// Start enterprise services
await enterprise.start();

🏗️ Architecture

Modular Design

CBD Enterprise
├── Core Database (TypeScript)
│   ├── Memory Engine
│   ├── Vector Store (Faiss)
│   ├── Storage Adapters
│   └── MCP Server
├── Enterprise Modules (Rust)
│   ├── cbd-core (Core traits)
│   ├── cbd-vector (HNSW index)
│   ├── cbd-storage (RocksDB)
│   ├── cbd-cluster (Raft consensus)
│   ├── cbd-security (JWT, encryption)
│   └── cbd-server (gRPC/REST)
└── TypeScript Interfaces
    ├── Cluster Manager
    ├── Security Manager
    └── Enterprise Server

Technology Stack

TypeScript: Application logic and interfaces
Rust: High-performance enterprise modules
RocksDB: Enterprise storage backend
Faiss: Vector similarity search
gRPC/tonic: High-performance RPC
JWT/OAuth2: Authentication and authorization
Raft: Distributed consensus

🔧 Configuration

Basic Configuration

const config = {
  storage: {
    type: 'cbd-native', // 'sqlite' | 'cbd-native'
    dataPath: './cbd-data',
  },
  embedding: {
    model: 'openai', // 'openai' | 'local'
    apiKey: process.env.OPENAI_API_KEY,
    modelName: 'text-embedding-ada-002',
    dimensions: 1536,
  },
  vector: {
    indexType: 'faiss', // 'faiss' | 'inmemory'
    dimensions: 1536,
    similarityMetric: 'cosine',
  },
};

Enterprise Configuration

const enterpriseConfig = {
  cluster: {
    nodeId: 'cbd-node-1',
    bindAddress: '0.0.0.0:8080',
    clusterPeers: ['node-2:8080', 'node-3:8080'],
    enableRaft: true,
    dataDir: './cluster-data',
  },
  security: {
    jwtSecret: process.env.JWT_SECRET,
    sessionTimeout: 3600, // seconds
    enableOAuth2: true,
    enableLDAP: false,
    encryptionKey: process.env.ENCRYPTION_KEY,
    requireTLS: true,
  },
  server: {
    grpcPort: 8080,
    restPort: 8081,
    adminPort: 8082,
    bindAddress: '0.0.0.0',
    maxConnections: 1000,
    enableTLS: true,
    certFile: './certs/server.crt',
    keyFile: './certs/server.key',
    enableMetrics: true,
    enableTracing: true,
  },
};

📊 API Reference

Basic Operations

// Memory operations
await cbd.storeMemory(key, content, metadata);
await cbd.searchMemories(query, options);
await cbd.getMemory(key);
await cbd.deleteMemory(key);

// Vector operations
await cbd.storeVector(id, vector, metadata);
await cbd.searchVectors(queryVector, options);

// Statistics
const stats = await cbd.getStats();

Enterprise Operations

// Cluster management
const state = await enterprise.cluster.getClusterState();
const isLeader = await enterprise.cluster.isLeader();
await enterprise.cluster.joinCluster(leaderAddress);

// Security operations
const token = await enterprise.security.authenticate(username, password);
const context = await enterprise.security.validateToken(token);
const hasPermission = await enterprise.security.hasPermission(context, 'write');

// Server operations
const stats = await enterprise.server.getStats();
const health = await enterprise.server.healthCheck();
const metrics = await enterprise.server.getMetrics();

🔐 Security Features

Authentication

JWT tokens with configurable expiration
OAuth2 integration for enterprise SSO
LDAP support for directory services
API key authentication for service-to-service

Authorization

Role-based access control (RBAC)
Permission-based authorization
Context-aware security policies
Audit logging for compliance

Encryption

AES-256-GCM encryption at rest
TLS 1.3 encryption in transit
Key rotation and management
Secure key derivation

📈 Performance & Monitoring

Metrics

Request throughput and latency
Memory and CPU usage
Error rates and success rates
Cluster health and performance

Health Checks

Database connectivity
Cluster consensus status
Security service health
Resource utilization

Prometheus Integration

# Get metrics endpoint
curl http://localhost:8082/metrics

# Sample metrics
cbd_total_requests 1500
cbd_active_connections 25
cbd_requests_per_second 150
cbd_average_response_time 45
cbd_error_rate 0.02

🛠️ Development

Build Commands

# Install dependencies
pnpm install

# Build TypeScript and Rust
pnpm build

# Build only Rust workspace
pnpm build:rust:workspace

# Build enterprise features
pnpm build:enterprise

# Run tests
pnpm test
pnpm test:enterprise

# Start development server
pnpm dev

# Start enterprise server
pnpm server:enterprise

Project Structure

packages/cbd/
├── src/
│   ├── memory/           # Core memory engine
│   ├── vector/           # Vector operations
│   ├── storage/          # Storage adapters
│   ├── embedding/        # Embedding models
│   ├── mcp/             # MCP server
│   ├── enterprise/      # Enterprise TypeScript interfaces
│   └── types/           # Type definitions
├── cbd-core/            # Rust core traits
├── cbd-vector/          # Rust vector operations
├── cbd-storage/         # Rust storage backend
├── cbd-cluster/         # Rust clustering
├── cbd-security/        # Rust security
├── cbd-server/          # Rust gRPC/REST server
├── tests/               # Test suites
└── docs/                # Documentation

🤝 Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🏆 Acknowledgments

Built with Rust for performance and safety
Powered by TypeScript for developer experience
Vector search with Faiss
Storage with RocksDB
Clustering with Raft consensus
gRPC with tonic

CBD Enterprise - The world-class vector database for the AI era. 🚀

Built by the CODAI Ecosystem team

Package detail

@codai/cbd

readme