# How OpenHuman's `memory-git` Feature Uses Git for Wiki Backups, Checkpoints, and Diffs

> Explore OpenHuman's memory-git feature. Discover how it uses Git for automatic wiki backups, checkpoints, and diffs, version-controlling your agent's knowledge graph.

- Repository: [Tiny Humans/openhuman](https://github.com/tinyhumansai/openhuman)
- Tags: how-to-guide
- Published: 2026-08-27

---

**The `memory-git` feature in OpenHuman leverages the `git2` crate to version-control the agent's knowledge graph, enabling automatic Git commits for checkpoints, exportable Markdown wikis for backups, and computable diffs between memory states.**

OpenHuman stores an AI agent's long-term knowledge in its **Memory** domain, and the optional `memory-git` feature adds Git-based versioning for durability and auditability. When enabled via the `memory-git` Cargo flag, this system transforms volatile memory states into durable commits, providing three core capabilities through direct integration with the **git2** library.

## Three Core Capabilities of the memory-git Feature

The `memory-git` implementation divides its functionality into three distinct operational modes: wiki export for human-readable backups, automatic checkpointing for state preservation, and differential analysis for audit trails.

### Wiki Backups via Markdown Export

The wiki backup system converts the entire memory graph into a Git-compatible repository of Markdown files. Located in `src/openhuman/memory/wiki`, the `wiki::export` implementation handles serialization and remote synchronization.

This module creates a set of Markdown files representing the knowledge base and uses the **git2** crate to initialize a repository, stage files with `repo_add_all()`, and commit changes. The resulting repository can be pushed to a remote URL configured in [`src/openhuman/config/schema/memory.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/config/schema/memory.rs) under `git.wiki.remote_url`, providing a durable, human-readable backup that supports external editing.

### Configurable Checkpoints

At configurable intervals—either on each conversational turn or via a timer—the current memory state is snapshotted into a Git commit. The checkpoint logic lives in [`src/openhuman/memory/checkpoint.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/checkpoint.rs), specifically within the `Checkpoint::save` function.

This function serializes the memory graph using the shared serialization logic in [`src/openhuman/memory/serialization.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/serialization.rs), writes the output to the repository's working tree at `.openhuman/memory.git`, and creates an immutable commit via `git2::Repository::commit`. This creates a complete history of the knowledge base that supports rollback to any prior point.

### Diff Generation and Audit Trails

When memory changes occur, OpenHuman computes a textual diff between snapshots and records it as a Git patch. The `DiffEngine` struct in [`src/openhuman/memory/diff.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/diff.rs) orchestrates this process.

The engine loads two commit trees using the `git2` API, invokes `git2::Tree::diff` to produce a `git2::Diff` object, and extracts the resulting patch. This diff can be inspected, applied, or reverted, enabling fine-grained audit trails of how the agent's knowledge evolved over time.

## Implementation Architecture

Under the hood, the `memory-git` feature relies on a layered architecture that abstracts Git operations while maintaining zero-cost abstractions for builds that disable the feature.

### Repository Initialization and Driver Layer

When the `memory-git` feature is compiled, the **git2** dependency links against libgit2. The memory subsystem creates or opens a Git repository at `.openhuman/memory.git` in the user's workspace, managed by [`src/openhuman/memory/driver/git.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/driver/git.rs).

This driver file contains wrapper functions that encapsulate common Git workflows:

- `repo_init()` – Creates a new repository if none exists
- `repo_add_all()` – Stages every file under the memory directory
- `repo_commit(message)` – Writes a commit with a timestamped message
- `repo_diff(old_rev, new_rev)` – Returns a textual diff between revisions

### Memory Serialization Pipeline

Before Git can version the memory graph, it must be serialized to disk. The [`src/openhuman/memory/serialization.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/serialization.rs) module handles conversion of the internal graph structure into JSON and Markdown formats. This serialization layer is reused by both the wiki exporter and the checkpoint writer, ensuring consistent on-disk representation across backup and checkpointing workflows.

### Feature Gates and Fallback Behavior

All code paths that touch Git are guarded by `#[cfg(feature = "memory-git")]` conditional compilation flags. When the feature is disabled, the system falls back to the in-process **Tinymemory** engine without Git interaction, as implemented in [`src/openhuman/memory/binding.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/binding.rs). This design ensures that binary size is minimized for deployments that do not require version-controlled memory.

## Configuration and System Integration

The `memory-git` feature exposes runtime configuration through the core schema in [`src/openhuman/config/schema/memory.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/config/schema/memory.rs). Key settings include `git.enabled`, `git.auto_checkpoint_interval`, and `git.wiki.remote_url`, which control activation, checkpoint frequency, and remote backup destinations respectively.

### Agent Tool Interface

The system exposes checkpointing directly to AI agents through the `memory_git_checkpoint` tool. Defined in [`src/openhuman/tools/impl/memory/git_checkpoint.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/tools/impl/memory/git_checkpoint.rs), this tool allows an LLM to request explicit snapshots of the current memory state during conversation turns.

### Remote Synchronization and Security

The composio sync service in `src/openhuman/memory/sync/composio/` can be configured to push memory commits to remote Git servers, enabling multi-device synchronization. For security-critical deployments, Git commits can be signed with GPG keys if provided, and all commit metadata is logged by the core audit subsystem in [`src/openhuman/security/audit.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/security/audit.rs), guaranteeing non-repudiation of knowledge edits.

## Practical Code Examples

The following examples demonstrate how to interact with the `memory-git` system programmatically.

Creating a manual checkpoint after a conversational turn:

```rust
use openhuman::memory::checkpoint::Checkpoint;

let mem = core.memory();                // Get the memory instance
let ckpt = Checkpoint::new(&mem);
ckpt.save("Turn 42 checkpoint")?;      // Writes a Git commit

```

Exporting the entire memory graph as a Markdown wiki and pushing to a remote:

```rust
use openhuman::memory::wiki::export_wiki;

let repo_path = "/home/user/.openhuman/memory.git";
export_wiki(repo_path, "https://git.example.com/user/memory.wiki.git")?;

```

Computing a diff between the current and previous checkpoint:

```rust
use openhuman::memory::diff::DiffEngine;

let diff = DiffEngine::new(&mem)?;
let patch = diff.between("HEAD~1", "HEAD")?;
println!("{}", patch);                 // Human‑readable patch

```

## Summary

- The `memory-git` feature enables Git-based versioning of OpenHuman's memory graph through the `git2` crate, activated via the `memory-git` Cargo feature flag.
- **Wiki backups** are generated in `src/openhuman/memory/wiki` as Markdown files that can be pushed to remote repositories for human-readable, editable archives.
- **Checkpoints** in [`src/openhuman/memory/checkpoint.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/checkpoint.rs) create immutable Git commits at configurable intervals, allowing full rollback capabilities via `Checkpoint::save`.
- **Diffs** produced by [`src/openhuman/memory/diff.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/diff.rs) provide textual patches between memory states for auditing and change tracking.
- The architecture uses `#[cfg(feature = "memory-git")]` guards to fall back to the **Tinymemory** engine when the feature is disabled, ensuring minimal binary overhead.
- Configuration is managed through [`src/openhuman/config/schema/memory.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/config/schema/memory.rs) with settings for auto-checkpoint intervals and remote URLs.
- The system supports agent-triggered checkpoints via `memory_git_checkpoint` and integrates with security auditing in [`src/openhuman/security/audit.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/security/audit.rs).

## Frequently Asked Questions

### How do I enable the memory-git feature in OpenHuman?

Enable the feature by compiling OpenHuman with the `memory-git` Cargo flag. In your build command or [`Cargo.toml`](https://github.com/tinyhumansai/openhuman/blob/main/Cargo.toml), include `--features memory-git`. When enabled, the system links the **git2** crate and initializes a repository at `.openhuman/memory.git`; when disabled, it falls back to the in-process **Tinymemory** engine without Git dependencies.

### What file formats does the wiki backup use?

The wiki backup serializes the memory graph into Markdown files using the serialization logic in [`src/openhuman/memory/serialization.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/serialization.rs). This produces a human-readable directory structure that can be browsed, edited in standard text editors, and synchronized to remote Git repositories as a Git-compatible wiki.

### Can AI agents trigger checkpoints manually?

Yes. The `memory_git_checkpoint` tool in [`src/openhuman/tools/impl/memory/git_checkpoint.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/tools/impl/memory/git_checkpoint.rs) exposes checkpoint functionality to the agent runtime. An LLM can invoke this tool during conversation to request an immediate snapshot of the current memory state, which executes `Checkpoint::save` and creates a Git commit with a custom message.

### How does OpenHuman secure the Git repository for sensitive data?

OpenHuman supports GPG signing of commits when users provide a GPG key in the configuration. Additionally, the core audit subsystem in [`src/openhuman/security/audit.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/security/audit.rs) logs all commit metadata, ensuring non-repudiation and providing an immutable record of when knowledge was modified and by which process or agent tool.