The AI-native database for intelligent systems

Model the world as it really is, in a query language designed for programmers. No more joining flat tables or binary graphs.

Start buildingGo open sourceExplore docs
  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8

insert
$sql isa language;
$typeql isa language;
(past: $sql, future: $typeql) isa evolution;

Learn about the hot topics at TypeDB

A new dimension of database design

TypeDB is built on a rich, expressive type system that validates queries, enforces semantics, and unlocks semantic optimisation. A safer, smarter foundation for complex systems.

Read article

How TypeDB enables self-adaptive robotics

Explore how TypeDB can be used to support self-adaptation in the field of robotics

Read article

TypeDB Studio is now in your browser

Explore knowledge graphs, design schemas, and write queries—now in your browser.

Read article

An interview with TypeDB's head of research

Dr Dorn recently took the time to sit down with Cal, our COO to be interviewed about his experiences at TypeDB, and working on a novel database

Read article

What is an entity-relation database?

Breaking down our novel database. Learn about what it means to be an entity-relation database.

Read article

Structured for machines, intuitive for humans

TypeQL is human readable, machine writable language built on modern programming paradigms, that allows you to embed logic into the database.

Its clarity and structured nature make it perfect for LLMs and vibe coding, readying your data for the next wave of AI-driven applications and automation.

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25

define
attribute username, value string;
attribute page-visibility, value string @values("public", "private");
attribute address, value string;
attribute dob, value date;

entity profile @abstract, 
  owns username @key,
  owns page-visibility @card(1);

entity person,
  sub profile,
  owns dob,
  plays employment:employee;

entity company,
  sub profile,
  owns address @card(0..),
  plays employment:employer;

relation employment,
  relates employer,
  relates employee;

A database for complex systems

Forget tables and joins. TypeDB is built to model multi-dimensional, highly interconnected data, without losing structure or semantic meaning.

TypeDB Studio
A schema tree in TypeDB Studio

A programming language, not just a schema

With TypeQL, you describe your data like code. It’s readable, writable, and logical, enabling full expressiveness with real constraints and inference.

TypeDB

Find users that have access to different types of resources. Return user emails, resource IDs and resource types

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
match
  $user isa user;
  $resource isa! $resource-type;
  $resource-type sub resource;
  resource-ownership (resource: $resource, owner: $user);
fetch {
  "email": $user.email,
  "resource-id": $resource.id,
  "resource-type": $resource-type
};

Relational

In relational DBs, define one table for each resource type, using a UNION ALL query and JOINs to fetch interconnected data

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25
  26. 26
  27. 27
  28. 28
  29. 29
  30. 30
  31. 31
  32. 32
  33. 33
  34. 34
  35. 35
  36. 36
  37. 37
  38. 38
  39. 39
  40. 40
  41. 41
  42. 42
  43. 43
  44. 44
  45. 45
  46. 46
  47. 47
  48. 48
  49. 49
  50. 50
  51. 51
  52. 52
  53. 53
  54. 54
  55. 55
  56. 56
  57. 57
  58. 58
  59. 59
  60. 60
  61. 61
  62. 62
  63. 63
  64. 64
  65. 65
  66. 66
  67. 67
  68. 68
  69. 69
  70. 70
  71. 71
  72. 72
  73. 73
  74. 74
  75. 75
  76. 76
  77. 77
  78. 78
  79. 79
  80. 80
  81. 81
  82. 82
  83. 83
  84. 84
  85. 85
  86. 86
SELECT
  ue.email AS email,
  'file' AS resource_type,
  f.path AS id
FROM users u
JOIN user_emails ue
ON u.id = ue.user_id
JOIN resource_ownerships ro
ON u.id = ro.user_id
JOIN resources r
ON ro.resource_id = r.id
JOIN files f
ON r.id = f.resource_id
UNION ALL
SELECT
  ue.email AS email,
  'directory' AS resource_type,
  d.path AS id
FROM users u
JOIN user_emails ue
ON u.id = ue.user_id
JOIN resource_ownerships ro
ON u.id = ro.user_id
JOIN resources r
ON ro.resource_id = r.id
JOIN directories d
ON r.id = d.resource_id
UNION ALL
SELECT
  ue.email AS email,
  'commit' AS resource_type,
  c.hash AS id
FROM users u
JOIN user_emails ue
ON u.id = ue.user_id
JOIN resource_ownerships ro
ON u.id = ro.user_id
JOIN resources r
ON ro.resource_id = r.id
JOIN commits c
ON r.id = c.resource_id
UNION ALL
SELECT
  ue.email AS email,
  'repository' AS resource_type,
  re.name AS id
FROM users u
JOIN user_emails ue
ON u.id = ue.user_id
JOIN resource_ownerships ro
ON u.id = ro.user_id
JOIN resources r
ON ro.resource_id = r.id
JOIN repositories re
ON r.id = re.resource_id
UNION ALL
SELECT
  ue.email AS email,
  'table' AS resource_type,
  t.name AS id
FROM users u
JOIN user_emails ue
ON u.id = ue.user_id
JOIN resource_ownerships ro
ON u.id = ro.user_id
JOIN resources r
ON ro.resource_id = r.id
JOIN tables t
ON r.id = t.resource_id
UNION ALL
SELECT
  ue.email AS email,
  'database' AS resource_type,
  f.name AS id
FROM users u
JOIN user_emails ue
ON u.id = ue.user_id
JOIN resource_ownerships ro
ON u.id = ro.user_id
JOIN resources r
ON ro.resource_id = r.id
JOIN databases d
ON r.id = d.resource_id;

Document

In document DBs, freeform structures make writes trivial, but reading and validating data becomes a significant challenge

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25
  26. 26
  27. 27
  28. 28
  29. 29
  30. 30
  31. 31
  32. 32
  33. 33
  34. 34
  35. 35
  36. 36
  37. 37
  38. 38
  39. 39
  40. 40
  41. 41
  42. 42
  43. 43
  44. 44
  45. 45
  46. 46
  47. 47
  48. 48
  49. 49
  50. 50
  51. 51
  52. 52
  53. 53
  54. 54
  55. 55
  56. 56
  57. 57
  58. 58
  59. 59
  60. 60
  61. 61
  62. 62
  63. 63
  64. 64
  65. 65
  66. 66
  67. 67
  68. 68
  69. 69
  70. 70
  71. 71
  72. 72
  73. 73
  74. 74
  75. 75
  76. 76
  77. 77
  78. 78
  79. 79
  80. 80
  81. 81
  82. 82
  83. 83
  84. 84
  85. 85
  86. 86
  87. 87
  88. 88
  89. 89
  90. 90
  91. 91
  92. 92
  93. 93
  94. 94
  95. 95
db.resource_ownerships.aggregate( [
  {
    $lookup:
    {
      from: "resources",
      localField: "resource",
      foreignField: "_id",
      as: "resource"
    }
  },
  {
    $unwind:
    {
      path: "$resource"
    }
  },
  {
    $lookup:
    {
      from: "users",
      localField: "owner",
      foreignField: "_id",
      as: "owner"
    }
  },
  {
    $unwind:
    {
      path: "$owner"
    }
  },
  {
    $unwind:
    {
      path: "$owner.emails"
    }
  },
  {
    $addFields:
    {
      resource_id: {
        $switch: {
          branches: [
            {
              case: { 
                $eq: ["$resource.resource_type", "file"]
              }, 
              then: "$resource.path" 
            },
            {
              case: { 
                $eq: ["$resource.resource_type", "directory"]
              }, 
              then: "$resource.path" 
            },
            {
              case: { 
                $eq: ["$resource.resource_type", "commit"]
              }, 
              then: "$resource.hash" 
            },
            {
              case: { 
                $eq: ["$resource.resource_type", "repository"]
              }, 
              then: "$resource.name" 
            },
            {
              case: { 
                $eq: ["$resource.resource_type", "table"]
              }, 
              then: "$resource.name" 
            },
            {
              case: { 
                $eq: ["$resource.resource_type", "database"]
              }, 
              then: "$resource.name" 
            }
          ]
        }
      }
    }
  },
  {
    $project: {
      _id: false,
      email: "$owner.emails",
      resource_type: "$resource.resource_type",
      id: "$resource_id"
    }
  }
 ] )

Graph

In graph DBs, properties are attached directly to the nodes that own them, rather than being nodes themselves

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  10. 10
  11. 11
  12. 12
  13. 13
  14. 14
  15. 15
  16. 16
  17. 17
  18. 18
  19. 19
  20. 20
  21. 21
  22. 22
  23. 23
  24. 24
  25. 25
MATCH
  (user:User)-[:OWNS]->(rsrc:Resource)
WITH
  rsrc,
  [user.primary_email] + user.alias_emails AS emails,
  labels(rsrc) AS resource_types,
  keys(rsrc) AS properties
UNWIND emails AS email
UNWIND resource_types AS resource_type
WITH
  rsrc, email, resource_type, properties,
  {
    File: "path",
    Directory: "path",
    Commit: "hash",
    Repository: "name",
    Table: "name",
    Database: "name"
  } AS id_type_map
WHERE resource_type IN keys(id_type_map)
AND id_type_map[resource_type] IN properties
RETURN email, resource_type, rsrc[id_type_map[resource_type]] AS id

The power of a knowledge graph

TypeDB uses a hypergraph model to represent entities, relationships, and nested concepts natively, making it uniquely suited for applications where context, structure, and inference matter.

TypeDB Studio
A visualization of the Social Network TypeDB schema in TypeDB Studio

Explore with our live web studio

Want to dive in and see what TypeDB can do? Sign up to Cloud and connect instantly to our web studio to see what we can do in just a few minutes.

TypeDB Studio
A screenshot of TypeDB Studio's Query page showcasing all of its tool windows

Collaborate with other builders

We are used by major enterprises, cutting edge AI businesses, world-leading researchers, and everything else you can imagine.

GitHub

Discord

YouTube

LinkedIn

Leverage the power of programming.
In your database

Using the Polymorphic-Entity-Relations-Attribute (PERA) model as the basis of TypeQL leads to a general, expressive, intuitive, and strongly typed language! Since data must be instantiated from the schema, the system can make strong guarantees about data integrity and shape.

Write less to do more

Queries are shorter, more intuitive, and more expressive. You don’t have to specify how data joins; Just say what you need and retrieve it in a simple, single database call.

Learn more

Eliminate a significant amount of your tech debt

Data logic belongs in the structure, not the query. Our query variables match all valid types so doesn’t need updating even when you add new subtypes.

Learn more

Your data holds more answers than you know

TypeDB is the only database built for interconnected data and intelligent applications. Build systems that understand, reason, and adapt, solving problems traditional databases cannot.

TypeDB Studio
A schema tree in TypeDB Studio

Batteries included

Connect your production application with our dedicated drivers, supporting the major languages, with more added regularly.

Rust

Java

Python

TypeScript

C#

C++

C

View all in docs →

Useful resources to get started

What is an entity-relation database?

Breaking down our novel database. Learn about what it means to be an entity-relation database.

Read article

A new dimension of database design

TypeDB is built on a rich, expressive type system that validates queries, enforces semantics, and unlocks semantic optimisation. A safer, smarter foundation for complex systems.

Read article

TypeDB Studio is now in your browser

Explore knowledge graphs, design schemas, and write queries—now in your browser.

Read article

Start free, upgrade when ready

Go to production in weeks, not months

TypeDB delivers a clear, structured data model and a human-readable, beautiful query language, ideal for powering agentic systems, cyber threat intelligence, robotics and much more.

Start building
A screenshot of TypeDB Studio's Query page showcasing all of its tool windows
Feedback