Asami is both similar to and different from other graph databases. Some of the goals of the project are:

Schema-less data. Data can be loaded without prior knowledge of its structures.
Stable. Storage uses immutable structures to ensure that writes cannot lead to data corruption.
Multiplatform. Asami runs on the Java Virtual Machine and on JavaScript platforms (browsers, node.js, etc).
Ease of setup. Asami managed storage requires no provisioning, and can be created in a single statement.
Pluggable. Storage is a pluggable system that allows for multiple storage types, both local and remote.
Analytics. Graph analytics are provided by using internal mechanisms for efficiency.

Asami is a schemaless database, meaning that data may be inserted with no predefined schema. This flexibility has advantages and disadvantages. It is easier to load and evolve data over time without a schema. However, functionality like upsert and basic integrity checking is not available in the same way as with a graph with a predefined schema. Optional schemas are on the roadmap to help with this.

Asami also follows an Open World Assumption model, in the same way that RDF does. In practice, this has very little effect on the database, beyond what being schemaless provides.

If you are new to graph databases, then please read our Introduction page.

Asami has a query API that looks very similar to a simplified Datomic. More details are available in the Query documentation.

A lot of us feel a little lost as we start to use Clojure and try to make sense of how we should model data. If we came from a schema or type-based system many of us are tempted to apply those skills directly. We have a notion (reinforced by talks we watch) that these namespaced keywords are important, but we often struggle to apply those concepts pragmatically.

In this talk, I’ll discuss how the ideas of context-free federated names (a.k.a. namespace-qualified keywords) have become more concrete and pragmatic to me during my use of them at NuBank. I’ll talk about my realizations on how they can be used in practical ways that lead to a high level of clarity in our data models and communication systems, and open up better flexibility and reach.

Finally, I’ll relate these concepts to recent advances in the communication of this kind of data at the systems level as a graph, and show how industry standards like GraphQL continue to suffer from problems of composition and generality, while Clojure’s approach leads to an open information system with maximal utility: the Maximal Graph.

Graph is a simple, declarative abstraction to express compositional structure.

Declarative means that we should explicitly list a system’s components and dependencies in a way that is accessible to our tooling. This solves the issues of the previous section, enabling abstractions over a system’s components as well as reasoning about the composition as a whole. Of course, this idea is not new; for example, it is the basis of graph computation frameworks like Pregel, Dryad, and Storm, and existing libraries for system composition such as react.

Our primary objective in Graph is to distill this idea to its simplest, most idiomatic expression in Clojure, our language of choice. Concretely, a Graph is just a Clojure map of functions that can depend on the outputs of other functions. Because Graphs are just ordinary data, we can manipulate them for free using our favorite existing tools, making Graphs trivially easy to create, modify, run, reason about, test, and build upon. Put simply, Graph is an [FCA][swe] for composition.

It is better to have 100 functions operate on one data structure than 10
functions on 10 data structures.
  -- Alan Perlis

As a first attempt in this direction, we could rewrite our stats example as a Clojure map, turning let variables into keywords and wrapping each of the corresponding value expressions in anonymous functions.

This gets us 90% of the way there. The individual components of the computation are now explicit, but the dependency information is still missing. For instance, there’s no way for our tools to know that the m in the arguments to the :v function refers to the mean computed in the second step of the graph – after compilation, it’s just the first argument to an anonymous function.

• GitHub - plumatic/plumbing: Prismatic's Clojure(Script) utility belt · GitHub
• Plumbing 0.4.0 API documentation

Modern IT systems manage an increasing amount of data, sometimes bound by sophisticated models, that require specific representations of the same information in order to perform translation between various software layers

As consequence, software developers have to provide descriptions in data and constraints/relations of these systems, this is what we call data-models

Not all the data-models are the same, one criteria we can use to differentiate them is the kind of relationships between the objects

• Models with one-to-many relationship ( aka "tree-like" )
• Models with many-to-many relationship ( aka "graph-like" )

The one-to-many relationship can be modelled using a tree structure which can be easily represented using the JSON data language

On the other hand, representing many-to-many relationships leads to design decisions in how to represent the data : in other words, a conditional expression of some edges and vertices.
Tree vs Graph

Thus, the technical choices made on the data modelling aspect of software design will affect the system behaviour, its overall performances, as well as the efficiency of the tools that support it.

In this presentation, we explore the concept of knowledge databases, which represent entities and their relationships in a structured and semantic way. By combining this model with immutability—where data is never overwritten, only accumulated—it becomes possible to build systems with a complete, auditable history and native versioning. This approach is particularly powerful in complex ecosystems like Nubank’s, where thousands of microservices interact. We’ll show how modeling these interactions as a knowledge database allows us to uncover patterns, dependencies, and insights that are otherwise hidden, ultimately helping teams understand and evolve the system more safely and intelligently.

Biography

Darlei Soares and João Nascimento are software engineers and data enthusiasts with deep experience in building systems around immutable knowledge databases. Currently part of the engineering team at Nubank, Darlei and João both work on designing and maintaining highly distributed services that leverage Datomic at scale, powering financial operations for millions of customers.

Recorded Nov 13, 2025 at Clojure/Conj 2025 in Charlotte, NC.

DF is a directed, labeled graph data format for representing information in the Web. This specification defines the syntax and semantics of the SPARQL query language for RDF. SPARQL can be used to express queries across diverse data sources, whether the data is stored natively as RDF or viewed as RDF via middleware. SPARQL contains capabilities for querying required and optional graph patterns along with their conjunctions and disjunctions. SPARQL also supports aggregation, subqueries, negation, creating values by expressions, extensible value testing, and constraining queries by source RDF graph. The results of SPARQL queries can be result sets or RDF graphs.

A graph database built for data that matters. Temporal, verifiable, standards-compliant.

Fluree stores data as RDF triples with complete history, integrated search, and fine-grained access control — in a single binary with no external dependencies.

Billions of triples on commodity hardware. Over 2M triples/second bulk import. Benchmark leader across 105 W3C SPARQL queries.

PlantUML is a component that allows you to quickly write:

• Sequence diagram

  @startuml
  Alice -> Bob: Authentication Request
  Bob --> Alice: Authentication Response
  Alice -> Bob: Another authentication Request
  Alice <-- Bob: Another authentication Response
  @enduml

  

• Usecase diagram

• Class diagram

• Object diagram

• Activity diagram (here is the legacy syntax)

• Component diagram

• Deployment diagram

• State diagram

• Timing diagram

GitHub - plantuml/plantuml: Generate diagrams from textual description
Official Javadoc Documentation: Overview (plantuml 1.2024.7beta2 API)

Graphviz is open source graph visualization software. Graph visualization is a way of representing structural information as diagrams of abstract graphs and networks. It has important applications in networking, bioinformatics, software engineering, database and web design, machine learning, and in visual interfaces for other technical domains.

Graph visualization is a way of representing structural information as diagrams of abstract graphs and networks. Automatic graph drawing has many important applications in software engineering, database and web design, networking, and in visual interfaces for many other domains.

Graphviz is open source graph visualization software. It has several main graph layout programs. See the Gallery for some sample layouts. It also has web and interactive graphical interfaces, and auxiliary tools, libraries, and language bindings.

The Mac OS X edition of Graphviz, by Glen Low, won two 2004 Apple Design Awards.

The Graphviz layout programs take descriptions of graphs in a simple text language, and make diagrams in several useful formats such as images and SVG for web pages, Postscript for inclusion in PDF or other documents; or display in an interactive graph browser. (Graphviz also supports GXL, an XML dialect.)

Graphviz has many useful features for concrete diagrams, such as options for colors, fonts, tabular node layouts, line styles, hyperlinks, and custom shapes.

In practice, graphs are usually generated from an external data sources, but they can also be created and edited manually, either as raw text files or within a graphical editor. (Graphviz was not intended to be a Visio replacement, so it is probably frustrating to try to use it that way.)

Graph-tool is an efficient Python module for manipulation and statistical analysis of graphs (a.k.a. networks). Contrary to most other python modules with similar functionality, the core data structures and algorithms are implemented in C++, making extensive use of template metaprogramming, based heavily on the Boost Graph Library. This confers it a level of performance that is comparable (both in memory usage and computation time) to that of a pure C/C++ library.

NetworkX is a Python package for the creation, manipulation, and study of the structure, dynamics, and functions of complex networks.

Features

• Data structures for graphs, digraphs, and multigraphs
• Many standard graph algorithms
• Network structure and analysis measures
• Generators for classic graphs, random graphs, and synthetic networks
• Nodes can be "anything" (e.g., text, images, XML records)
• Edges can hold arbitrary data (e.g., weights, time-series)
• Open source 3-clause BSD license
• Well tested with over 90% code coverage
• Additional benefits from Python include fast prototyping, easy to teach, and multi-platform

This wiki page is a resource for some brainstorming around the possibility of a Python Graph API in the form of an informational PEP, similar to PEP 249, the Python DB API. The goal would be, in other words, to define how a graph (or various kinds of graphs) would be expected to behave (possibly from different perspectives) in order to increase interoperability among graph algorithms. The numeric array interface, recently developed by the Numeric Python community to increase interoperability between array-handling software, illustrates the general idea.

This post is Part 3 of a 4-part series about Kubernetes monitoring. Part 1 discusses how Kubernetes changes your monitoring strategies, Part 2 explores Kubernetes metrics and events you should monitor, this post covers the different ways to collect that data, and Part 4 details how to monitor Kubernetes performance with Datadog.

Graphite does two things:

1) Store numeric time-series data
2) Render graphs of this data on demand

What Graphite does not do is collect data for you, however there are some tools out there that know how to send data to graphite. Even though it often requires a little code, sending data to Graphite is very simple.