Tip

Due to other commitments, this project will resume in February 2026.

Note

The status of this project is a stable current version, and development is paused while background work is being done.

• Join the SSTorytime LinkedIn Group for questions and discussions.
• Quick installation options now with provisional scripts to simplify the setup
• TO-DO List and HOW YOU CAN CONTRIBUTE!
• Welcome!

SSTorytime

(A Unified Graph Process For Mapping Knowledge)

Imagine a tool that would help you to know your own thinking, to capture it, visualize it, and make it searchable for those days when your scatterbrain isn’t working on all cylinders. This is the thinking behind SSTorytime. We might not call such a tool Artificial Intelligence; rather, we might call it a "cyborg enhancement". Still, the results would be useful for training and teaching of human or machine intelligence alike. Such a toolset is the goal of the open source SSTorytime Knowledge project. The issue of what kind of graph you should make is secondary to the issue of understanding what knowledge means, and how we will use it. Neither topic maps nor rdf communities got this right in the past.

• Get going with the documentation or keep scrolling for some background and highlights...

SSTorytime is an independent Knowledge Graph, based on Semantic Spacetime. It is not an Topic Map or RDF-based project. It aims to be both easier to use and more powerful than RDF.

Graphs are the language of spacetime process

Graphs are popular once again, but the technologies for dealing with them are clunky and designed by technologists rather than scientists. This project makes working with graphs simple.

Graphs may be used:

• As visualization of processes.
• As a map of space and time.
• As a map of a process, like Gant charts and path integrals.
• As computational device (a multi-matrix algebra representation).
• - e.g. social networks with centralities and flow patterns, link weight as contact frequencies...
• As a distributed index over semantic relationships.
• And more ...

If you want to know the deep background behind the Semantic Spacetime concept and its approach, you can read the book shown to the right. **N.B. This book is conceptual background, not a tutorial or HOW-TO manual.**

Deep Dive into this Semantic Spacetime Project (SST)

Keywords, tags: Open Source Smart Graph Database API for Postgres, Go(lang) API, Explainability of Knowledge Representation

• See these Medium articles for a conceptual introduction:

• • Getting To Know Knowledge--How Can Semantic Graphs Actually Help Us?
• • What is semantic search?
• • Why Semantic Spacetime (SST) is the answer to rescue property graphs
• • From cognition to understanding:
• • Searching in Graphs, Artificial Reasoning, and Quantum Loop Corrections with Semantics Spacetime
• • The Shape of Knowledge part 1
• • The Shape of Knowledge part 2
• • Why are we so bad at knowledge graphs?
• • The Role of Intent and Context Knowledge Graphs With Cognitive Agents
• • Designing Nodes and Arrows in Knowledge Graphs with Semantic Spacetime
• • Avoiding the Ontology Trap: How biotech shows us how to link knowledge spaces
• • Using Knowledge Maps for Learning Comprehension
• • Unifying Data Structures and Knowledge Graphs
• • Using Knowledge Graphs For Inferential Reasoning
• • Building A Knowledge Graph of a Music Collection: A case study in building Knowledge Graphs from Data Structures
• • Using N4L notes and SST Knowledge Graphs For Foreign Language Learning

This project aims to turn intentionally created data (like written notes or snippets cut and pasted into a file) into linked and searchable knowledge maps, tracing the stories that we call reasoning, and solving puzzles by connecting the dots between bits of information you curate.

For instance...

You might want to look up something ad hoc:

You might want to be prompted for reminders:

You might be surveying the breadth of your knowledge:

Or just curious about something:

The concept

Knowledge maps are graph (network) structures that link together events, things, and ideas into a web of relationships. They have enjoyed renewed interest in recent years, because of "AI" -- but, since the 1990s, people have largely been doing them wrong--trying to model things and ideas instead of processes.

Graphs are great ways to find out where processes start and stop, who is most important in their execution, the provenance of transacted things or ideas, and their rate of spreading, etc etc. The pathways through such a web form journeys, histories, or stories, planning itineraries or processes, depending on your point of view. We can interpret graphs in many ways. Your imagination is the limit,

Stories are one of the most important forms of information, whether they describe happenings, calculations, tales of provenance, system audits... Stories underpin everything that happens.

Getting data into story form isn't as easy as it sounds, so we start by introducing a simple language "N4L" to make data entry as painless as possible. Then we add tools for browsing, visializing, analysing the resulting graph, solving for paths, and divining storylines through the data. The aim is to support human learning, and to assist human perception--though the results may be used together with "AI" in the future. Finally, there will be an API for programmers to incorporate these methods into their own explorations, either in Go or in Python. As a sort of "better, faster Python", Go is recommended for power scripting.

Note-taking may be an intuitive but semi-formal approach to getting facts for reasoning, for knowledge capture, querying, and dissemination of individual thinking easy, for humans and general use. (AI can only capture knowledge from humans, so even if we want to use AI, we'd better get the knowledge representations right.) Whether we are analysing forensic evidence, looking for criminal behaviour, learning a foreign language, or taking notes in school for an exam.

Today, computer tools ask people to enter data through APIs by programming, or by typing into special forms that are stressful and unnatural. We can do better, just as we can do better at retrieving the information and searching it.

Imagine being able to take notes easily, work with them, and later be able to "rummage around" in everything to understand what you were thinking, and how it all fits together. In other words, remaining in control of what you see and ask, rather than handing over to a batch job summary by an LLM text tool in which you get an answer `take it or leave it'.

• Getting started
• The Mission of SSTorytelling
• A quick tutorial
• An example / case study
• Basics of Knowledge Engineering
• How does context work?
• Dynamic Node Content with in-built functions
• N4L - Notes For Learning/Loading
• searchN4L - preliminary search/testing tool
• pathsolve - preliminary path solving tool
• Related work and links
• API - An overview of the golang programmers API.
• FAQ

History

The roots of this project go back almost 20 years for me, when I was working in configuration management (with the CFEngine project) and realized that the main problem there was not fixing machinery but rather understanding the monster you've created! Knowledge Management was built into CFEngine 3, but later removed again when `the market wasn't ready'. Over those 20 years, I've studied and learned how to approach the problem in better ways. I've implemented the concepts using a variety of technologies, including my own. In this latest version, I'm combining those lessons to make a version that builds on standard Postgres.

While the actual graphs in knowledge might not turn out to be anything like the beautiful fabrications one sees in fancy online graph engines, the information is still important. Most knowledge is patchy and disconnected. Knowledge capture requires tools for collecting factual notes, data relationships, and structures for representing and organizing them, so that they can be found easily. Many mistakes have been made around this in the past, trying to force discipline onto people at the wrong moment and neglecting to do so when it matters. As a lifelong teacher of ideas, I've studied this problem and think we can do better than what we have today.

One of the goals of this project is to better understand what we call "reasoning". One used to think of reasoning, philosophically, as logical argumentation. As computers entered society we replaced this idea with actual first order logic. But, if you ask a teacher (and if we've learned anything from the Artificial Intelligence journey) then we realize that the way humans arrive at conclusions has a more complicated relationship to logic. We first decide emotionally, narrowly or expansively depending on our context, and then we try to formulate a "logical" story to support that. This is why we strive to study the role of stories in learning and understanding for this project.

The tools

The tool-set consistent of several components, starting with:

• N4L - The N4L compiler (This is now merged with N4L-db)

• searchN4L - a simple and experimental command line tool for testing the graph database

• text2N4L - scan a text file and turn it into a set of notes in N4L file for further editing

• removeN4L - remove an uploaded chapter from the database

• notes - a simple command line browser of notes in page view layout

• pathsolve - a simple and experimental command line tool for testing the graph database

• graph_report - a simple and experimental command line tool for reporting on graph data, detecting loops, sources, sinks, etc, symmetrizing on different links and finding eigenvector centrality.

• http_server - a prototype webserver providing the SSTorytime browsing service

• API_EXAMPLE_1 - a simple store and retrieve example of the graph database.

• API_EXAMPLE_2 - multi/hyperlink example, joining several nodes through a central hub.

• API_EXAMPLE_3 - a maze solving example, showing higher functions.

• API_EXAMPLE_4 - a path solving example, with loop corrections (quantum style).

• python_integration_example.py - a basic Python example

• SSTorytime.py - Includable Python interface for SSTorytime, basic functions (TBD)