# How OpenHuman Syncs Memory to an Obsidian Wiki Vault via Git Mirror

> Learn how OpenHuman syncs memory to your Obsidian vault. It converts updates to Markdown and pushes to a Git mirror for seamless integration.

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

---

**OpenHuman synchronizes its SQLite memory store to an Obsidian-compatible Git repository by converting each memory update into Markdown files under a `docs/` folder, then automatically committing and pushing those changes to a configured remote that serves as the Obsidian vault root.**

OpenHuman implements a bidirectional bridge between its internal AI memory system and external knowledge management tools through a Git-based mirroring system. According to the **tinyhumansai/openhuman** source code, this feature transforms the application's SQLite-backed conversation memory into version-controlled Markdown files that Obsidian can render as a native wiki vault.

## The Git-Backed Memory Architecture

OpenHuman stores user memory—including notes, conversation metadata, and structured knowledge like people and tasks—in a local **SQLite database**. When the **Git-backed memory** feature (also referenced as `memory-git` or the broader `gitbooks` integration) is enabled, the application mirrors this database to a Git repository working tree.

The synchronization creates a **first-class, version-controlled Markdown** representation of the memory. Obsidian opens this folder as a **Vault**, treating the Git working tree as its root directory. Because the folder is a standard Git repository, Obsidian instantly displays any new or updated files that OpenHuman commits, and users can pull external changes back into the local vault.

## Configuration and Setup

### Enabling the Git Mirror

Enable the feature by setting `memory.git.enabled = true` or activating the broader `gitbooks` integration in [`.openhuman/config.toml`](https://github.com/tinyhumansai/openhuman/blob/main/.openhuman/config.toml). The configuration schema in [`src/openhuman/config/schema/memory.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/config/schema/memory.rs) defines the remote URL, branch target, and commit message templates.

```toml

# .openhuman/config.toml

[gitbooks]
enabled = true                
repo = "git@github.com:me/openhuman-vault.git"
branch = "main"
commit_message = "OpenHuman memory sync"

```

When `enabled = true`, OpenHuman initializes the memory-to-Git pipeline on startup. The system stores the remote repository URL and authentication credentials according to the schema defined in the memory configuration module.

### Configuring the Obsidian Vault

Point Obsidian at the same local folder that OpenHuman uses as its Git working tree:

1. Clone the remote repository that OpenHuman pushes to (e.g., `git clone git@github.com:me/openhuman-vault.git ~/obsidian-vault`).
2. In Obsidian, select **Open folder** and choose `~/obsidian-vault`.
3. Obsidian automatically indexes all `*.md` files that OpenHuman generates under the `docs/` subdirectory.

The [`gitbooks/guides/connect-obsidian.md`](https://github.com/tinyhumansai/openhuman/blob/main/gitbooks/guides/connect-obsidian.md) file in the repository provides the official user-facing guide for this connection process.

## The Synchronization Pipeline

The sync process runs automatically after each conversation turn or can be triggered manually via the API. The pipeline involves three core components: the diff engine, the Git orchestrator, and the Markdown serializer.

### Diff Engine and Markdown Generation

The [`src/openhuman/memory/diff.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/diff.rs) module implements the **diff engine** that detects changes between the current SQLite store and the previous Git-mirrored state. When changes are detected, the engine serializes modified entries as Markdown files.

Specifically, the diff logic:
- Compares the current memory state against the last committed snapshot.
- Writes changed notes as Markdown files to the `docs/` folder within the repository.
- Generates structured filenames (e.g., [`docs/notes/2024-03-15-meeting.md`](https://github.com/tinyhumansai/openhuman/blob/main/docs/notes/2024-03-15-meeting.md)) that Obsidian recognizes as wiki links.

### Git Operations and Remote Sync

The [`src/openhuman/gitbooks/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/gitbooks/mod.rs) module provides the higher-level **GitBooks** service that coordinates the synchronization. This service exposes the `sync_memory()` method, which:
- Invokes the diff engine to generate file updates.
- Stages all modified Markdown files using Git commands.
- Executes `git commit` with the configured message template.
- Pushes the commit to the configured remote branch.

This process ensures that the Obsidian vault remains up-to-date with the AI's internal memory state without manual file exports.

## Programmatic Access

Developers can force a memory synchronization programmatically using the `GitbooksService` API. This is useful for scripting custom backup schedules or integrating OpenHuman into larger automation workflows.

```rust
use openhuman::gitbooks::GitbooksService;
use openhuman::core::CoreBuilder;
use openhuman::core::Access;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let core = CoreBuilder::new()
        .access(Access::full())
        .build()
        .await?;

    // Force a full memory sync – this is what the background task does after each turn.
    let gitbooks = GitbooksService::from_core(&core);
    gitbooks.sync_memory().await?;
    Ok(())
}

```

The `GitbooksService::from_core()` constructor initializes the service with access to the core memory stores, while `sync_memory().await` executes the full diff-and-push pipeline synchronously.

## Summary

- **OpenHuman** stores internal memory in SQLite, but can mirror this to a Git repository via the `gitbooks` feature.
- The **[`src/openhuman/memory/diff.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/memory/diff.rs)** engine converts database changes into Markdown files under a `docs/` folder.
- The **[`src/openhuman/gitbooks/mod.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/gitbooks/mod.rs)** service orchestrates Git commands, automatically committing and pushing updates to a remote.
- **Obsidian** opens the same Git working tree as a Vault, displaying the AI-generated Markdown as editable wiki notes.
- Configuration is managed through [`.openhuman/config.toml`](https://github.com/tinyhumansai/openhuman/blob/main/.openhuman/config.toml) using the schema defined in [`src/openhuman/config/schema/memory.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/config/schema/memory.rs).

## Frequently Asked Questions

### How do I enable Git-backed memory in OpenHuman?

Set `enabled = true` in the `[gitbooks]` section of [`.openhuman/config.toml`](https://github.com/tinyhumansai/openhuman/blob/main/.openhuman/config.toml) and specify a valid Git remote URL in the `repo` field. The feature activates on the next application start, creating the initial commit if the repository is empty.

### What folder structure does OpenHuman create for Obsidian?

OpenHuman writes Markdown files to a `docs/` subdirectory within the Git working tree. Each note receives a structured filename (typically including dates or UUIDs) that appears instantly in Obsidian's file explorer when committed.

### Can I use Obsidian to edit notes that sync back to OpenHuman?

Yes. Because the folder is a standard Git working tree, any edits made in Obsidian can be committed and pushed back to the remote. When OpenHuman runs `git pull` on the same repository, it can ingest those changes, though the sync is primarily designed as a one-way export from the SQLite store to Markdown.

### Where is the Git remote configuration stored?

The remote URL, branch name, and commit message templates are defined in the configuration schema located at [`src/openhuman/config/schema/memory.rs`](https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/config/schema/memory.rs) and persisted in the user's [`.openhuman/config.toml`](https://github.com/tinyhumansai/openhuman/blob/main/.openhuman/config.toml) file under the `[gitbooks]` table.