Tutorial teknis + mental model + implementasi Hermes Agent

Untuk audiens @kayadigital.ai <callout icon="✅" color="green_bg">

STATUS VERIFIKASI — 27 September 2026

Tutorial ini diverifikasi ulang terhadap dokumentasi resmi OpenAI, Anthropic, LangGraph/LangMem, dan Hermes Agent/Nous Research yang tersedia saat ini. Bagian Content Agent + SQLite adalah contoh implementasi yang kita bangun sendiri, bukan fitur bawaan Hermes dan bukan klaim studi kasus produksi. </callout>

AI Agent Memory Architecture: Dari Chat Memory ke Persistent State + Praktik Hermes Agent

Pertanyaan awalnya sederhana:

Kalau Claude & ChatGPT sudah punya memory, buat apa agent pakai database lagi? Jawabannya: karena mengingat pengguna dan menjalankan workflow yang punya state adalah dua kebutuhan yang berbeda. Tutorial ini membangun pemahamannya dari nol, lalu mempraktikkannya memakai Hermes Agent.

Bukan berarti salah satunya lebih baik. Fungsinya berbeda.

LangGraph memberi contoh pemisahan yang sangat jelas: checkpointer menyimpan state sebuah thread sebagai checkpoint, sedangkan store menyimpan data jangka panjang yang didefinisikan aplikasi dan dapat digunakan lintas thread. Sumber: LangGraph — Persistence

4. Apakah Setiap AI Agent Harus Punya Database?

Tidak.

Agent sederhana mungkin cukup memakai:

• context window;
• memory bawaan runtime;
• session history;
• file lokal;
• API sederhana. Database menjadi berguna ketika workflow mulai membutuhkan persistent application state. Contoh:
• daftar order;
• status tiket;
• histori konten;
• approval;
• CRM record;
• customer state;
• dokumen yang sudah diproses;
• job queue;
• workflow checkpoint. Jadi rule yang lebih tepat bukan:

“AI Agent wajib punya database.” Tetapi: Jika state harus tetap ada, dapat dicari, diperbarui, dibedakan antar-user/project, atau digunakan lagi pada run berikutnya, kita membutuhkan persistence yang sesuai.

5. “Database” dalam Carousel Sebenarnya Lebih Tepat Disebut Persistent Store

Persistent store tidak selalu berarti satu jenis database. Implementasi dapat berupa:

• relational database seperti PostgreSQL atau SQLite;
• key-value store;
• vector store;
• document store;
• kombinasi beberapa storage. Pemilihannya tergantung jenis state. Contohnya:

Relational / SQL

• task;
• status;
• approval;
• tanggal;
• relasi entity;
• data terstruktur.

Key-value

• state sederhana;
• cache;
• lookup cepat.

Vector store

• semantic retrieval;
• mencari dokumen/memory berdasarkan kemiripan makna.

Object/file storage

• PDF;
• gambar;
• file besar. Vector store bukan pengganti semua database. Untuk task status seperti pending → approved → published, database terstruktur biasanya lebih natural dibanding menyimpan semuanya sebagai embedding.

6. Kenapa Tidak Cukup Masukkan Seluruh History ke Prompt?

Karena context window adalah working context, bukan source of truth aplikasi. Semakin besar workflow, agent biasanya membutuhkan operasi yang lebih eksplisit:

WRITE

menyimpan state atau fakta penting.

READ

mengambil record tertentu.

SEARCH

mencari informasi yang relevan.

UPDATE

mengubah state, misalnya Draft → Approved.

DELETE

menghapus data yang memang tidak lagi diperlukan. LangMem juga menyediakan pola memory tools untuk menyimpan, mencari, memperbarui, dan mengorganisasi memory ke namespace. Dokumentasinya menunjukkan namespace dapat dipisahkan berdasarkan user, organization, assistant/agent, atau kategori lain. Sumber:

• LangMem — Memory Tools
• LangMem — Dynamic Namespaces

7. Apa Sebenarnya Full AI Agent Architecture?

Carousel kita fokus pada Memory & State Architecture, bukan seluruh arsitektur agent. Mental model yang lebih lengkap:

USER / EVENT
     ↓
AGENT RUNTIME
     ↓
MODEL / REASONING
     ↓
TOOL SELECTION
     ↓
TOOLS / EXTERNAL SYSTEMS
     ↓
OBSERVATION / RESULT
     ↓
MEMORY + STATE UPDATE
     ↺

Di dunia nyata biasanya masih ada:

• permissions;
• guardrails;
• human approval;
• logging;
• retries;
• scheduling;
• evaluation;
• monitoring. Jadi label paling presisi untuk carousel ini adalah:

AI Agent Memory Architecture atau Memory & State in AI Agents

8. Sekarang Masuk ke Hermes: Hermes Itu Apa dalam Diagram Kita?

Hermes Agent bukan “database memory”. Hermes adalah agent runtime/harness yang sudah membawa banyak komponen agent: model access, tools, terminal/file operations, memory, session search, skills, MCP integration, delegation, cron/scheduling, dan fitur lainnya. Secara sederhana:

               HERMES AGENT
                    │
  ┌─────────────────┼─────────────────┐
  │                 │                 │
MODEL             TOOLS            MEMORY
  │                 │                 │
  │          terminal/web/MCP     USER.md
  │                                MEMORY.md
  │
  ├──────────── SESSION SEARCH
  ├──────────── SKILLS
  └──────────── PROJECT CONTEXT
                    │
                    ↓
          EXTERNAL SYSTEMS
        DB / API / FILE / WEB

Sumber:

• Hermes — Features Overview
• Hermes — Tools & Toolsets

9. Empat Hal yang Sering Tercampur Saat Membahas Hermes

A. USER.md — siapa user-nya

Hermes menggunakan USER.md untuk informasi seperti identitas, preferensi komunikasi, workflow habits, dan ekspektasi user. Contoh:

Nama: Fery
Bahasa utama: Indonesia
Prefer carousel: praktis, padat, mudah dibaca
Hindari: mengulang topik yang baru diposting

B. MEMORY.md — apa yang agent pelajari

MEMORY.md dipakai untuk fakta tentang environment, convention, project, tool quirks, atau lessons learned yang perlu dibawa ke sesi berikutnya. Dokumentasi Hermes saat ini membatasi MEMORY.md sekitar 2.200 karakter dan USER.md sekitar 1.375 karakter. Keduanya dimasukkan sebagai snapshot pada awal session. Sumber: Hermes — Persistent Memory

C. Session Search — apa yang pernah dibicarakan

Hermes menyimpan conversation session pada SQLite state database dan menyediakan session_search berbasis SQLite FTS5 untuk mencari pesan dari session sebelumnya. Ini berguna ketika agent perlu menjawab:

“Kemarin kita pernah membahas apa tentang content agent?” tanpa memasukkan seluruh history ke memory aktif. Sumber: Hermes — Sessions

D. Skills — bagaimana melakukan sesuatu

Skills berbeda dari memory. Hermes menjelaskan perbedaannya dengan sangat jelas:

• Memory = factual knowledge / what
• Skill = procedural knowledge / how Skill dimuat on-demand ketika relevan, bukan selalu dimasukkan penuh pada setiap session. Contoh skill:

bagaimana melakukan riset ide konten, mengecek history konten, memverifikasi klaim, lalu membuat rekomendasi. Sumber: Hermes — Working with Skills

10. Maka Database Workflow Kita Ada di Mana?

Sekarang kita bisa memetakan semuanya. Untuk AI Content Agent:

USER
 ↓
HERMES
 ├─ USER.md
 │    → preferensi user
 │
 ├─ MEMORY.md
 │    → fakta penting yang dipelajari
 │
 ├─ SESSION SEARCH
 │    → percakapan terdahulu
 │
 ├─ SKILL
 │    → prosedur membuat / menilai konten
 │
 └─ TERMINAL / MCP / TOOL
      ↓
 CONTENT DATABASE
      ↓
 topic
 status
 format
 CTA
 audience question
 publish date
 notes

Content Database bukan pengganti Hermes Memory.

Hermes Memory menjawab:

“Apa yang penting untuk saya ingat?” Content Database menjawab: “Apa state nyata dari workflow konten?”

11. Praktik: Bangun Content Agent dengan Hermes + SQLite

Kita akan membuat demo lokal yang benar-benar memisahkan:

1. Hermes built-in memory
2. Hermes session history
3. Hermes skill
4. Application database Use case:

User meminta: “Cari ide carousel malam ini.” Agent harus lebih dulu mengecek history konten dan draft sebelum memberi ide. <callout icon="📝" color="yellow_bg"> Ini reference implementation untuk belajar arsitektur. SQLite di sini bukan database bawaan Hermes. Kita sengaja membuat store sendiri agar perbedaan antara agent memory dan business/workflow state terlihat jelas. </callout>

12. Install Hermes

Windows / macOS

Dokumentasi Hermes merekomendasikan Hermes Desktop installer untuk Windows dan macOS.

CLI — Linux / macOS / WSL2 / Android Termux

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Windows native PowerShell

iex (irm https://hermes-agent.nousresearch.com/install.ps1)

Setelah instalasi, konfigurasi model:

hermes model

Atau jalur Nous Portal:

hermes setup --portal

Sumber:

• Hermes — Installation
• Hermes — Quickstart

13. Opsional: Pakai OpenRouter sebagai Provider Model

Hermes saat ini mendukung OpenRouter. Cara paling aman untuk pemula: jalankan:

hermes model

lalu pilih OpenRouter dan ikuti setup interaktif. Dokumentasi juga mendukung OAuth OpenRouter:

hermes auth add openrouter --type oauth

atau API key melalui konfigurasi Hermes.

Jangan menaruh API key di prompt, SKILL.md, atau database konten.

Sumber: Hermes — AI Providers

14. Pastikan Tool yang Dibutuhkan Aktif

Untuk demo ini kita membutuhkan minimal:

• terminal;
• file operations;
• memory;
• skills;
• session_search. Untuk ide konten yang memerlukan informasi terbaru, tambahkan web tools. Buka konfigurasi:

hermes tools

Hermes mendokumentasikan terminal, file, memory, session_search, skills, web, browser, cronjob, delegation, dan toolset lain sebagai bagian dari registry-nya. Sumber: Hermes — Tools & Toolsets

15. Buat Folder Project

mkdir content-agent
cd content-agent

Buat file:

content-agent/
├── content_memory.py
└── content.db

content.db akan dibuat otomatis oleh script.

16. Buat Database Workflow

Buat file content_memory.py dengan isi berikut.

import argparse
import json
import sqlite3
from pathlib import Path

DB = Path(__file__).with_name("content.db")

def connect():
    conn = sqlite3.connect(DB)
    conn.row_factory = sqlite3.Row
    return conn

def init_db():
    conn = connect()
    conn.execute("""
        CREATE TABLE IF NOT EXISTS content_history (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            topic TEXT NOT NULL,
            status TEXT NOT NULL DEFAULT 'draft',
            format TEXT,
            cta TEXT,
            audience_question TEXT,
            published_at TEXT,
            notes TEXT,
            created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
        )
    """)
    conn.commit()
    conn.close()

def rows_to_json(rows):
    print(json.dumps([dict(row) for row in rows], ensure_ascii=False, indent=2))

def add(args):
    conn = connect()
    conn.execute(
        """
        INSERT INTO content_history
        (topic, status, format, cta, audience_question, published_at, notes)
        VALUES (?, ?, ?, ?, ?, ?, ?)
        """,
        (
            args.topic,
            args.status,
            args.format,
            args.cta,
            args.question,
            args.published_at,
            args.notes,
        ),
    )
    conn.commit()
    conn.close()
    print("OK")

def recent(args):
    conn = connect()
    rows = conn.execute(
        """
        SELECT * FROM content_history
        ORDER BY COALESCE(published_at, created_at) DESC
        LIMIT ?
        """,
        (args.limit,),
    ).fetchall()
    conn.close()
    rows_to_json(rows)

def pending(args):
    conn = connect()
    rows = conn.execute(
        """
        SELECT * FROM content_history
        WHERE lower(status) != 'published'
        ORDER BY created_at DESC
        """
    ).fetchall()
    conn.close()
    rows_to_json(rows)

def search(args):
    conn = connect()
    q = "%" + args.query + "%"
    rows = conn.execute(
        """
        SELECT * FROM content_history
        WHERE topic LIKE ?
           OR cta LIKE ?
           OR audience_question LIKE ?
           OR notes LIKE ?
        ORDER BY created_at DESC
        """,
        (q, q, q, q),
    ).fetchall()
    conn.close()
    rows_to_json(rows)

def update_status(args):
    conn = connect()
    conn.execute(
        "UPDATE content_history SET status = ? WHERE id = ?",
        (args.status, args.id),
    )
    conn.commit()
    conn.close()
    print("OK")

def delete(args):
    conn = connect()
    conn.execute("DELETE FROM content_history WHERE id = ?", (args.id,))
    conn.commit()
    conn.close()
    print("OK")

parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest="command", required=True)

sub.add_parser("init")

p = sub.add_parser("add")
p.add_argument("--topic", required=True)
p.add_argument("--status", default="draft")
p.add_argument("--format", default="")
p.add_argument("--cta", default="")
p.add_argument("--question", default="")
p.add_argument("--published-at", default=None)
p.add_argument("--notes", default="")

p = sub.add_parser("recent")
p.add_argument("--limit", type=int, default=30)

sub.add_parser("pending")

p = sub.add_parser("search")
p.add_argument("--query", required=True)

p = sub.add_parser("update-status")
p.add_argument("--id", type=int, required=True)
p.add_argument("--status", required=True)

p = sub.add_parser("delete")
p.add_argument("--id", type=int, required=True)

args = parser.parse_args()

init_db()

if args.command == "init":
    print("Database ready:", DB)
elif args.command == "add":
    add(args)
elif args.command == "recent":
    recent(args)
elif args.command == "pending":
    pending(args)
elif args.command == "search":
    search(args)
elif args.command == "update-status":
    update_status(args)
elif args.command == "delete":
    delete(args)

Kenapa output dibuat JSON? Supaya agent menerima data terstruktur, bukan harus menebak struktur dari output terminal yang berantakan.

17. Inisialisasi Database

Jalankan:

python content_memory.py init

Expected output:

Database ready: .../content.db

18. Masukkan Contoh History dari Carousel

python content_memory.py add   --topic "Prompt Injection"   --status published   --format infographic   --cta "Tutorial"   --question "RAG aman?"   --published-at "2026-09-24"

Tambahkan beberapa konten lain agar agent punya history yang realistis. Cek:

python content_memory.py recent --limit 30

Di sinilah operasi READ terjadi.

19. Test SEARCH, UPDATE, dan DELETE

Search

python content_memory.py search --query "Prompt Injection"

Update state

Misalnya draft nomor 2 disetujui:

python content_memory.py update-status --id 2 --status approved

Delete

Hanya untuk record yang memang ingin dibuang:

python content_memory.py delete --id 2

Sekarang lima konsep carousel terlihat secara nyata:

WRITE  → add
READ   → recent / pending
SEARCH → search
UPDATE → update-status
DELETE → delete

20. Buat Hermes Skill: Content Agent Memory

Hermes Skills adalah prosedur reusable. Semua skill lokal berada di ~/.hermes/skills/ dan tiap skill memiliki SKILL.md. Buat directory:

mkdir -p ~/.hermes/skills/content/content-agent-memory

Buat:

~/.hermes/skills/content/content-agent-memory/SKILL.md

Isi:

---
name: content-agent-memory
description: Cek history konten sebelum merekomendasikan ide baru.
version: 1.0.0
metadata:
  hermes:
    tags: [content, memory, workflow]
    category: content
    requires_toolsets: [terminal]
---

# Content Agent Memory

## When to Use

Gunakan ketika user meminta:
- ide konten baru;
- evaluasi topik yang pernah dipakai;
- kelanjutan draft;
- pengecekan duplikasi konten.

## Procedure

1. Sebelum merekomendasikan ide, query 30 record terbaru:
   python content_memory.py recent --limit 30

2. Query draft/pending:
   python content_memory.py pending

3. Jika user merujuk diskusi terdahulu yang tidak ada di database,
   gunakan session_search.

4. Jika rekomendasi bergantung pada perkembangan terbaru,
   gunakan web search dan verifikasi sumber.

5. Pisahkan:
   - fakta dari database;
   - fakta dari web;
   - inference/rekomendasi agent.

6. Jangan menulis record baru sebelum user memilih atau menyetujui ide.

7. Setelah ide disetujui, simpan sebagai draft dengan content_memory.py add.

## Pitfalls

- Database history bukan sumber kebenaran untuk klaim eksternal.
- Jangan menganggap topik tidak pernah dibuat hanya karena database kosong.
- Jangan memasukkan credential ke database atau memory.
- Jangan menghapus record tanpa alasan yang jelas.

## Verification

Sebelum menjawab ide konten, pastikan recent dan pending sudah diperiksa.

Dokumentasi resmi Hermes menyatakan skill dapat disimpan di ~/.hermes/skills/ dan langsung tersedia sebagai slash command setelah dimuat pada session baru. Sumber: Hermes — Skills System

21. Jalankan Session Baru

Mulai session baru agar skill terdeteksi:

hermes chat

Kemudian:

/content-agent-memory Cari ide carousel malam ini.

Sebelum memberi rekomendasi:
1. periksa 30 konten terakhir;
2. periksa draft yang belum publish;
3. hindari topik yang terlalu dekat;
4. jika perlu informasi terbaru, gunakan web research;
5. berikan 3 angle dengan alasan singkat.

Sekarang workflow-nya berbeda dari chatbot biasa. Bukan:

PROMPT
  ↓
LLM
  ↓
IDE

Tetapi:

REQUEST
  ↓
HERMES
  ↓
LOAD SKILL
  ↓
QUERY CONTENT DATABASE
  ↓
CHECK PENDING
  ↓
OPTIONAL SESSION SEARCH
  ↓
OPTIONAL WEB RESEARCH
  ↓
REASON OVER RESULTS
  ↓
RECOMMEND NEW ANGLE

22. Di Mana Letak “Agentic”-nya?

Bukan karena ada database. Bukan juga karena namanya Hermes. Sifat agentic muncul karena model berada dalam loop yang dapat:

1. memahami goal;
2. memilih tool;
3. mengamati hasil tool;
4. menentukan langkah berikutnya;
5. mengubah state bila diperlukan;
6. berhenti atau meminta keputusan manusia. Database hanya salah satu environment/tool yang dapat digunakan agent.

23. Bedakan Empat Jenis Informasi Ini

Ini adalah bagian yang paling penting untuk memahami perbedaan “AI mengingat saya” dan “agent mempunyai state.”

24. Bagaimana Hermes Memory Sendiri Bekerja?

Hermes memiliki dua memory file utama: USER.md

• profile user;
• preferensi;
• gaya komunikasi;
• ekspektasi. MEMORY.md
• environment facts;
• project conventions;
• lessons learned;
• tool quirks;
• hal penting yang ingin dibawa ke session berikutnya. Keduanya adalah memory yang terkurasi dan bounded. Hermes juga memiliki session database terpisah. Dokumentasi saat ini menyebut session disimpan ke ~/.hermes/state.db dengan full-text search FTS5. Jadi:

MEMORY.md / USER.md
→ key facts yang selalu berguna

SESSION SEARCH
→ cari percakapan lama saat dibutuhkan

CONTENT DATABASE
→ state aplikasi / workflow

25. Mengapa Skill Bukan Memory?

Karena procedure biasanya jauh lebih panjang daripada fakta. Contoh memory:

“Audiens utama pemula-intermediate Indonesia.” Contoh skill: “Sebelum membuat carousel, cek history → cek pending → research sumber → buat angle → verifikasi → format 8 slide → tunggu approval.” Hermes sendiri mendokumentasikan pola: Memory = factual knowledge. Skills = procedural knowledge. Inilah sebabnya menyimpan seluruh SOP ke USER.md atau MEMORY.md bukan desain yang ideal.

26. Bagaimana Kalau Database-nya Notion, PostgreSQL, CRM, atau Sistem Perusahaan?

Arsitekturnya tetap sama.

HERMES
  ↓
TOOL / MCP
  ↓
NOTION / POSTGRES / CRM / API

Hermes mendukung MCP untuk menghubungkan external tool server, database, filesystem, internal API, GitHub, dan layanan lain. Sumber: Hermes — MCP <callout icon="⚠️" color="yellow_bg">

Catatan penting: Notion connector yang dipakai ChatGPT dalam tutorial/portal ini tidak otomatis tersedia di Hermes. Hermes harus memiliki integrasi/MCP dan autentikasinya sendiri. Jangan menganggap koneksi antar-produk otomatis terbagi. </callout> Untuk belajar, SQLite lebih transparan. Untuk workflow editorial kecil, Notion dapat menjadi source of truth yang nyaman. Untuk state transactional atau workload yang lebih berat, pilih storage sesuai kebutuhan teknis aplikasi.

27. Advanced: External Memory Provider Hermes

Hermes saat ini juga mendukung external memory provider plugin yang berjalan bersama, bukan menggantikan, built-in MEMORY.md / USER.md. Dokumentasi Hermes menyebut provider seperti Honcho, OpenViking, Mem0, Holographic, RetainDB, ByteRover, Supermemory, serta provider lain dari plugin catalog. Setup interaktif:

hermes memory setup

Status:

hermes memory status

Ini berguna ketika kita membutuhkan memory lebih dalam seperti semantic retrieval, cross-session modeling, atau knowledge graph. Tetapi untuk memahami fondasi arsitektur, jangan langsung menambahkan external memory provider. Pastikan dulu kita memahami:

context
≠ user memory
≠ session history
≠ skill
≠ workflow state
≠ external knowledge

Sumber: Hermes — Memory Providers

28. Kapan Content Database Ditulis?

Jangan biarkan agent menulis apa pun secara sembarangan. Contoh lifecycle:

IDE PROPOSED
     ↓
HUMAN REVIEW
     ↓
APPROVED
     ↓
WRITE TO DATABASE
     ↓
DRAFT
     ↓
PUBLISHED
     ↓
UPDATE STATUS

Untuk content workflow, human checkpoint tetap berguna agar:

• rekomendasi agent tidak otomatis dianggap keputusan final;
• draft yang belum dipilih tidak memenuhi database;
• status published mencerminkan kejadian nyata.

29. Contoh Workflow Akhir: “Cari Ide Carousel Malam Ini”

User:

Cari ide carousel malam ini. Agent:

STEP 1 — LOAD PROCEDURE

Memuat Content Agent Skill.

STEP 2 — READ BUSINESS STATE

Query 30 posting terakhir.

STEP 3 — CHECK OPEN STATE

Query draft/pending.

STEP 4 — RECALL IF NEEDED

Gunakan session_search jika user merujuk diskusi lama.

STEP 5 — RESEARCH IF NEEDED

Gunakan web jika angle membutuhkan informasi terbaru.

STEP 6 — REASON

Bandingkan candidate topic dengan content history.

STEP 7 — OUTPUT

Berikan 3 ide yang tidak terlalu dekat dengan konten terakhir.

STEP 8 — HUMAN DECISION

User memilih satu.

STEP 9 — WRITE

Simpan ide yang dipilih sebagai draft.

STEP 10 — UPDATE

Setelah publish, ubah status menjadi published. Inilah bentuk yang lebih nyata dari:

Agent menggunakan history pekerjaan untuk menentukan next action.

30. Bagaimana Memastikan Agent Benar-Benar Menggunakan Database?

Jangan hanya bertanya:

“Apakah kamu sudah cek database?” Buat verification step yang dapat diamati. Minta agent menampilkan:

Sebelum rekomendasi, laporkan:
- jumlah record yang dicek;
- daftar topik yang sengaja dihindari;
- draft yang bentrok;
- apakah session_search digunakan;
- apakah web research digunakan;
- alasan memilih angle final.

Dengan begitu kita bisa membedakan:

claim

“saya sudah mengecek” dengan:

observable tool workflow

agent benar-benar query → membaca result → memakai result.

31. Kesalahan Konsep yang Paling Umum

“Kalau ChatGPT/Claude punya memory, database tidak dibutuhkan.”

Salah sebagai generalisasi. Memory produk chat dan workflow persistence melayani kebutuhan berbeda.

“Semua agent wajib pakai vector database.”

Tidak. Vector retrieval cocok untuk semantic search, tetapi task state sering lebih cocok pada store terstruktur.

“Hermes Memory adalah database bisnis.”

Bukan. Hermes memory adalah salah satu layer memory agent. Database aplikasi adalah state eksternal yang dapat diakses melalui tools.

“Skill sama dengan memory.”

Tidak. Pada Hermes, skill berisi procedure, memory berisi facts.

“Session history sama dengan application state.”

Tidak. Percakapan menjelaskan apa yang dibicarakan. Database workflow mencatat apa yang benar-benar menjadi state sistem.

“Semakin banyak memory semakin pintar.”

Tidak selalu. Memory yang tidak terkurasi dapat menjadi stale, tidak relevan, atau membebani context. Hermes sendiri membuat built-in memory bounded dan memisahkan session search dari memory aktif.

32. Checklist Sebelum Membuat Agent + Memory Database

• Apa yang harus diketahui hanya selama run sekarang?
• Apa yang merupakan preferensi user?
• Apa yang merupakan fakta penting lintas session?
• Apa yang merupakan procedure reusable?
• Apa yang merupakan workflow/business state?
• Apakah data harus dicari secara exact atau semantic?
• Apakah data harus di-update?
• Apakah state perlu dipisahkan per user/project/organization?
• Aksi apa yang butuh approval manusia?
• Apa source of truth?
• Apakah kita bisa membuktikan agent benar-benar membaca state sebelum bertindak? Jika pertanyaan ini terjawab, barulah pemilihan database dan memory layer menjadi jauh lebih jelas.

33. Ringkasan Mental Model

CONTEXT
Apa yang sedang ada di working window
        ↓
PERSONAL MEMORY
Siapa user dan preferensinya
        ↓
SESSION HISTORY
Apa yang pernah dibicarakan
        ↓
SKILL
Bagaimana melakukan pekerjaan
        ↓
WORKFLOW STATE
Apa kondisi pekerjaan sekarang
        ↓
LONG-TERM / EXTERNAL STORE
Apa yang harus bertahan dan dapat diambil lagi
        ↓
TOOLS + ACTION
Apa yang dapat dilakukan agent

Dan pada Hermes:

USER.md
     → user profile

MEMORY.md
     → key learned facts

SESSION SEARCH
     → past conversations

SKILLS
     → reusable procedures

TOOLS / MCP
     → akses sistem eksternal

EXTERNAL DATABASE
     → business / workflow state

<callout icon="🎯" color="blue_bg">

Kalimat yang perlu diingat:

Chat memory membantu AI mengenal konteks kita. Agent state membantu sistem mengetahui pekerjaan sedang berada di mana dan harus melakukan apa berikutnya. </callout>

Referensi Resmi

1. OpenAI — Memory in ChatGPT

2. Anthropic — Use Claude’s chat search and memory

3. LangGraph — Persistence

4. LangMem — Memory Tools

5. LangMem — Dynamic Namespaces

6. Hermes Agent — Quickstart

7. Hermes Agent — Installation

8. Hermes Agent — AI Providers

9. Hermes Agent — Tools & Toolsets

10. Hermes Agent — Persistent Memory

11. Hermes Agent — Sessions

12. Hermes Agent — Skills System

13. Hermes Agent — MCP

14. Hermes Agent — Memory Providers <callout icon="✅" color="green_bg">

    Status materi: fitur produk, istilah Hermes, command instalasi/setup, struktur built-in memory, session search, skills, toolsets, OpenRouter support, MCP, dan external memory provider diverifikasi terhadap sumber resmi. Script SQLite, schema Content Agent, dan workflow content recommendation adalah implementasi contoh yang ditulis untuk tutorial ini dan secara eksplisit tidak diklaim sebagai fitur native Hermes atau studi kasus produksi. </callout>