Utopia: Bitemporal Knowledge Graphs for Enterprise Intelligence

The problem: knowledge systems that overwrite instead of record

A vector store holds embeddings of documents. A knowledge graph holds named entities and relationships. Both answer questions about the present state: What films did actor X appear in? What is the inventory level? But neither records how a company changed its mind. When a supplier's credit rating drops, traditional systems update the node. When safety data revises a chemical's toxicity, they overwrite it. In a compliance review or a scientist's replication study, you need to know what the system believed and when it changed. Utopia records that full history: every fact carries a timestamp for when it held in the world and when the system learned it. Correcting a fact does not erase the old one; it links the new one back, so the graph keeps both timelines.

How Utopia builds knowledge: ingest, extract, ontology, and revision

Utopia takes documents in (PDF, DOCX, XLSX, CSV, web pages, RSS feeds, GitHub, Jira, Notion, WebDAV, S3 buckets) and converts them to entities and facts. A Tantivy full-text index handles search, and pgvector stores embeddings alongside the graph. The system extracts entities and relationships following an ontology: a formal description of what types of things exist (Person, Company, Contract) and how they relate (Person worksAt Company). Utopia ships with five built-in packs (schema.org, W3C Org, PROV-O, FOAF, IOF Core) and lets you edit the ontology as you work. When extraction is uncertain (an entity might be a duplicate, a cardinality rule seems broken), Utopia flags it for human review. The decisions people make in the review queue are recorded and used to tune the extraction model, closing the loop. This three-step process (ingest, extract with ontology, review and refine) is the basis of the whole system.

Installing Utopia and loading your first documents

Utopia requires one Rust binary and PostgreSQL 16 or later with the pgvector extension. The simplest deployment uses Docker Compose:

git clone https://github.com/deeplethe/utopia.git
cd utopia
docker compose --profile app up -d

By default, it binds to port 1516. Open http://localhost:1516 in a browser to reach the web UI. The first user to register becomes an administrator; subsequent users can be invited by admins or register automatically if UTOPIA_OPEN_REGISTRATION is true in the .env file. The docker-compose.yml includes a postgres service with pgvector and exposes the database on port 1517 locally.

To load documents, use the Upload button in the console, or configure ingest from external sources (GitHub, Notion, S3) by creating a source and setting a sync schedule. Extraction and embedding run asynchronously; indexing takes from seconds to minutes depending on document size and load. Configuration options in the .env file control the database connection pool (default 32 connections), the JWT signing key, and whether SSO is enabled through OIDC.

For production, Utopia runs on any Linux distribution with Docker and Postgres, and can be deployed as a single binary (cargo build --release, run the utopia-server crate). Configuration is environment variables prefixed with UTOPIA_. A restricted database role (UTOPIA_APP_DB_PASSWORD) can lock the app to read operations on business data and append-only operations on audit tables. The workspace is modular: separate crates for core logic (utopia-core), storage (utopia-store), ingest, extraction, reasoning, full-text search and LLM integration allow for independent maintenance and testing.

Why bitemporal is harder but matters when decisions get reviewed

Most systems keep one timeline: the current truth. Utopia keeps two: valid time (when a fact was true in the world) and system time (when the database learned it). If a contract's start date was reported wrong and corrected in an amendment, valid time records both periods; system time shows when the correction landed. In practice, this costs storage and makes queries more complex. a simple "select all active contracts" becomes "select contracts where valid_from <= today and (valid_to is null or valid_to >= today) and (system_to is null or system_to = the_latest_version)". But when an auditor asks what the system believed on 2025-03-15, or when a researcher replicates a decision, the data is there. Teams that do not need that audit trail should use a standard knowledge graph.

Why the ontology is worth editing, and when it holds you back

Extraction only works as well as the ontology lets it. If the ontology has a Company type but no Subsidiary relation, the system cannot extract "Company A is a subsidiary of Company B" unless you add the relation. The built-in packs cover standard business data: schema.org (general web vocabulary), W3C Org (organizations and roles), PROV-O (provenance and causality), FOAF (people and their profiles), and IOF Core (industrial foundations). These cover organizations, people, contracts, and provenance but not vertical-specific domains. The repository has an issue template for ontology requests labeled "enhancement", and the maintainers respond, but there is no subscription or SLA. If your documents describe a novel domain (nanoparticle properties, obscure legal doctrines, mineral compositions), you will need to design the ontology yourself, which requires understanding both the domain and Utopia's formal rules (transitivity, symmetry, cardinality). That is not a barrier for teams with a knowledge engineer, but it is a design challenge if you are trying to get working systems without specialized expertise.

Agent harness and agentic RAG without external dependencies

Utopia ships with a built-in agent that can search documents, walk the graph (asking questions like "what changed between January and March"), and query mounted databases. The agent works with any OpenAI-compatible endpoint: OpenAI, DeepSeek, Qwen, GLM, Ollama, or vLLM. Because the endpoints are pluggable, Utopia can run fully air-gapped: call a local LLM and never send data to a cloud provider. The same tools are exposed over Model Context Protocol (MCP), so agents in Claude Desktop, Cursor, Workbuddy and other agent frameworks can connect and search the knowledge base with fine-grained permissions. The MCP integration means you can ask questions in a general-purpose agent tool and have it search Utopia's documents as one capability among many. That is unusual: most knowledge platforms make you query through their own chat interface or API. Search combines full-text (using Tantivy) with vector search (pgvector) fused using reciprocal rank fusion (RRF), and answers stream with inline citations that open the source passages.

The release candidate caveat and active maintenance

The current release is v0.1.0-rc7 (September 25, 2026). The last push to GitHub was September 28, one day before this article. The project has frequent releases (rc6 on September 19, rc5 on September 5), and the maintainers are actively merging pull requests and responding to issues. However, being a release candidate means the API may change, and some features are still being refined. The ontology system and the bitemporal model are mature, but agent behavior and conflict resolution rules have been revised across recent releases. A team considering Utopia for a long-term system should test the current version thoroughly and plan for updates.

Editorial conclusion

Utopia is for enterprises that need to audit how decisions were made: audit trails, compliance documentation, or long-running research projects where revisiting a decision means finding the evidence that led to it. Skip it if a simple vector store answers your question, or if you need a fully stable release rather than a release candidate. Start by reading the philosophy section at utopia.bi/philosophy, then run the Docker image locally with a small document collection to see whether the two-timeline graph model fits your use case.

Frequently asked questions

Official sources

1. deeplethe/utopia on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases