Your Data, Naturally Connected

Embedded graph database with Git-like branches and time travel.

Installation Installation

# Python
pip install casys-db

# TypeScript/Node.js
npm install casys-db

# Setup: Knowledge Graph pour RAG
from casys_db import Database, Session
from casys_db import NodeEntity, HasMany

# Ouvrir base de prod
prod = Database("knowledge_graph.db")

# Schéma ORM (sans strings!)
class Topic(NodeEntity):
    pass  # label: "Topic"

class Document(NodeEntity):
    topics = HasMany(Topic)  # via auto: TOPICS
    related = HasMany(Topic, via="ABOUT")  # override

# Créer branche main si besoin
main = prod.branch("main")

# Insérer documents + embeddings (OpenAI/LLaMA)
prod.query("""  
  CREATE (doc:Document {
    title: 'RAG avec Casys',
    content: 'Guide complet...',
    embedding: [0.23, -0.45, 0.67]
  })
  CREATE (ai:Topic { name: 'AI' })
  CREATE (db:Topic { name: 'Databases' })
  CREATE (doc)-[:ABOUT]->(ai)
  CREATE (doc)-[:ABOUT]->(db)
""")
prod.commit()  # → Snapshot auto créé

# Ou avec l'ORM
session = Session(prod)
adults = session.Document.where(
    lambda d: d.topics.any(lambda t: t.name == "AI")
).all()

# Créer une branche pour tester nouveau modèle
experiment = prod.create_branch("test-llama3")

# Voir les snapshots disponibles
snapshots = prod.snapshots()
for snap in snapshots:
    print(f"{ snap['timestamp'] }: { snap['segments_count'] } segments")

# ✅ Prod reste intacte pendant vos tests
# ✅ Isolation complète (comme Git)
# ✅ Zero downtime

# Re-calculer embeddings avec LLaMA 3
import numpy as np

# Récupérer tous les docs via ORM (aperçu)
session = Session(experiment)
rows = (
  session.Document
    .select(title=lambda d: d.title, content=lambda d: d.content)
    .all()
)

# Full ORM: read + update
for row in rows:
    new_emb = compute_llama3(row.content)
    session.Document 
      .where(lambda d: d.title == row.title) 
      .update(embedding=new_emb)

experiment.commit()

# Comparer perf prod vs experiment 📊

# PITR: Si experiment casse tout ⏰

# Voir l'historique complet
history = prod.history(from_time="yesterday")
print(f"{ len(history) } snapshots depuis hier")

# Créer branche depuis un point passé
recovery = prod.branch_at(
    name="safe-state",
    timestamp="2 hours ago"
)

# Vérifier l'état avant le bug
count = recovery.query("MATCH (d:Document) RETURN count(d)")
print(f"Documents à ce moment: { count } ")

# ✅ Zéro perte de données

⚡

Embedded Embarquée

Zero servers, runs in your process

📊

ISO GQL

Standard graph query language Langage standard de requêtes graphe

🔄

MVCC

Isolated transactions, consistent reads

# Create nodes and relationships
from casys_db import Database

db = Database("social_network.db")
session = db.default_branch().session()

# Create Person nodes
session.execute("""
  CREATE (alice:Person { name: 'Alice', age: 30 })
  CREATE (bob:Person { name: 'Bob', age: 25 })
  CREATE (carol:Person { name: 'Carol', age: 28 })
  
  CREATE (alice)-[:KNOWS { since: 2020 } ]->(bob)
  CREATE (alice)-[:KNOWS { since: 2019 } ]->(carol)
  CREATE (bob)-[:KNOWS { since: 2021 } ]->(carol)
  RETURN alice, bob, carol
""")

session.commit()

-- Find friends of friends (2-hop path)
MATCH (person:Person)-[:KNOWS*2]->(friend_of_friend:Person)
WHERE person.name = 'Alice'
  AND person <> friend_of_friend
RETURN friend_of_friend.name, 
       COUNT(*) AS paths
GROUP BY friend_of_friend.name
ORDER BY paths DESC;

-- Find people who know each other (mutual connections)
MATCH (p1:Person)-[:KNOWS]->(p2:Person)-[:KNOWS]->(p1)
WHERE p1.name < p2.name
RETURN p1.name, p2.name;

# Fluent query builder (ORM-style)
from casys_db import NodeEntity, Session

class Person(NodeEntity):
    pass

session = Session(db.default_branch())

# Find all adults
adults = session.Person.where(lambda p: p.age >= 18).all()

# Complex filtering with projections
results = (
    session.Person
    .where(lambda p: p.age > 25)
    .select_fields('name', 'age')
    .order_by(lambda p: p.age, desc=True)
    .limit(10)
    .all()
)

for person in results:
    print(f"{ person['name'] }: { person['age'] }")

# Define entity relationships
from casys_db import NodeEntity, HasMany, HasOne
from typing import Self

class Person(NodeEntity):
    knows = HasMany(Self)  # Self-referential relationship
    lives_in = HasOne('City')

class City(NodeEntity):
    pass

# Query with joins
results = (
    session.Person
    .where(lambda p: p.name == 'Alice')
    .join_out(lambda p: p.knows)  # Follow KNOWS relationship
    .select(
        person=lambda p: p.name,
        friend=lambda f: f.name
    )
    .all()
)

for row in results:
    print(f"{ row['person'] } knows { row['friend'] }")

⚡

Embedded & Fast Embarquée & Rapide

Zero servers, zero configuration. Runs directly in your Python or TypeScript process. Starts in milliseconds.

📊

ISO GQL

Standard ISO GQL language. MATCH, WHERE, RETURN, EXISTS, WITH. Compatible with modern GQL tools.

🔄

MVCC

Transactions with snapshot isolation. Consistent reads, isolated writes. No blocking locks.

⏰

Time Travel Voyage dans le temps

Point-in-Time Recovery (PITR). Create branches from any commit. Explore complete history.

🐍

Fluent Python ORM ORM Python Fluent

Type-safe query builder with lambdas. where(), select(), join_out(). Like SQLAlchemy but for graphs.

📦

Zero Dependencies Zéro Dépendance

Compiled Rust engine. Single native library. Install in 3 seconds. No JVM, no Node.js required.

# Créer une branche depuis main
import casys_db

engine = casys_db.CasysEngine(data_dir="~/.casys_db")
db = engine.open_database("social")

# Créer une branche "main" si elle n'existe pas
engine.create_branch("social", "main")

# Créer une branche expérimentale depuis main
engine.create_branch("social", "experiment")

# Travailler sur experiment sans affecter main
exp_branch = engine.open_branch("social", "experiment")
result = exp_branch.query("""
  CREATE (p:Person { name: 'Test User' })
  RETURN p
""")

# main reste inchangé !

# Point-in-Time Recovery
from casys_db import Database

db = Database("social.db")

# Voir l'historique des modifications
history = db.history(from_time="yesterday")
for event in history:
    print(f"{ event.timestamp }: { event.type }")

# Créer une branche depuis un point dans le passé
recovery = db.branch_at(
    name="recovery",
    timestamp="2 hours ago"
)

# Explorer cet état passé (lecture seule)
result = recovery.query("MATCH (u:User) RETURN count(u)")
print(f"Utilisateurs à ce moment: { result }")

# Snapshots et persistence
import casys_db

engine = casys_db.CasysEngine(data_dir="~/.casys_db")
db = engine.open_database("social")
branch = engine.open_branch("social", "main")

# Créer des données
branch.query("""
  CREATE (u:User { name: 'Alice', age: 30 })
""")

# Persister les changements sur disque
branch.flush()  # → Write segments + WAL

# Créer un snapshot explicite
timestamp = engine.snapshot(branch, None)
print(f"Snapshot créé: { timestamp }")

# Recharger depuis le disque
branch.load()

🌳

Isolated Branches Branches Isolées

Test changes safely. Each branch is completely isolated.

⏰

Time Travel Voyage dans le Temps

Create a branch from any past commit. Debug easily.

📸

Auto Snapshots Snapshots Auto

Each commit = snapshot. No data loss, complete history.

Use Cases Cas d'usage

CasysDB excels where data is connected

👥

Social Networks Réseaux Sociaux

Find friends-of-friends, recommendations, community detection. 2-3 hop queries in milliseconds.

MATCH (user:Person)-[:KNOWS*2..3]->(friend)
WHERE user.id = $userId
RETURN DISTINCT friend

🧠

Knowledge Graphs Knowledge Graphs

Ontologies, RAG, semantic search. Complex relationships between entities, attributes, concepts.

MATCH (concept)-[:RELATED_TO*]->(topic)
WHERE concept.name = 'Machine Learning'
RETURN topic.name, COUNT(*) AS relevance

🎯

Recommendation Engines Moteurs de Recommandation

Collaborative filtering, content-based recommendations. Find patterns in user interactions.

MATCH (u:User)-[:LIKES]->(i:Item)<-[:LIKES]-(similar:User)
WHERE u.id = $userId
RETURN i.name, COUNT(similar) AS score

🕸️

Network Analysis Analyse de Réseaux

Fraud detection, supply chain, dependency tracking. Visualize and explore connections.

MATCH path = (start)-[:DEPENDS_ON*]->(end)
WHERE start.type = 'Service'
RETURN path, LENGTH(path) AS depth

⚡

Zero configuration Zero configuration

No server to manage. Runs directly in your Python or TypeScript application.

📊

Native ISO GQL ISO GQL natif

Standard graph query language. Learn once, use everywhere.

🔄

MVCC & PITR MVCC & PITR

Isolated transactions with MVCC. Point-in-Time Recovery to travel through history.

Comparison of CasysDB and alternative databases
Feature Fonctionnalité	CasysDB	Neo4j	SQLite	PostgreSQL
Embedded (no server) Embarquée (no server)	✅	❌	✅	❌
Native Graph Queries Requêtes Graphe Natives	✅	✅	❌	⚠️
Standard Language (ISO GQL) Langage Standard (ISO GQL)	✅	⚠️	❌	⚠️
MVCC Transactions	✅	✅	❌	✅
Time Travel (PITR) Voyage dans le temps (PITR)	✅	❌	❌	❌
Type-Safe ORM ORM Type-Safe	✅	❌	⚠️	⚠️
Dependencies Dépendances	0	JVM	0	Server
License Licence	MIT	GPL/Commercial	Public Domain	PostgreSQL

🚀 CasysDB combines SQLite's simplicity with graph database power, plus MVCC and Time Travel

Ready to Get Started? Prêt à commencer ?

CasysDB is open-source and ready to use. Check out the documentation or source code.

Documentation View on GitHub

Your Data, Naturally Connected

Vos données, connectées naturellement

Embedded Embarquée

ISO GQL

MVCC

CasysDB in Action CasysDB en action

Why CasysDB? Pourquoi CasysDB ?

Embedded & Fast Embarquée & Rapide

ISO GQL

MVCC

Time Travel Voyage dans le temps

Fluent Python ORM ORM Python Fluent

Zero Dependencies Zéro Dépendance

Branching & Time Travel Branches & Voyage dans le Temps

Isolated Branches Branches Isolées

Time Travel Voyage dans le Temps

Auto Snapshots Snapshots Auto

Use Cases Cas d'usage

Social Networks Réseaux Sociaux

Knowledge Graphs Knowledge Graphs

Recommendation Engines Moteurs de Recommandation

Network Analysis Analyse de Réseaux

Why CasysDB? Pourquoi CasysDB ?

Zero configuration Zero configuration

Native ISO GQL ISO GQL natif

MVCC & PITR MVCC & PITR

CasysDB vs Alternatives CasysDB vs Alternatives

Ready to Get Started? Prêt à commencer ?

Your Data, Naturally Connected

Vos données, connectées naturellement

Embedded Embarquée

ISO GQL

MVCC

CasysDB in Action CasysDB en action

Why CasysDB? Pourquoi CasysDB ?

Embedded & Fast Embarquée & Rapide

ISO GQL

MVCC

Time Travel Voyage dans le temps

Fluent Python ORM ORM Python Fluent

Zero Dependencies Zéro Dépendance

Branching & Time Travel Branches & Voyage dans le Temps

Isolated Branches Branches Isolées

Time Travel Voyage dans le Temps

Auto Snapshots Snapshots Auto

Use Cases Cas d'usage

Social Networks Réseaux Sociaux

Knowledge Graphs Knowledge Graphs

Recommendation Engines Moteurs de Recommandation

Network Analysis Analyse de Réseaux

Why CasysDB? Pourquoi CasysDB ?

Zero configuration Zero configuration

Native ISO GQL ISO GQL natif

MVCC & PITR MVCC & PITR

CasysDB vs Alternatives CasysDB vs Alternatives

Ready to Get Started? Prêt à commencer ?

Embedded Embarquée

CasysDB in Action CasysDB en action

Why CasysDB? Pourquoi CasysDB ?

Embedded & Fast Embarquée & Rapide

Time Travel Voyage dans le temps

Fluent Python ORM ORM Python Fluent

Zero Dependencies Zéro Dépendance

Branching & Time Travel Branches & Voyage dans le Temps

Isolated Branches Branches Isolées

Time Travel Voyage dans le Temps

Auto Snapshots Snapshots Auto

Use Cases Cas d'usage

Social Networks Réseaux Sociaux

Knowledge Graphs Knowledge Graphs

Recommendation Engines Moteurs de Recommandation

Network Analysis Analyse de Réseaux

Why CasysDB? Pourquoi CasysDB ?

Zero configuration Zero configuration

Native ISO GQL ISO GQL natif

MVCC & PITR MVCC & PITR

CasysDB vs Alternatives CasysDB vs Alternatives

Ready to Get Started? Prêt à commencer ?