OpenHuman

https://tinyhumans.gitbook.io/openhuman
Admin
OpenHuman is an open-source personal AI assistant for your desktop that connects to 118+ services,...
Tokens:65,349
Snippets:1,028
Trust Score:9.8
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install Headless Binary

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Download and install the appropriate architecture-specific binary from GitHub Releases.

```bash
# Pick the tarball that matches your host arch.
ARCH="$(uname -m)"
case "$ARCH" in
  x86_64)  TARGET=x86_64-unknown-linux-gnu  ;;
  aarch64) TARGET=aarch64-unknown-linux-gnu ;;
  *) echo "Unsupported arch: $ARCH"; exit 1 ;;
esac
VERSION=1.2.4   # set to the release you want
curl -fsSL "https://github.com/tinyhumansai/openhuman/releases/download/v${VERSION}/openhuman-core-${VERSION}-${TARGET}.tar.gz" \
  | tar -xz -C /usr/local/bin
openhuman-core --version
```

--------------------------------

### Preview installation script actions

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Run the installation script in dry-run mode to preview actions without modifying files.

```bash
# Preview actions without writing files
curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash -s -- --dry-run
```

--------------------------------

### Install macOS prerequisites

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Install Xcode Command Line Tools to provide the necessary SDK headers for native compilation.

```bash
xcode-select --install
```

--------------------------------

### Install ARM Linux Prerequisites

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Installs xvfb to support headless builds and testing on ARM Linux.

```bash
sudo apt install xvfb
```

--------------------------------

### Install OpenHuman on Windows

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Uses PowerShell to download and execute the latest stable installer script.

```powershell
irm https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.ps1 | iex
```

--------------------------------

### Install Prerequisites on Arch Linux

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Use pacman to install system dependencies, Node.js, pnpm, and the Rust toolchain.

```bash
sudo pacman -S --needed nodejs npm rustup cmake base-devel clang openssl \
  alsa-lib xdotool libxtst libxi libevdev gtk3 webkit2gtk-4.1 \
  libayatana-appindicator librsvg patchelf nss nspr at-spi2-core \
  libcups libdrm libxkbcommon libxcomposite libxdamage libxfixes \
  libxrandr mesa pango cairo libxshmfence
npm install -g pnpm@10.10.0
rustup toolchain install 1.93.0 --profile minimal
rustup component add rustfmt clippy --toolchain 1.93.0
```

--------------------------------

### Install Prerequisites on macOS

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Use Homebrew to install the required Node.js, pnpm, and Rust toolchain versions.

```bash
brew install node@24 pnpm rustup-init cmake
rustup toolchain install 1.93.0 --profile minimal
rustup component add rustfmt clippy --toolchain 1.93.0
```

--------------------------------

### Install and start AgentMemory

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/agentmemory-backend.md

Run this command in a terminal to start the AgentMemory service. It defaults to REST port 3111 and WebSocket port 49134.

```bash
npx -y @agentmemory/agentmemory
```

--------------------------------

### Start Remote Core and Local UI

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Configure the core host and port, generate an authentication token, and launch the UI development server.

```bash
# On the server, run the core with an explicit token.
export OPENHUMAN_CORE_HOST=0.0.0.0
export OPENHUMAN_CORE_PORT=7788
export OPENHUMAN_CORE_TOKEN="$(openssl rand -hex 32)"
openhuman-core serve

# In another shell on the server, serve the UI only on loopback.
pnpm --dir app dev -- --host 127.0.0.1 --port 1420
```

--------------------------------

### Install Linux desktop/Tauri dependencies

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Install these broader dependency sets when building the desktop shell instead of the core-only crate.

```bash
sudo apt-get update
sudo apt-get install -y \
  libgtk-3-dev libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev \
  patchelf cmake libasound2-dev libxdo-dev libxtst-dev libx11-dev libxi-dev \
  libevdev-dev libssl-dev libclang-dev \
  libnss3 libnspr4 libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 \
  libxkbcommon0 libxcomposite1 libxdamage1 libxfixes3 libxrandr2 \
  libgbm1 libpango-1.0-0 libcairo2 libatspi2.0-0 libxshmfence1 libu2f-udev
```

```bash
sudo pacman -S --needed gtk3 webkit2gtk-4.1 libayatana-appindicator \
  librsvg patchelf nss nspr at-spi2-core libcups libdrm \
  libxkbcommon libxcomposite libxdamage libxfixes libxrandr \
  mesa pango cairo libxshmfence
```

--------------------------------

### Install Linux core-only dependencies

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Install these system packages on a fresh Linux machine before running cargo build.

```bash
sudo apt-get update
sudo apt-get install -y \
  build-essential cmake pkg-config clang libssl-dev libclang-dev \
  libasound2-dev libxi-dev libxtst-dev libxdo-dev libudev-dev \
  libstdc++-14-dev
```

```bash
sudo pacman -S --needed base-devel cmake pkgconf clang openssl \
  alsa-lib libxi libxtst xdotool libevdev
```

--------------------------------

### Initialize D-Bus for WebKit

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Start the D-Bus session required by webkit2gtk.

```bash
eval $(dbus-launch --sh-syntax)
```

--------------------------------

### Install Rust toolchain and build core

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Configures the required Rust toolchain version, adds the MSVC target, and builds the core binary.

```powershell
rustup toolchain install 1.93.0 --component rustfmt --component clippy
rustup target add x86_64-pc-windows-msvc
cargo build --manifest-path Cargo.toml --bin openhuman-core
```

--------------------------------

### Run local development environment

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Commands to start the web-only UI or the desktop application development environment.

```bash
# Web-only UI development
pnpm dev

# Desktop app development with the vendored Tauri/CEF CLI: run from the workspace root
pnpm --filter openhuman-app dev:app
```

--------------------------------

### Deploy with Docker Compose

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Standard workflow for cloning the repository, configuring environment variables, and starting the service.

```bash
# On the server:
git clone https://github.com/tinyhumansai/openhuman.git
cd openhuman

# Configure secrets:
cp .env.example .env
# Edit .env - at minimum:
#   BACKEND_URL=https://api.tinyhumans.ai
#   OPENHUMAN_CORE_TOKEN=<openssl rand -hex 32>
#   OPENHUMAN_APP_ENV=production

# Build and start:
docker compose up -d

# Verify:
docker compose ps
curl -fsS http://localhost:7788/health
```

--------------------------------

### Install Appium Chromium Driver

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Install the required Appium version and the Chromium driver for Linux testing.

```bash
npm install -g appium@3
appium driver install --source=npm appium-chromium-driver
```

--------------------------------

### Build OpenHuman from source

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Commands to clone the repository, initialize submodules, install dependencies, and build the desktop application.

```bash
# 1) Clone and enter the repo
git clone https://github.com/tinyhumansai/openhuman.git
cd openhuman

# 2) Fetch vendored Tauri/CEF sources
git submodule update --init --recursive

# 3) Install JS deps (workspace)
pnpm install

# 4) Build desktop app artifacts
pnpm build
```

--------------------------------

### Install ARM Linux DEB Package

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Locates and installs the generated ARM64 DEB package.

```bash
DEB_FILE=$(ls app/src-tauri/target/aarch64-unknown-linux-gnu/release/bundle/deb/OpenHuman_*_arm64.deb | head -n1)
sudo dpkg -i "$DEB_FILE"
```

--------------------------------

### Build and install Arch Linux package

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Commands to build the AUR package locally or install it via yay after publication.

```bash
cd packages/arch/openhuman-bin
makepkg --syncdeps --install
```

```bash
yay -S openhuman-bin
```

--------------------------------

### Install the pinned Rust toolchain

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Installs the specific Rust version and components required by the project as defined in rust-toolchain.toml.

```bash
rustup toolchain install 1.93.0 --component rustfmt --component clippy
rustup default 1.93.0
```

--------------------------------

### Query documentation via HTTP GET

Source: https://tinyhumans.gitbook.io/openhuman/llms.txt

Perform a GET request to the documentation index using the ask and goal parameters to receive a tailored answer.

```http
GET https://tinyhumans.gitbook.io/openhuman/legal/terms-of-use.md?ask=<question>&goal=<end_goal>
```

--------------------------------

### Configure Linux Display for E2E

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Set the display environment variable and start Xvfb to support WebView testing on Linux.

```bash
export DISPLAY=:99
Xvfb :99 -screen 0 1280x1024x24 &
```

--------------------------------

### Run E2E tests on Linux

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Commands to install dependencies, build the application, and execute test suites on Linux environments.

```bash
# Install Appium and the Chromium driver (one-time)
npm install -g appium@3
appium driver install --source=npm appium-chromium-driver

# Build the E2E app
pnpm --filter openhuman-app test:e2e:build

# Run all flows
pnpm --filter openhuman-app test:e2e:all:flows

# Run a single spec
bash app/scripts/e2e-run-spec.sh test/e2e/specs/smoke.spec.ts smoke
```

--------------------------------

### Install stable release via script

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Primary command to install the latest stable OpenHuman release on macOS or Linux x64.

```bash
curl -fsSL https://raw.githubusercontent.com/tinyhumansai/openhuman/main/scripts/install.sh | bash
```

--------------------------------

### GET /agentmemory/projects

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/agentmemory-backend.md

Retrieves summaries for all memory projects.

```APIDOC
## GET /agentmemory/projects

### Description
Returns a list of project summaries including name, memory count, and last updated timestamp.

### Method
GET

### Endpoint
/agentmemory/projects
```

--------------------------------

### Run E2E tests on macOS

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Commands to install dependencies and execute test suites on macOS, requiring Node 24+.

```bash
# Install Appium + Chromium driver (one-time, needs Node 24+)
npm install -g appium@3
appium driver install --source=npm appium-chromium-driver

# Build the .app bundle
pnpm --filter openhuman-app test:e2e:build

# Run all flows
pnpm --filter openhuman-app test:e2e:all:flows
```

--------------------------------

### Configure agent model pins

Source: https://tinyhumans.gitbook.io/openhuman/features/model-routing.md

Examples of overriding model routing via inline JSON calls or persistent TOML configuration.

```json
{
  "agent_id": "researcher",
  "model": "anthropic/claude-sonnet-4",
  "prompt": "Collect source notes for the launch memo."
}
```

```toml
[orchestrator]
model = "anthropic/claude-sonnet-4"

[teams.research]
lead_model = "openai/gpt-5.1"
agent_model = "groq/llama-3.1-8b-instant"

[teams.code]
agent_model = "qwen/qwen3-coder"
```

--------------------------------

### GET /agentmemory/livez

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/agentmemory-backend.md

Liveness probe for the service.

```APIDOC
## GET /agentmemory/livez

### Description
Standard liveness check endpoint.

### Method
GET

### Endpoint
/agentmemory/livez
```

--------------------------------

### GET /documentation-index

Source: https://tinyhumans.gitbook.io/openhuman/llms.txt

Perform a natural language query against the documentation index to receive a direct answer and relevant source excerpts.

```APIDOC
## GET https://tinyhumans.gitbook.io/openhuman/legal/terms-of-use.md

### Description
Perform an HTTP GET request on the documentation index to ask a specific question and optionally provide a broader goal for context.

### Method
GET

### Endpoint
https://tinyhumans.gitbook.io/openhuman/legal/terms-of-use.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question to ask, written in natural language.
- **goal** (string) - Optional - Describes the broader end goal to tailor the answer.

### Request Headers
- **Accept** (string) - Optional - Use 'text/markdown' for content negotiation.
```

--------------------------------

### GET /agentmemory/memories

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/agentmemory-backend.md

Lists memories for a specific project.

```APIDOC
## GET /agentmemory/memories

### Description
Retrieves a list of memories filtered by project.

### Method
GET

### Endpoint
/agentmemory/memories

### Parameters
#### Query Parameters
- **latest** (boolean) - Optional - If true, returns the latest memories
- **project** (string) - Required - The namespace/project identifier
```

--------------------------------

### GET /agentmemory/health

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/agentmemory-backend.md

Checks the health and memory count of the service.

```APIDOC
## GET /agentmemory/health

### Description
Returns the current health status and total memory count.

### Method
GET

### Endpoint
/agentmemory/health
```

--------------------------------

### Launch Fly.io application

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Initializes the Fly.io configuration using the provided template without deploying immediately.

```bash
fly launch --no-deploy --config .fly/fly.toml
```

--------------------------------

### Configure desktop application

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Updates the local environment file to point the desktop client to the hosted core instance.

```bash
OPENHUMAN_CORE_RUN_MODE=external
OPENHUMAN_CORE_RPC_URL=https://<your-app-name>.fly.dev/rpc
OPENHUMAN_CORE_TOKEN=<the token you set in Step 4>
```

--------------------------------

### Deploy and Manage Apps via doctl

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Commands for initializing authentication, creating an application from a specification file, and monitoring deployment logs.

```bash
# One-time: install doctl and authenticate.
doctl auth init

# Edit .do/app.yaml - set OPENHUMAN_CORE_TOKEN to a real value (or pass it in
# at create time via --spec with envsubst). Then:
doctl apps create --spec .do/app.yaml

# Watch the build:
doctl apps list
doctl apps logs <app-id> --type build --follow
```

```bash
doctl apps update <app-id> --spec .do/app.yaml
```

--------------------------------

### Deploy Application Manually

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Deploys the application using the specified configuration file.

```bash
fly deploy --config .fly/fly.toml
```

--------------------------------

### Configure desktop app for remote core

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Environment settings for connecting the desktop application to a hosted or private network core instance.

```bash
# Use the hosted core instead of spawning a local sidecar.
OPENHUMAN_CORE_RUN_MODE=external
OPENHUMAN_CORE_RPC_URL=https://core.example.com/rpc
OPENHUMAN_CORE_TOKEN=<the same token you set on the server>
```

```bash
OPENHUMAN_CORE_RUN_MODE=external
OPENHUMAN_CORE_RPC_URL=http://100.x.x.x:7788/rpc
OPENHUMAN_CORE_TOKEN=<the same token you set on the server>
```

--------------------------------

### Configure SearXNG via Environment Variables

Source: https://tinyhumans.gitbook.io/openhuman/features/native-tools/web-search.md

Alternative configuration method for enabling and setting up SearXNG using environment variables.

```bash
OPENHUMAN_SEARXNG_ENABLED=true
OPENHUMAN_SEARXNG_BASE_URL=http://localhost:8080
OPENHUMAN_SEARXNG_MAX_RESULTS=10
OPENHUMAN_SEARXNG_DEFAULT_LANGUAGE=en
OPENHUMAN_SEARXNG_TIMEOUT_SECONDS=10
```

--------------------------------

### Build and test the Rust core

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Use these commands from the repository root to check, build, or test the openhuman-core binary.

```bash
# Fast dependency + type check
cargo check --manifest-path Cargo.toml

# Debug build of the actual CLI / RPC binary
cargo build --manifest-path Cargo.toml --bin openhuman-core

# Release build
cargo build --manifest-path Cargo.toml --release --bin openhuman-core

# Rust tests
cargo test --manifest-path Cargo.toml
```

--------------------------------

### Run ARM Linux Binary

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Configures the environment to include necessary CEF libraries before launching the binary.

```bash
REL_DIR=app/src-tauri/target/aarch64-unknown-linux-gnu/release
CEF_DIR=$(ls -d "$REL_DIR"/build/cef-dll-sys-*/out/cef_linux_aarch64 2>/dev/null | head -n1)
export LD_LIBRARY_PATH="$CEF_DIR:$REL_DIR/deps:$REL_DIR${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
"$REL_DIR/OpenHuman" --no-sandbox
```

```bash
#!/bin/bash
REL_DIR=/path/to/app/src-tauri/target/aarch64-unknown-linux-gnu/release
CEF_DIR=$(ls -d "$REL_DIR"/build/cef-dll-sys-*/out/cef_linux_aarch64 2>/dev/null | head -n1)
export LD_LIBRARY_PATH="$CEF_DIR:$REL_DIR/deps:$REL_DIR${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
exec "$REL_DIR/OpenHuman" --no-sandbox "$@"
```

--------------------------------

### Clone the repository for core development

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Downloads the repository and navigates to the root directory for core-only work.

```bash
git clone https://github.com/tinyhumansai/openhuman.git
cd openhuman
```

--------------------------------

### Run Core and Frontend Separately

Source: https://tinyhumans.gitbook.io/openhuman/developing/cef.md

Use these commands to bypass native window configuration issues by running the core and frontend in separate terminals.

```bash
cargo build --bin openhuman-core
./target/debug/openhuman-core run --port 7788
```

```bash
cd app
pnpm dev
```

--------------------------------

### Deploy and verify application

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Deploys the application to Fly.io and verifies the health endpoint.

```bash
fly deploy --config .fly/fly.toml
```

```bash
curl -fsS https://<your-app-name>.fly.dev/health
```

--------------------------------

### Systemd Service Configuration

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Recommended settings for managing the OpenHuman process via systemd.

```ini
Restart=always
ExecReload=/bin/kill -HUP $MAINPID
```

--------------------------------

### Initialize Desktop Deep Link Listener

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Sets up the deep link listener in the main entry point to handle custom protocol URLs before the router initializes.

```typescript
// main.tsx
import("./utils/desktopDeepLinkListener").then((m) => {
  m.setupDesktopDeepLinkListener().catch(console.error);
});
```

--------------------------------

### Retrieve Application Logs

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Fetches logs for the application instance defined in the configuration.

```bash
fly logs --config .fly/fly.toml
```

--------------------------------

### Frontend directory structure

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Visual representation of the project's directory layout under app/src/.

```text
app/src/
├── App.tsx                 # Provider chain + HashRouter shell (desktop + mobile shells)
├── AppRoutes.tsx           # Desktop route table (AppRoutesIOS.tsx for mobile)
├── main.tsx                # Entry (polyfills, Sentry, store, styles)
├── store/                  # Redux slices, selectors, userScopedStorage persistence
├── providers/              # ThemeProvider, CoreStateProvider, SocketProvider, ChatRuntimeProvider
├── services/               # apiClient, socketService, coreRpcClient, transport/, api/* (~50 modules)
├── lib/                    # AI prompt loaders, i18n, MCP helpers, platform, tunnel crypto
├── pages/                  # Route-level screens (incl. onboarding/, ios/, dev/)
├── features/               # Feature verticals (human/, conversations/, meet/, voice/)
├── components/             # Shared UI (incl. settings/, layout/shell/, accounts/)
├── agentworld/             # tiny.place Agent World surface (/agent-world/*)
├── hooks/                  # App hooks
├── utils/                  # Config, Tauri command wrappers, routing utilities
└── assets/                 # Icons and static assets
```

--------------------------------

### Configure Update Strategy

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Set the restart strategy for headless deployments to ensure compatibility with external service managers.

```toml
[update]
restart_strategy = "supervisor"
rpc_mutations_enabled = false
```

```bash
OPENHUMAN_AUTO_UPDATE_RESTART_STRATEGY=supervisor
OPENHUMAN_AUTO_UPDATE_RPC_MUTATIONS_ENABLED=false
```

--------------------------------

### Configure SearXNG in config.toml

Source: https://tinyhumans.gitbook.io/openhuman/features/native-tools/web-search.md

Enable and configure the self-hosted SearXNG search tool using the project's TOML configuration file.

```toml
[searxng]
enabled = true
base_url = "http://localhost:8080"
max_results = 10
default_language = "en"
timeout_seconds = 10
```

--------------------------------

### View Container Logs

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Follow the output logs for the OpenHuman container.

```bash
docker compose logs -f openhuman-core
```

--------------------------------

### Configure Workload Providers

Source: https://tinyhumans.gitbook.io/openhuman/features/model-routing/local-ai.md

Set specific provider strings for chat and reasoning workloads to route them to local Ollama instances.

```toml
chat_provider = "ollama:llama3.1:8b"
reasoning_provider = "ollama:qwen2.5:14b"
```

--------------------------------

### memory.tool_rules_for_prompt

Source: https://tinyhumans.gitbook.io/openhuman/features/native-tools/tool-memory.md

Returns the rendered Markdown block and structured snapshot for the session builder.

```APIDOC
## memory.tool_rules_for_prompt

### Description
Generates the rendered Markdown block and structured snapshot used by the session builder to pin rules into the system prompt.
```

--------------------------------

### Verify backend reachability

Source: https://tinyhumans.gitbook.io/openhuman/overview/troubleshooting-sign-in.md

Use these commands to confirm the desktop app can communicate with public OpenHuman endpoints.

```bash
curl -I https://tinyhumans.ai/
curl -I https://api.tinyhumans.ai/health
```

--------------------------------

### Execute Android Release Commands

Source: https://tinyhumans.gitbook.io/openhuman/developing/release-policy.md

Commands to trigger manual Android releases to Google Play using pnpm.

```bash
pnpm --dir app release:android:play -- --track internal
pnpm --dir app release:android:play -- --ref main --track production --status draft
```

--------------------------------

### Run E2E tests via Docker

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Commands to execute the Linux-based test harness from macOS using Docker Compose.

```bash
# Build + run all E2E flows
docker compose -f e2e/docker-compose.yml run --rm e2e

# Build the app first (if needed)
docker compose -f e2e/docker-compose.yml run --rm e2e \
  pnpm --filter openhuman-app test:e2e:build

# Run a single spec
docker compose -f e2e/docker-compose.yml run --rm e2e \
  bash app/scripts/e2e-run-spec.sh test/e2e/specs/smoke.spec.ts smoke
```

--------------------------------

### Run local smoke tests for cloud deployment

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Executes build and runtime verification for both the token-based App Platform path and the fresh-volume Docker Compose path.

```bash
docker build -t openhuman-core:smoke .

# Optional: tune build profile and Cargo parallelism.
# Keep CARGO_BUILD_JOBS=1 on constrained builders; raise it on larger machines.
docker build --build-arg CARGO_PROFILE=release --build-arg CARGO_BUILD_JOBS=4 -t openhuman-core:release .

# Token-set path (App Platform):
docker run -d --name oh-smoke -p 7788:7788 \
  -e OPENHUMAN_CORE_TOKEN=smoke-test-token \
  openhuman-core:smoke
curl -fsS http://localhost:7788/health
docker rm -f oh-smoke

# Fresh-volume / no-token path (Docker Compose, VPS):
docker volume create oh-vol-test
docker run -d --name oh-vol-smoke -p 7789:7788 \
  -v oh-vol-test:/home/openhuman/.openhuman \
  openhuman-core:smoke
curl -fsS http://localhost:7789/health
docker rm -f oh-vol-smoke
docker volume rm oh-vol-test
```

--------------------------------

### Run OpenHuman Container

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Execute a standalone container with required environment variables and volume persistence.

```bash
docker run -d --name openhuman-core -p 7788:7788 \
  -e OPENHUMAN_CORE_TOKEN="$(openssl rand -hex 32)" \
  -e BACKEND_URL=https://api.tinyhumans.ai \
  -e OPENHUMAN_APP_ENV=production \
  -v openhuman-workspace:/home/openhuman/.openhuman \
  ghcr.io/tinyhumansai/openhuman-core:latest
```

--------------------------------

### Run the theme migration codemod

Source: https://tinyhumans.gitbook.io/openhuman/developing/theming.md

Use these commands to identify, apply, or test migrations for legacy Tailwind utility pairings.

```bash
node scripts/theme-codemod/migrate.mjs            # dry-run + report
node scripts/theme-codemod/migrate.mjs --write    # apply
node scripts/theme-codemod/migrate.mjs --selftest # fixture assertions
```

--------------------------------

### Configure Fly.io application settings

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Defines the application environment, persistent storage mounts, and HTTP service health checks in the TOML configuration file.

```toml
app = '<your-app-name>'
primary_region = '<your-region>'

[build]
  dockerfile = "Dockerfile"

[env]
  OPENHUMAN_CORE_HOST = "0.0.0.0"
  OPENHUMAN_CORE_PORT = "7788"
  OPENHUMAN_WORKSPACE = "/home/openhuman/.openhuman"
  RUST_LOG = "info"

[[mounts]]
  source = "openhuman_workspace"
  destination = "/home/openhuman/.openhuman"

[http_service]
  internal_port = 7788
  force_https = true
  auto_stop_machines = 'stop'
  auto_start_machines = true
  # min_machines_running = 0 fully stops the machine when idle (cheapest), but
  # the first request after idle pays a cold-start penalty (container boot +
  # Rust binary init — several seconds). Set to 1 to keep one machine warm.
  min_machines_running = 0
  processes = ['app']

  [[http_service.checks]]
    interval = "30s"
    timeout = "5s"
    grace_period = "10s"
    method = "GET"
    path = "/health"

[[vm]]
  memory = '1gb'
  cpus = 1
```

--------------------------------

### Manually pull local models

Source: https://tinyhumans.gitbook.io/openhuman/guides/guides/local-model.md

Use these commands to pre-download the required models for chat and embeddings if not handled automatically by the application.

```bash
ollama pull gemma3:1b-it-qat
ollama pull bge-m3
```

--------------------------------

### Back-compatibility Redirects

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Legacy route mappings that use Navigate replace to maintain query parameters.

```text
/home        → /chat                     /skills      → /connections
/activity    → /settings/notifications   /channels    → /connections?tab=messaging
/intelligence→ /settings/notifications   /routines    → /settings/automations
/workflows   → /settings/automations     /webhooks    → /settings/integrations#webhooks
/brain/tinyplace-orchestration → /orchestration
```

--------------------------------

### Manually register Windows URL scheme

Source: https://tinyhumans.gitbook.io/openhuman/overview/troubleshooting-sign-in.md

Run this PowerShell script to manually register the openhuman:// protocol handler if automatic registration fails.

```powershell
$exe = 'C:\Path\To\OpenHuman.exe'   # update this
New-Item -Path 'HKCU:\Software\Classes\openhuman' -Force | Out-Null
Set-ItemProperty -Path 'HKCU:\Software\Classes\openhuman' -Name '(Default)' -Value 'URL:OpenHuman Protocol'
New-ItemProperty -Path 'HKCU:\Software\Classes\openhuman' -Name 'URL Protocol' -Value '' -Force | Out-Null
New-Item -Path 'HKCU:\Software\Classes\openhuman\shell\open\command' -Force | Out-Null
Set-ItemProperty -Path 'HKCU:\Software\Classes\openhuman\shell\open\command' -Name '(Default)' -Value ('"' + $exe + '" "%1"')
```

--------------------------------

### Fix GTK Initialization for ARM

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Ensures GTK is initialized before the system tray is created by adding this snippet to the tauri-runtime-cef library.

```rust
// After CEF initialization, add:
#[cfg(target_os = "linux")]
{
    gtk::init().ok();
}
```

--------------------------------

### cost_get_summary

Source: https://tinyhumans.gitbook.io/openhuman/features/billing-and-usage.md

Retrieves a live summary of session, daily, and monthly costs.

```APIDOC
## RPC Method: cost_get_summary

### Description
Returns a live summary of the current session, daily, and monthly costs.

### Inputs
- None

### Output
- Live session cost (float)
- Daily cost (float)
- Monthly cost (float)
```

--------------------------------

### Run the agent review E2E script

Source: https://tinyhumans.gitbook.io/openhuman/developing/agent-observability.md

Executes the end-to-end agent review process.

```bash
bash app/scripts/e2e-agent-review.sh
```

--------------------------------

### SuperContext Workflow Diagram

Source: https://tinyhumans.gitbook.io/openhuman/features/super-context.md

Visual representation of the deterministic harness gate and context scouting process.

```text
New thread, first message
        │
        ▼
┌──────────────────────────────┐
│  Harness gate (deterministic) │
│  super_context_enabled?       │
└───────────────┬──────────────┘
                │ yes
                ▼
        context_scout (read-only)
        sweeps memory + files + data
                │
                ▼
        [context_bundle] … [/context_bundle]
                │  validated & extracted
                ▼
   Prepended to your message → orchestrator
```

--------------------------------

### Run Rust Inference Provider E2E Tests

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Executes tests using wiremock to simulate HTTP upstreams without requiring live LLM API calls.

```bash
# Local:
bash scripts/test-rust-inference-e2e.sh

# Via Docker (Linux, same image as CI):
docker compose -f e2e/docker-compose.yml run --rm inference-e2e
```

--------------------------------

### Configure GitHub Actions for Continuous Deployment

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Automates deployment to Fly.io on pushes to the main branch. Requires the FLY_API_TOKEN secret to be set in the repository.

```yaml
name: Fly Deploy
on:
  push:
    branches:
      - main
    paths:
      - 'src/**'
      - 'Cargo.toml'
      - 'Cargo.lock'
      - 'Dockerfile'
      - '.fly/fly.toml'
      - 'scripts/docker-entrypoint-core.sh'
jobs:
  deploy:
    name: Deploy openhuman-core
    runs-on: ubuntu-latest
    concurrency: deploy-group
    steps:
      - uses: actions/checkout@v4
      # Pin the Fly action to a tagged release (or a full commit SHA) rather
      # than `@master` — tracking a moving branch trusts every future commit
      # pushed there, including any made by a compromised maintainer account.
      - uses: superfly/flyctl-actions/setup-flyctl@1.5
      - run: flyctl deploy --remote-only --config .fly/fly.toml
        env:
          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}
```

--------------------------------

### Verify remote core connectivity

Source: https://tinyhumans.gitbook.io/openhuman/overview/troubleshooting-sign-in.md

Use this command to ping the remote core and verify the bearer token. A 401 response indicates a token mismatch.

```bash
curl -sS https://your-core.example/rpc \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer CORE_TOKEN" \
  -d '{"jsonrpc":"2.0","id":1,"method":"core.ping","params":{}}'
```

--------------------------------

### Build OpenHuman for ARM Linux

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Compiles the application for the aarch64-unknown-linux-gnu target using pnpm and Tauri.

```bash
cd app
pnpm tauri build --target aarch64-unknown-linux-gnu
```

--------------------------------

### Pre-merge CI Gate Commands

Source: https://tinyhumans.gitbook.io/openhuman/developing/testing-strategy.md

A comprehensive list of commands to run locally before opening a pull request to ensure code quality and functional integrity.

```bash
# Rust core
cargo fmt --check
cargo check --manifest-path Cargo.toml
cargo clippy --manifest-path Cargo.toml -- -D warnings
cargo test --manifest-path Cargo.toml

# Tauri shell
cargo check --manifest-path app/src-tauri/Cargo.toml

# Frontend
pnpm typecheck
pnpm lint
pnpm format:check
pnpm test:unit

# Rust integration with mock backend
pnpm test:rust

# E2E (slow - run when behaviour changes user-visibly)
pnpm test:e2e:build
bash app/scripts/e2e-run-spec.sh test/e2e/specs/<your-spec>.spec.ts <id>
```

--------------------------------

### Memory Diff Output Format

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/memory-diff.md

The tool returns a concise markdown summary detailing added, modified, and removed items.

```markdown
## Memory Changes (Inbox)

**2 added, 1 modified, 0 removed** (47 unchanged)

### Added
- Invoice #4021 from Acme
- Re: Q3 planning

### Modified
- Standup notes
```

--------------------------------

### Obsidian Deep Link Protocol

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki.md

The application uses the obsidian://open protocol to trigger vault opening, requiring the folder to be registered as a vault in Obsidian first.

```text
obsidian://open?path=...
```

--------------------------------

### Create persistent volume

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Provisions a 5GB persistent volume to ensure data persists across application redeployments.

```bash
fly volumes create openhuman_workspace --size 5 --region <your-region> --config .fly/fly.toml
```

--------------------------------

### Configure Caddy reverse proxy

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Minimal configuration to expose the core service behind TLS.

```caddy
core.example.com {
  reverse_proxy localhost:7788
}
```

--------------------------------

### Check Core Token Status

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Use these commands to verify the source and value of the token currently used by the running core process.

```bash
scripts/print-core-token.sh --where     # prints 'env' or 'file:/path'
scripts/print-core-token.sh --redact    # first 8 hex chars + '…' (safe for logs)
scripts/print-core-token.sh             # full value (pipe straight into a client)
```

--------------------------------

### memory.tool_rule_list

Source: https://tinyhumans.gitbook.io/openhuman/features/native-tools/tool-memory.md

Lists all rules associated with a specific tool, sorted by priority and freshness.

```APIDOC
## memory.tool_rule_list

### Description
Returns a list of all rules for a given tool, ordered by priority and freshness.

### Parameters
- **tool_name** (string) - The name of the tool to list rules for.
```

--------------------------------

### Configure OpenHuman for AgentMemory

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/agentmemory-backend.md

Update the config.toml file to point OpenHuman to the AgentMemory backend. Uncomment and modify the optional fields if defaults need to be overridden.

```toml
[memory]
backend = "agentmemory"
# Defaults below — set only when overriding.
# agentmemory_url        = "http://localhost:3111"
# agentmemory_secret     = ""           # HMAC bearer token, optional
# agentmemory_timeout_ms = 5000
```

--------------------------------

### Define build-time configuration constants

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Use these constants for build-time environment variables. Do not use these for runtime API calls; resolve URLs at runtime instead.

```typescript
// Build-time fallback only (used outside Tauri).
export const BACKEND_URL = /* VITE_BACKEND_URL || default */;
// Core RPC build-time fallback.
export const CORE_RPC_URL = /* VITE_OPENHUMAN_CORE_RPC_URL || 'http://127.0.0.1:7788/rpc' */;
// Dev flags, e.g.
export const DEV_FORCE_ONBOARDING = /* dev-only VITE_DEV_FORCE_ONBOARDING */;
```

--------------------------------

### Periodic Sync Scheduler Workflow

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/auto-fetch.md

Visual representation of the periodic synchronization loop, showing the tick interval, connection checks, and state management.

```text
every 20 min
    |
    v
for each active connection (Gmail, Notion, GitHub, ...)
    |
    +--> check sync_state (toolkit, connection_id)
    |       - last sync timestamp
    |       - daily budget
    |       - dedup set
    |       - cursor
    |
    +--> if interval elapsed -> provider.sync()
            |
            +--> on success -> record_sync_success(ts)
```

--------------------------------

### Memory Tree Pipeline Architecture

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki/memory-tree.md

Visual representation of the data flow from source adapters to retrieval, illustrating the deterministic processing stages.

```text
source adapters (chat / email / document)
        |
        v
canonicalize    normalised Markdown + provenance metadata
        |
        v
chunker         deterministic IDs, <=3k-token bounded segments
        |
        v
content_store   atomic .md files on disk (body + tags)
        |
        v
store           persistence (chunks, scores, summaries, jobs)
        |
        v
score           signals + embeddings + entity extraction
        |
        v
source / topic / global trees   per-scope summary trees
        |
        v
retrieval       search / drill_down / topic / global / fetch
```

--------------------------------

### Manually inject session token

Source: https://tinyhumans.gitbook.io/openhuman/overview/troubleshooting-sign-in.md

Use this command to verify if a remote core can accept an authentication session token.

```bash
curl -sS https://your-core.example/rpc \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer CORE_TOKEN" \
  -d '{"jsonrpc":"2.0","id":1,"method":"openhuman.auth_store_session","params":{"token":"JWT_FROM_CALLBACK"} }'
```

--------------------------------

### Resolve backend URL at runtime

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Use these methods to ensure the core's API URL configuration is respected at runtime.

```typescript
// React components
import { useBackendUrl } from "../hooks/useBackendUrl";
const backendUrl = useBackendUrl();

// Non-React code
import { getBackendUrl } from "../services/backendUrl";
const backendUrl = await getBackendUrl();
```

--------------------------------

### Frontend Services Directory Structure

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Conceptual layout of the services directory, highlighting the roles of API clients, URL resolution, and transport mechanisms.

```text
services/
  ├─ apiClient        → REST to a URL resolved at runtime via `services/backendUrl#getBackendUrl`
  ├─ backendUrl       → Calls `openhuman.config_resolve_api_url`; falls back to VITE_BACKEND_URL only outside Tauri
  ├─ socketService    → Socket.io to the local core (base URL derived from the RPC URL); MCP-style envelopes
  ├─ coreRpcClient    → JSON-RPC over HTTP to the local openhuman core; `relay_http_rpc` fallback for non-loopback http
  └─ transport/       → ConnectionProfile transports for iOS/remote (LanHttp, Tunnel, CloudHttp)
```

--------------------------------

### Implement hook subscriptions with cleanup

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Always include all dependencies in the dependency array and provide a cleanup function to prevent memory leaks.

```typescript
useEffect(() => {
  on("event", handler);
  return () => off("event", handler);
}, [on, off, handler]);
```

--------------------------------

### Frontend Component Directory Structure

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/frontend.md

Visual representation of the component hierarchy and organization within the application source code.

```text
components/
├── ProtectedRoute / PublicRoute / DefaultRedirect   # Route guards
├── layout/shell/            # RootShellLayout, AppSidebar, SidebarSlot (two-pane app chrome)
├── settings/                # Settings registry, modal, layout, panels, search (see above)
├── accounts/                # WebviewHost + connected-app (CEF webview) surfaces
├── BootCheckGate/, daemon/  # Boot + service gates in the provider chain
├── commands/                # CommandProvider (command palette)
├── Announcement/, upsell/, userErrors/, walkthrough/  # Shell-level overlays
├── keyring/, mcp-setup/, InitProgressScreen/          # Consent + init overlays
└── intelligence/            # Memory/vault surfaces (ObsidianVaultSection, VaultHealthChecklist, WorkflowsTab, …)
```

--------------------------------

### Set application secrets

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Configures required and optional environment secrets, including the authentication token and Sentry DSN.

```bash
# Required
fly secrets set OPENHUMAN_CORE_TOKEN="$(openssl rand -hex 32)"
fly secrets set BACKEND_URL="https://api.tinyhumans.ai"
fly secrets set OPENHUMAN_APP_ENV="production"

# Recommended for any publicly-reachable deployment:
fly secrets set OPENHUMAN_AUTO_UPDATE_RPC_MUTATIONS_ENABLED="false"
fly secrets set OPENHUMAN_AUTO_UPDATE_RESTART_STRATEGY="supervisor"

# Optional — error reporting and analytics:
fly secrets set OPENHUMAN_CORE_SENTRY_DSN="https://<key>@o<org>.ingest.sentry.io/<project>"
fly secrets set OPENHUMAN_ANALYTICS_ENABLED="true"
```

--------------------------------

### Resolve libstdc++ issues on Linux

Source: https://tinyhumans.gitbook.io/openhuman/developing/building-rust-core.md

Use this workaround if the build fails due to unresolved libstdc++ headers when using clang.

```bash
# Ubuntu/Debian — adjust the GCC version as needed
sudo ln -sf /usr/lib/gcc/x86_64-linux-gnu/13/libstdc++.so /usr/lib/x86_64-linux-gnu/libstdc++.so
```

--------------------------------

### Configure CORS for Remote UI

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Add non-loopback origins to the core's allowlist to enable cross-origin RPC requests.

```bash
export OPENHUMAN_CORE_ALLOWED_ORIGINS="https://openhuman-ui.example.com"
```

--------------------------------

### Execute E2E Notification Tests

Source: https://tinyhumans.gitbook.io/openhuman/developing/e2e-testing.md

Run the notification specification test suite using the provided shell script.

```bash
bash app/scripts/e2e-run-spec.sh test/e2e/specs/notifications.spec.ts notifications
```

--------------------------------

### Capture checkpoints and mock logs in specs

Source: https://tinyhumans.gitbook.io/openhuman/developing/agent-observability.md

Use these helpers to record the application state and mock server logs during test execution.

```typescript
import {
  captureCheckpoint,
  saveMockRequestLog,
} from '../helpers/artifacts';
import { getRequestLog } from '../mock-server';

await captureCheckpoint('after-connect-click');
saveMockRequestLog('after-connect-click', getRequestLog());
```

--------------------------------

### Verify Ollama server status

Source: https://tinyhumans.gitbook.io/openhuman/guides/guides/local-model.md

Use this command to confirm the Ollama local server is running and reachable by OpenHuman.

```bash
curl http://localhost:11434/api/tags
```

--------------------------------

### Agent Tier Hierarchy Visualization

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/agent-harness.md

Visual representation of the allowed delegation paths between agent tiers.

```text
Chat        (fast, UX-focused — e.g. orchestrator on `chat` hint)
  │
  ├─► Worker      ◄─── fast path: one delegation, leaf does the work
  │
  └─► Reasoning   (slow, deep-thinking — e.g. planner on `reasoning` hint)
        │
        └─► Worker  ◄─── deep path: reasoning decomposes, workers execute
```

--------------------------------

### AgentHarness tool-call loop structure

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/agent-harness.md

The logical flow of the AgentHarness loop, which handles context management, provider communication, and tool execution.

```text
loop {
    1. context guard      - if history is too big, microcompact / autocompact
    2. stop-hook check    - budget caps, max-iterations, custom kill switches
    3. provider call      - send messages + tool specs, stream the response
    4. parse response     - split assistant text from tool calls
    5. if no tool calls   - return final text
    6. execute tool calls - dispatch each one (next section)
    7. summarize oversize - route huge tool outputs through the summarizer agent
    8. append results     - push tool results into history, loop again
}
```

--------------------------------

### Task Decision Execution Logic

Source: https://tinyhumans.gitbook.io/openhuman/features/subconscious.md

Visual representation of how the local model handles task decisions based on intent and escalation requirements.

```text
Decision: Skip
  → Log "nothing new", schedule the next run

Decision: Act
  → Execute on the local model (read or write)

Decision: Escalate
  ├─ Write-intent task
  │   → Run the cloud agent with full permissions
  │   → No approval needed (you explicitly asked for the action)
  │
  └─ Read-only task
      → Run the cloud agent in analysis-only mode
      → If the agent surfaces an unsolicited recommended action
      │   → Create an escalation card for your approval
      │   → On approval → re-run with full permissions
      └─ Otherwise → log result, done
```

--------------------------------

### memory.tool_rule_get

Source: https://tinyhumans.gitbook.io/openhuman/features/native-tools/tool-memory.md

Fetches a specific rule by tool name and rule ID.

```APIDOC
## memory.tool_rule_get

### Description
Retrieves a single rule identified by the tool name and rule ID.

### Parameters
- **tool_name** (string) - The name of the tool.
- **id** (string) - The unique identifier for the rule.
```

--------------------------------

### memory.tool_rules_json

Source: https://tinyhumans.gitbook.io/openhuman/features/native-tools/tool-memory.md

Returns a raw JSON list of rules for envelope consumers.

```APIDOC
## memory.tool_rules_json

### Description
Provides a raw JSON list of all tool rules, intended for use by envelope consumers.
```

--------------------------------

### Manual Cleanup of Stale Processes

Source: https://tinyhumans.gitbook.io/openhuman/developing/getting-set-up.md

Commands to manually terminate lingering OpenHuman processes.

```bash
pkill -f "OpenHuman.app/Contents"
pkill -f "openhuman-core"
```

--------------------------------

### openhuman.approval_list_pending

Source: https://tinyhumans.gitbook.io/openhuman/features/approval-gate.md

Retrieves the live queue of parked requests awaiting approval.

```APIDOC
## openhuman.approval_list_pending

### Description
Returns the current list of parked requests that are waiting for user approval.

### Method
JSON-RPC

### Parameters
None
```

--------------------------------

### Define a StateGraph

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/agent-harness.md

Construct a state machine using the builder pattern to define nodes, edges, and entry/finish points.

```rust
StateGraph::new(name)
  .add_node(id, node)            // a unit of work: async fn(State) -> (State, Command)
  .add_edge(from, to)            // static transition
  .add_conditional_edges(...)    // route by inspecting state
  .add_fork(from, [a, b])        // fan out in parallel; merge via State::merge
  .set_entry_point(id) / .set_finish_point(id)
  .compile()? -> CompiledGraph   // validated; .invoke(state) / .resume_with(...)
```

--------------------------------

### Update Local Deployment

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Commands to update a repository-based Docker Compose deployment.

```bash
git pull
docker compose build
docker compose up -d
```

--------------------------------

### Update Image Version

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Updates the image tag in the configuration file for version-pinned deployments.

```toml
[build]
  image = "ghcr.io/tinyhumansai/openhuman-core:v1.2.4"
```

--------------------------------

### UI to Core data flow

Source: https://tinyhumans.gitbook.io/openhuman/developing/architecture/tauri-shell.md

The communication path from the React frontend to the embedded core server.

```text
React (fetch)
    → POST http://127.0.0.1:<port>/rpc   (URL from `core_rpc_url`,
                                          bearer from `core_rpc_token`)
        → embedded openhuman core server (tokio task in this process)
```

--------------------------------

### Obsidian Vault Directory Structure

Source: https://tinyhumans.gitbook.io/openhuman/features/obsidian-wiki.md

The workspace directory contains a wiki folder with subdirectories for summaries, notes, and connected toolkits.

```text
<workspace>/
└── wiki/
 ├── summaries/ # auto-generated source / topic / global summaries
 ├── notes/ # your hand-written notes (free-form)
 └── … # one folder per connected toolkit you've connected
```

--------------------------------

### Fix Volume UID Mismatch

Source: https://tinyhumans.gitbook.io/openhuman/features/cloud-deploy.md

Resolves permission errors by SSH-ing into the machine to update file ownership and restarting the service.

```bash
fly ssh console --config .fly/fly.toml
chown -R openhuman:openhuman /home/openhuman/.openhuman/
exit
fly machine restart --config .fly/fly.toml
```
Tokens:
Raw