TrustGraph

TrustGraph is an open-source platform for building agent systems around context graphs, retrieval, orchestration, and inference. It combines document processing, graph and vector storage, GraphRAG, Ontology RAG, agent tools, and model-provider abstraction in one deployable knowledge layer.

Its distinctive strength is the way these capabilities operate together: structured and unstructured evidence share a retrieval layer, extraction and retrieval provenance remain queryable, knowledge can be isolated in portable Context Cores, and completion and embedding providers can be configured independently.

Architectural position

TrustGraph can sit between task agents and the underlying knowledge estate:

flowchart LR
    S["Documents, media, databases, and APIs"] --> I["TrustGraph ingestion and extraction"]
    I --> K["Context graph, vectors, objects, and source artifacts"]
    T["Task agent using a capable model"] --> Q["Knowledge agent or retrieval boundary"]
    Q --> K
    Q -->|"Selected grounded context"| T

Capability	TrustGraph’s approach	Related concept
Knowledge access	GraphRAG, Document RAG, Ontology RAG, structured queries, and agent knowledge tools	The Knowledge Base
Knowledge isolation	Context Cores package graph data, embeddings, schema, and metadata into independently loadable units	Context, Security & Prompt Injection
Model control	Self-hosted deployment, pluggable completion providers, and separately configured embedding models	Choosing a Model, Smart Routing
Structured extraction	Custom OWL ontologies constrain the entities and relationships extracted from source material	The Knowledge Base
Provenance	Source and retrieval lineage are stored as queryable RDF using W3C PROV-O	Execution Ledger
Data processing	Event-driven flows process documents into graphs, vectors, structured objects, and stored source artifacts	Durable Agent Execution

Context Cores and controlled retrieval

Context Cores package graph data, embeddings, schema, and metadata into independently loadable units. TrustGraph can load, unload, copy, and delete these units through its APIs, which makes them useful for isolating collections, moving prepared knowledge between environments, and selecting which bodies of knowledge are active.

Self-hosting, local-model support, provider abstraction, and explicit knowledge-query tools allow retrieval to run separately from the model performing the broader task. For example, an open-weight model can perform extraction and retrieval before a small grounded subgraph is passed to another model for synthesis.

Context Cores are an isolation and deployment mechanism, not a complete authorization system. Applications still need to decide which actors may query each core, redact sensitive results, audit access, and control what retrieved material may leave the knowledge boundary.

Multimodal and structured knowledge

TrustGraph separates source artifacts from the representations used for retrieval. Its platform describes support for documents, structured data, graphs, vectors, images, audio, and video, while its documented processing features include optical character recognition for images and scanned material. Extracted relationships can live as RDF triples, structured objects can remain queryable through APIs, and original artifacts can remain in object storage.

Ontology RAG constrains extraction with a custom OWL ontology that defines permitted classes, properties, and relationships. This gives TrustGraph a domain-specific structured representation while retaining the source artifact and other derived retrieval surfaces.

The ontology must be owned and evolved outside TrustGraph’s extraction pipeline. Changes can require migration and reprocessing, while an ontology that is too rigid can omit information that does not fit its vocabulary.

Provenance as queryable knowledge

TrustGraph distinguishes the core knowledge graph from two supporting graphs:

• urn:graph:source records extraction provenance from a source document through pages and chunks to extracted edges.
• urn:graph:retrieval records how a query was grounded, explored, and synthesized.

Both use RDF and the W3C PROV-O vocabulary, making lineage part of the queryable data rather than an attached text log. A query can inspect which source chunk produced a relationship and which retrieval path grounded a response.

TrustGraph records lineage, not truth. Its provenance graphs do not assign source authority, resolve contradictions, or prove that an extracted claim is correct.

Processing and lifecycle primitives

TrustGraph provides operating primitives for knowledge processing and lifecycle operations: an event-driven processing architecture, asynchronous library processing, document and collection management, independently loadable Context Cores, and APIs to unload or delete cores. These make recurring ingestion and replacement possible.

These primitives support recurring ingestion and replacement, but they do not automate the full knowledge lifecycle. Source-change detection, derived-data retraction, contradiction resolution, expiry, authority, confidence, and post-change evaluation remain application responsibilities.

Boundaries and trade-offs

• Retrieved context is visible to the model that receives it; self-hosting and local retrieval minimize disclosure but do not guarantee confidentiality.
• Context Cores isolate and package knowledge, but actor-level authorization and result redaction must be enforced by the surrounding application.
• PROV-O graphs expose extraction and retrieval lineage, but lineage does not establish truth, confidence, recency, or source authority.
• Custom ontologies improve structural consistency at the cost of schema ownership, versioning, migration, and reprocessing.
• Load, unload, copy, and delete operations provide lifecycle primitives, but they do not decide when knowledge should expire, be superseded, or be reconciled.

TrustGraph is strongest when a system needs one deployable layer for graph and vector retrieval, ontology-constrained extraction, queryable provenance, multimodal processing, Context Core isolation, and model-provider choice. Its limits are primarily policy and curation boundaries rather than missing storage or retrieval mechanisms.

Sources

• TrustGraph documentation: Introduction
• TrustGraph documentation: Architecture
• TrustGraph documentation: Information retrieval
• TrustGraph documentation: Storage
• TrustGraph documentation: Ontologies
• TrustGraph documentation: Context Cores
• TrustGraph documentation: Document processing
• TrustGraph documentation: Features
• TrustGraph source repository