One Database.
Every Dimension.
AI-Native.

The multi-dimensional graph database that speaks your AI's language.
Relationships, metadata, vectors, and nested data—all in one unified layer.

Free & Open Source MIT License SQLite-Based Zero Dependencies Edge-Ready

Key Features

Unified Data Store for AI

One powerful platform combining graph relationships, relational queries, and vector embeddings. Stop juggling multiple databases—your AI applications deserve integrated intelligence.

Comprehensive Developer-Friendly API

Intuitive SDKs for C#, JavaScript, and Python with full REST support. Build faster with clear documentation, predictable patterns, and thoughtful abstractions that just make sense.

Find the Right Data Relationships, Fast

Lightning-quick graph traversals, vector similarity search, and SQL-like queries in one engine. Navigate complex connections in milliseconds, not minutes.

Flexible In-Memory or On-Disk Operation

Choose your performance profile: blazing-fast RAM operations for real-time AI or persistent SQLite storage for durability. Switch modes without changing your code.

⚡ Why LiteGraph is Different

Single Platform for Graph, Relational, and Vector

Unifies three essential data paradigms in one lightweight engine. No more complex ETL pipelines or data synchronization nightmares.

Graph Intelligence at the Edge

Combines graph structure, metadata semantics, and vector space reasoning—all embeddable in a 5MB binary.

Embedded or Server Mode

Run as an embedded library for zero-latency access or deploy as a REST API server. Same data model, your choice of deployment.

SQLite Foundation

Built on the world's most deployed database engine. Battle-tested reliability with zero operational overhead.

Blazing-Fast In-Memory Graphs

Optional full in-RAM execution with controlled persistence enables high throughput applications.

Transparent & Source-Available

Open-source with simple, understandable architecture—ideal for integration and auditing.

Why Traditional Databases Fall Short

Relational (SQL)

Rigid schemas can't handle AI's dynamic needs. No native vector search. Painful for graph traversals. Your AI speaks embeddings, not tables.

Vector Databases

Great for similarity search, blind to relationships. Can't track lineage, store metadata, or handle complex objects. It's one-dimensional thinking in a multi-dimensional AI world.

Graph Databases

Excel at relationships but can't do semantic search. No vector operations means no AI-native queries. Missing the intelligence layer modern AI demands.

Object/BLOB Storage

Unstructured dumping grounds with no intelligence. Can't query relationships, find similar content, or maintain context. It's storage without understanding.

The Multi-Tool Problem

Stitching together 4+ databases means complex pipelines, data synchronization nightmares, and queries that take days to write. Your AI moves at machine speed—your data infrastructure should too.

Where LiteGraph Shines

From edge AI to enterprise knowledge graphs, LiteGraph powers applications that demand multi-dimensional intelligence.

🎯

Embedded AI/ML Applications

Power lightweight, local-first AI systems with graph-native metadata and vector embeddings—no external database required. Perfect for edge computing and privacy-sensitive applications.

🚀

RAG Beyond Vectors

Combine vector similarity with graph relationships and metadata filters for more accurate, contextual retrieval that actually understands your data.

🌐

Knowledge Graphs for Edge Devices

Run complex entity-relation and vector similarity lookups entirely in-process, even on constrained hardware. Bring intelligence to IoT and mobile applications.

🏢

Enterprise Data Relationship Mapping

Build semantically rich models for identity graphs, asset tracking, and network topologies with full traceability. Track complex organizational relationships with ease.

🔍

Semantic Search for Unstructured Data

Store structured metadata, JSON blobs, and vector embeddings together to support hybrid symbolic-vector search at scale. Query by meaning AND structure.

🔗

Custom Data Mesh/Lineage Engines

Track data transformations across pipelines and teams with full visibility using labeled, versioned graph relationships. Know where your data comes from and goes.

In-Memory AI Prototyping

Rapidly prototype graph/vector logic in-memory and flush to disk only when needed—ideal for LLM and RAG experiments. Iterate at the speed of thought.

🏭

Digital Twins & Simulation Graphs

Model real-world systems (IoT, manufacturing, security) with mutable node/edge metadata, labels, and temporal graph states. Simulate complex systems with ease.

Get Started in Minutes

Install LiteGraph using NuGet into your solution, or deploy a separate server using Docker

using LiteGraph;

// Initialize SDK
var client = new LiteGraphClient(new SqliteRepository("ai.db"));

// Create a graph
var graph = client.CreateGraph(new Graph { Name = "AI Knowledge" });

// Create nodes
var user = client.CreateNode(new Node { 
    GraphGUID = graph.GUID,
    Name = "User Profile",
    Labels = new[] { "user" },
    Tags = new NameValueCollection { { "type", "customer" } },
    Vectors = new[] { new VectorMetadata {
        Model = "ada-002",
        Vectors = new[] { 0.1f, 0.2f, 0.3f }
    }}
});

var pref = client.CreateNode(new Node {
    GraphGUID = graph.GUID,
    Name = "Prefers Technical",
    Labels = new[] { "preference" }
});

// Connect them
var edge = client.CreateEdge(new Edge {
    GraphGUID = graph.GUID,
    From = user.GUID,
    To = pref.GUID,
    Name = "has_preference"
});
using LiteGraph.Sdk;

// Initialize SDK
var sdk = new LiteGraphSdk("http://localhost:8701", "bearer-token");

// Create a graph
var graph = await sdk.Graph.Create(new Graph { 
    TenantGUID = tenantGuid,
    Name = "AI Knowledge",
    Labels = new List<string> { "knowledge", "ai" },
    Tags = new NameValueCollection { { "domain", "customer-service" } }
});

// Create nodes
var user = await sdk.Node.Create(new Node { 
    TenantGUID = tenantGuid,
    GraphGUID = graph.GUID,
    Name = "User Profile",
    Labels = new List<string> { "user" },
    Tags = new NameValueCollection { { "type", "customer" } },
    Vectors = new List<VectorMetadata> {
        new VectorMetadata {
            Model = "ada-002",
            Dimensionality = 3,
            Content = "customer profile data",
            Vectors = new List<float> { 0.1f, 0.2f, 0.3f }
        }
    }
});

var pref = await sdk.Node.Create(new Node {
    TenantGUID = tenantGuid,
    GraphGUID = graph.GUID,
    Name = "Prefers Technical",
    Labels = new List<string> { "preference" },
    Tags = new NameValueCollection { { "category", "communication-style" } }
});

// Connect them
var edge = await sdk.Edge.Create(new Edge {
    TenantGUID = tenantGuid,
    GraphGUID = graph.GUID,
    From = user.GUID,
    To = pref.GUID,
    Name = "has_preference",
    Labels = new List<string> { "relationship" }
});
import { LiteGraphSdk } from 'litegraphdb';

// Initialize SDK
const sdk = new LiteGraphSdk('http://localhost:8701', 'tenant-id', 'key');

// Create a graph
const graph = await sdk.createGraph('graph-id', 'AI Knowledge');

// Create nodes
const user = await sdk.createNode({
    GraphGUID: graph.GUID,
    Name: 'User Profile',
    Labels: ['user'],
    Tags: { type: 'customer' },
    Vectors: [{
        Model: 'ada-002',
        Vectors: [0.1, 0.2, 0.3]
    }]
});

const pref = await sdk.createNode({
    GraphGUID: graph.GUID,
    Name: 'Prefers Technical',
    Labels: ['preference']
});

// Connect them
const edge = await sdk.createEdge({
    GraphGUID: graph.GUID,
    From: user.GUID,
    To: pref.GUID,
    Name: 'has_preference'
});
from litegraph_sdk import configure, Graph, Node, Edge

# Initialize SDK
configure(endpoint="http://localhost:8701", tenant_guid="id", access_key="key")

# Create a graph
graph = Graph.create(name="AI Knowledge")

# Create nodes
user = Node.create(
    graph_guid=graph.guid,
    name="User Profile",
    labels=["user"],
    tags={"type": "customer"},
    vectors=[{
        "Model": "ada-002",
        "Vectors": [0.1, 0.2, 0.3]
    }]
)

pref = Node.create(
    graph_guid=graph.guid,
    name="Prefers Technical",
    labels=["preference"]
)

# Connect them
edge = Edge.create(
    graph_guid=graph.guid,
    from_node=user.guid,
    to_node=pref.guid,
    name="has_preference"
)
# Create a graph
curl -X PUT http://localhost:8701/v1.0/tenants/${TENANT}/graphs \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"Name": "AI Knowledge"}'

# Create user node with vector
curl -X PUT http://localhost:8701/v1.0/tenants/${TENANT}/graphs/${GRAPH}/nodes \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "Name": "User Profile",
    "Labels": ["user"],
    "Tags": {"type": "customer"},
    "Vectors": [{
      "Model": "ada-002",
      "Vectors": [0.1, 0.2, 0.3]
    }]
  }'

# Create preference node
curl -X PUT http://localhost:8701/v1.0/tenants/${TENANT}/graphs/${GRAPH}/nodes \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"Name": "Prefers Technical", "Labels": ["preference"]}'

# Create edge
curl -X PUT http://localhost:8701/v1.0/tenants/${TENANT}/graphs/${GRAPH}/edges \
  -H "Authorization: Bearer ${TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{"From": "${USER_NODE}", "To": "${PREF_NODE}", "Name": "has_preference"}'

Available SDKs

C# / .NET

.NET 8.0+

Full-featured SDK for .NET applications with embedded and server modes.

NuGet Version NuGet Downloads
Install via NuGet →

JavaScript

Node.js 18.20.4+

Modern JavaScript SDK with TypeScript support and comprehensive API coverage.

npm i litegraphdb
View on npm →

Python

Python 3.8+

Pythonic SDK with async support and comprehensive error handling.

pip install litegraph_sdk
View on PyPI →

REST API

HTTP/JSON

RESTful API with comprehensive endpoints for all graph operations.

Rapid Deployment with Docker

Get LiteGraph up and running in seconds with our official Docker image.

Quick Start

# Pull and run LiteGraph
docker run -d --name litegraph -p 8701:8701 -v $(pwd)/data:/data litegraphdb/litegraph:latest

# Or use Docker Compose
curl -O https://raw.githubusercontent.com/litegraphdb/litegraph/main/docker-compose.yml
docker-compose up -d

Docker Features

  • Pre-configured with sensible defaults
  • Persistent storage with volume mounting
  • Environment variable configuration
  • Health checks included