Knowform

Knowform is a personal Rust project for building knowledge graphs from structured data that I used in my work at RISE to map our organisation and provide strategic overviews of its structure.

The repository is here: erikkallman/knowform

The original idea behind Knowform was to create a framework for ingesting organisational data and turning it into a graph. The graph could then be used for strategic mapping of how an organisation is structured, how people relate to projects, and how documents, metadata, units, departments, and responsibilities connect.

The current ontology support is centered on organisational entities such as:

• organisations
• companies
• divisions
• departments
• units
• employees
• projects
• documents
• metadata

Knowform takes JSON data, deserializes it into domain entities, and represents those entities as vertices and edges. The goal is to make organisational structure visible as a graph instead of keeping it spread across separate data files, reports, and systems.

I wanted to explore how far a strongly typed Rust system could be pushed as a foundation for knowledge graph construction.

A lot of organisational data already exists in structured or semi-structured formats as shown in the mockup data. Employee records, project descriptions, CVs, time reports, department structures, and metadata can all describe relationships. Knowform was an attempt to make those relationships explicit.

The project is also a way to experiment with strategic mapping. Instead of only storing facts about an organisation, the system tries to infer useful relationships between those facts. Examples include employees belonging to units, employees being active in projects, projects having time reports, and documents being associated with employees or projects.

Knowform is built around a few main ideas and design decisions.

• JSON is used as the ingest format.
• Domain entities become graph vertices.
• Relationship rules create graph edges.
• Edges have meanings, such as EmployeeBelongsToUnit or EmployeeActiveInProject.
• Metadata is tracked so graph data can be traced back to its source.
• The graph can be adapted to external graph databases, with current support for Neo4j.
• SQLite is used internally for local graph and metadata storage.

Rust was chosen because the project depends heavily on type safety. The data model has many entity types and relationship rules, so compile-time checks are useful. Rust also fits the performance side of the idea: ingesting larger datasets, processing relationships, and building graph structures should be fast and predictable.

Also writing Rust code makes me happy.

The organisational ontology is the most developed part of the project.

At the moment, Knowform can model entities such as employees, departments, units, projects, documents, and metadata. It also defines relationship meanings between those entities. These meanings are important because they turn a basic graph into something closer to a domain model.

For example, an edge between an employee and a unit is not just a generic connection. It can mean that the employee belongs to the unit. An edge between an employee and a project can mean that the employee is active in that project, is the project leader, or is the project owner.

This gives the graph enough structure to support questions about organisational shape, responsibility, and project involvement.

Knowform is a piece in a framework on prototype stage. It is not a polished product.

The main value of the project is the architecture and the exploration of how organisational knowledge can be modeled as a graph. The codebase contains support for REST endpoints, JSON ingest, graph construction, edge rules, metadata tracking, and Neo4j output.

Some parts are still rough. Some model fields are pragmatic rather than elegant. The project also reflects experimentation with graph theory, category theory concepts, and Rust application structure.

The interesting direction for Knowform is strategic organisational mapping.

That could include:

• mapping formal and informal organisational structures
• tracing which people are connected to which projects
• showing how documents and reports relate to organisational entities
• identifying responsibility patterns across departments and units
• tracking how organisational graphs change over time
• supporting richer domain ontologies beyond the current organisation model

The larger idea is to treat organisational knowledge as a graph that can be inspected, extended, and reasoned about.

Knowform is my attempt to build the framework for that idea in Rust.