ðŸĶ€ Built with Rust

The AI-Powered
Distributed Data Platform

Schema-based storage, intelligent ingestion, and real-time processing.
Build smarter data applications with less code.

50Ξs Query Latency
100% Type Safe
0 Runtime Deps
fold_db — zsh
$ cargo install datafold
✓ Installing datafold v0.1.55
Compiling datafold v0.1.55
Finished release [optimized] target(s) in 42.3s
$ datafold_http_server --port 9001
⎥ FoldDB Server starting on http://localhost:9001
✓ Schema service connected
✓ AI ingestion pipeline ready
$
Features

Everything you need for
modern data applications

From AI-powered ingestion to distributed queries, FoldDB handles the complexity so you can focus on building.

ðŸĪ–

AI-Powered Ingestion

Drop any JSON and let AI automatically generate schemas, map fields, and structure your data. No manual schema definitions required.

let result = ingestion
    .process_json(any_json_data)
    .await?;
// Schema auto-generated âœĻ
💎

Natural Language Queries

Ask questions in plain English. AI interprets your intent and returns structured results.

⚡

Real-Time Processing

Event-driven architecture with automatic transform execution as data flows through.

🌐

Distributed P2P

Built-in peer discovery and networking. Scale horizontally without infrastructure changes.

🔐

Fine-Grained Permissions

Trust-based access control at the field level. Multi-tenant isolation out of the box.

☁ïļ

Serverless Ready

S3-backed storage and DynamoDB support. Deploy to AWS Lambda with zero modifications.

📊

Dynamic Schemas

Schemas evolve with your data. Add fields, update validation, all without migrations.

🔌

Extensible Adapters

Plugin system for Twitter, Reddit, webhooks, and custom data sources.

Code Examples

Developer-first API design

Clean, intuitive APIs that get out of your way. Ship faster with less boilerplate.

Ingest any data with AI

Just send your JSON data — FoldDB automatically analyzes it, generates an optimized schema, and stores it.

  • Automatic schema generation
  • Intelligent field mapping
  • Type inference and validation
  • Async processing with progress tracking
rust
use datafold::{IngestionCore, IngestionConfig};
use serde_json::json;

let config = IngestionConfig::from_env()?;
let ingestion = IngestionCore::new(config)?;

// Drop any JSON — AI handles the rest
let data = json!({
    "user": "alice",
    "action": "purchase",
    "total": 99.99
});

let result = ingestion
    .process_json_ingestion(data).await?;

Query with natural language

Ask questions in plain English and get structured results.

  • Natural language understanding
  • Schema-aware query planning
  • Automatic result formatting
rust
use datafold::DataFoldNode;

let node = DataFoldNode::new_with_defaults().await?;

// Natural language query
let response = node.ai_query(
    "Show me all purchases over $50"
).await?;

for item in response.results {
    println!("{}: ${}", item.user, item.total);
}

Deploy to AWS Lambda

First-class serverless support with DynamoDB multi-tenant isolation.

  • DynamoDB multi-tenant backend
  • S3 sync for persistence
  • User isolation out of the box
rust
use datafold::lambda::{LambdaConfig, LambdaContext};

let config = LambdaConfig::new(
    LambdaStorage::DynamoDb(DynamoDbConfig {
        region: "us-east-1".to_string(),
        tables: ExplicitTables::from_prefix("MyApp"),
        auto_create: true,
    }),
);

LambdaContext::init(config).await?;

Type-safe frontend client

Full TypeScript support with intelligent caching and standardized error handling.

  • 100% type coverage
  • Intelligent request caching
  • Automatic retry with backoff
typescript
import { schemaClient } from '@datafold/client';

const response = await schemaClient.getSchemas();

if (response.success) {
  const schemas = response.data;
  schemas.forEach(s => console.log(s.name));
}
Quick Start

Up and running in under 2 minutes

01

Install

Install via Cargo or download a pre-built binary.

cargo install datafold
02

Configure

Set your OpenRouter API key for AI features (optional).

export OPENROUTER_API_KEY="sk-..."
03

Launch

Start the HTTP server with the web UI.

datafold_http_server --port 9001
04

Build

Open localhost:9001 and start ingesting data.

open http://localhost:9001
Architecture

Built for scale and flexibility

Clients
Web UI
REST API
TypeScript SDK
CLI
↓
FoldDB Core
AI Ingestion
Query Engine
Transform Pipeline
Schema Manager
↓
Storage
Sled (Local)
DynamoDB
S3
P2P Network

Ready to build something amazing?

Join developers building the next generation of data applications with FoldDB.