OnnoWiki - Recent changes [en]

MCP: Reset dari nol, embed semua doc, isi vector database

Onnowpurbo — Sun, 26 Jul 2026 02:54:55 GMT

Created page with "# Rekomendasi **Tidak perlu install ulang AnythingLLM.** Gunakan reset melalui API lalu lakukan **restart normal**, bukan `docker kill` atau force restart. Menghapus dan mem..."

New page

# Rekomendasi

**Tidak perlu install ulang AnythingLLM.** Gunakan reset melalui API lalu lakukan **restart normal**, bukan `docker kill` atau force restart.

Menghapus dan membuat ulang container dengan storage volume yang sama tidak menghapus workspace, dokumen, atau vector database karena data AnythingLLM disimpan di `/app/server/storage` dan memang dirancang tetap ada setelah rebuild atau pull image baru. ([AnythingLLM][1])

Script berikut menggunakan API resmi untuk:

1. Backup seluruh storage AnythingLLM.
2. Menghapus semua workspace.
3. Menghapus semua dokumen internal dan cached embedding.
4. Restart container secara graceful.
5. Membuat satu workspace baru.
6. Upload dan embed ulang seluruh file dari `/opt/ai-stack/documents`.
7. Membuat manifest berisi nama file, hash SHA-256, dan lokasi dokumen internal.

AnythingLLM menyediakan endpoint resmi untuk mendaftar dan menghapus workspace, menghapus dokumen permanen, membuat workspace, serta upload dokumen langsung ke workspace.

[Download reset-rebuild-anythingllm.sh](sandbox:/mnt/data/reset-rebuild-anythingllm.sh)

Script sudah diperiksa dengan `bash -n`.

---

## 1. Copy script ke server

Misalnya file sudah berada di folder Downloads:

```bash
sudo mkdir -p /opt/ai-stack/batch

sudo cp ~/Downloads/reset-rebuild-anythingllm.sh \
/opt/ai-stack/batch/

sudo chmod 750 \
/opt/ai-stack/batch/reset-rebuild-anythingllm.sh
```

Periksa:

```bash
ls -lh /opt/ai-stack/batch/reset-rebuild-anythingllm.sh
```

---

## 2. Periksa nama dan port container

```bash
docker ps --format 'table {{.Names}}\t{{.Image}}\t{{.Ports}}' \
| grep -i anything
```

Atau:

```bash
docker port anythingllm
```

Contoh:

```text
3001/tcp -> 0.0.0.0:3001
```

Berarti:

```bash
export ANYTHINGLLM_URL="http://127.0.0.1:3001"
```

Apabila AnythingLLM memakai port host `3002`:

```bash
export ANYTHINGLLM_URL="http://127.0.0.1:3002"
```

Hal ini penting bila port `3001` sudah digunakan WAHA.

---

## 3. Buat API key AnythingLLM

Masuk ke:

```text
AnythingLLM
→ Settings
→ Developer API
→ API Keys
→ New API Key
```

Dokumentasi API pada instance tersedia di:

```text
http://IP-SERVER:PORT/api/docs
```

API key harus disimpan sebagai rahasia karena siapa pun yang memilikinya dapat mengoperasikan API AnythingLLM. ([AnythingLLM][2])

Set API key:

```bash
export ANYTHINGLLM_API_KEY='MASUKKAN_API_KEY_ANDA'
```

Jangan menyimpan API key langsung di dalam script.

---

## 4. Tentukan konfigurasi

Untuk hanya meng-embed Markdown:

```bash
export DOCUMENT_ROOT="/opt/ai-stack/documents"
export WORKSPACE_NAME="Perpustakaan"
export CONTAINER_NAME="anythingllm"
export EMBED_EXTENSIONS="md"
```

Untuk Markdown, PDF, DOCX, dan TXT:

```bash
export EMBED_EXTENSIONS="md,pdf,docx,txt"
```

Saya menyarankan memakai:

```bash
export EMBED_EXTENSIONS="md"
```

bila semua PDF sudah dikonversi dan dibersihkan menjadi Markdown untuk RAG. Ini mencegah isi yang sama ter-embed dua kali dari versi PDF dan Markdown.

---

## 5. Pastikan API key bekerja

```bash
curl --fail --silent --show-error \
-H "Authorization: Bearer ${ANYTHINGLLM_API_KEY}" \
"${ANYTHINGLLM_URL}/api/v1/auth"
```

Hasil yang benar:

```json
{
"authenticated": true
}
```

---

## 6. Jalankan dry-run dahulu

```bash
/opt/ai-stack/batch/reset-rebuild-anythingllm.sh \
--dry-run
```

Dry-run hanya menghitung:

* Jumlah workspace lama.
* Jumlah dokumen internal lama.
* Jumlah file sumber yang akan di-embed.
* Ekstensi yang diproses.
* Nama workspace baru.

Tidak ada data yang dihapus.

---

## 7. Jalankan reset dan rebuild

```bash
/opt/ai-stack/batch/reset-rebuild-anythingllm.sh \
--yes-reset
```

Jika user belum mendapat akses Docker dan direktori backup:

```bash
sudo -E /opt/ai-stack/batch/reset-rebuild-anythingllm.sh \
--yes-reset
```

Opsi `-E` mempertahankan variabel lingkungan seperti API key dan URL.

---

## 8. Hasil backup

Sebelum menghapus data, script menghentikan container sementara dan membuat backup konsisten:

```text
/opt/ai-stack/backups/anythingllm-storage-YYYYMMDD-HHMMSS.tar.gz
```

Periksa:

```bash
ls -lh /opt/ai-stack/backups/
```

Contoh:

```text
anythingllm-storage-20260726-103000.tar.gz
anythingllm-rebuild-manifest-20260726-103215.tsv
```

Manifest berisi:

```text
relative_path sha256 anythingllm_location
```

Contoh:

```text
AI/RAG/Pengenalan RAG.md a421... custom-documents/Pengenalan-RAG.md-uuid.json
```

---

## 9. Pantau proses

Terminal lain:

```bash
docker logs -f anythingllm
```

Pantau resource:

```bash
docker stats anythingllm ollama
```

Pantau GPU ketika embedding memakai Ollama:

```bash
watch -n 1 nvidia-smi
```

---

## 10. Verifikasi setelah selesai

Periksa workspace:

```bash
curl --fail --silent --show-error \
-H "Authorization: Bearer ${ANYTHINGLLM_API_KEY}" \
"${ANYTHINGLLM_URL}/api/v1/workspaces" \
| python3 -m json.tool
```

Seharusnya hanya terdapat satu workspace baru.

Periksa dokumen:

```bash
curl --fail --silent --show-error \
-H "Authorization: Bearer ${ANYTHINGLLM_API_KEY}" \
"${ANYTHINGLLM_URL}/api/v1/documents" \
| python3 -m json.tool
```

AnythingLLM menjelaskan bahwa menghapus dokumen secara permanen dari sistem akan menghapus parsed source, cached embedding, serta mengeluarkannya dari setiap workspace. ([AnythingLLM][3])

---

# Apakah perlu force restart?

## Pilihan terbaik: reset API + restart normal

Script menggunakan:

```bash
docker restart -t 30 anythingllm
```

Ini memberikan waktu sampai 30 detik agar proses berhenti secara normal sebelum Docker mengambil tindakan lanjutan.

**Jangan menggunakan ini kecuali container macet:**

```bash
docker kill anythingllm
```

Force restart tidak membersihkan vector database. Ia hanya menghentikan dan menyalakan proses.

---

# Kapan perlu install ulang?

Install ulang atau factory reset hanya diperlukan apabila:

* SQLite AnythingLLM rusak.
* LanceDB rusak dan API tidak dapat membersihkannya.
* Container terus crash akibat storage internal.
* Konfigurasi sistem sudah sangat kacau.
* Anda benar-benar ingin menghapus user, API key, model settings, MCP, agent skills, chat history, dan seluruh konfigurasi.

Menarik image atau membuat ulang container **tanpa menghapus storage** bukan factory reset karena data tetap persisten. ([AnythingLLM][1])

---

# Factory reset penuh

Ini **bukan pilihan utama**. Perintah berikut menghilangkan seluruh konfigurasi aplikasi, bukan hanya RAG.

```bash
cd /opt/ai-stack

sudo docker compose stop anythingllm
```

Cari lokasi storage:

```bash
docker inspect anythingllm \
--format '{{range .Mounts}}{{println .Source "->" .Destination}}{{end}}'
```

Misalnya:

```text
/opt/ai-stack/anythingllm/storage -> /app/server/storage
```

Backup dan ganti nama:

```bash
sudo mv \
/opt/ai-stack/anythingllm/storage \
"/opt/ai-stack/anythingllm/storage.factory-reset.$(date +%Y%m%d-%H%M%S)"
```

Buat storage kosong:

```bash
sudo mkdir -p /opt/ai-stack/anythingllm/storage
sudo chown -R 1000:1000 /opt/ai-stack/anythingllm/storage
```

Jalankan kembali:

```bash
sudo docker compose up -d anythingllm
```

AnythingLLM kemudian tampil seperti instalasi pertama. Anda harus mengatur ulang:

* Akun administrator.
* LLM provider.
* Embedding provider.
* Vector database.
* API key.
* MCP dan agent skills.
* Workspace.
* Dokumen.

Karena tujuan Anda adalah membersihkan workspace dan membangun ulang seluruh embedding, **gunakan script API-reset, bukan factory reset dan bukan install ulang**.

[1]: https://docs.anythingllm.com/installation-docker/local-docker "Local Docker Installation ~ AnythingLLM"
[2]: https://docs.anythingllm.com/features/api "API Access & Keys ~ AnythingLLM"
[3]: https://docs.anythingllm.com/features/privacy-and-data-handling "Privacy & Data ~ AnythingLLM"

LLM

Onnowpurbo — Sun, 26 Jul 2026 02:47:25 GMT

MCP

MCP: Regenerate Vector Database untuk update content documents

Onnowpurbo — Sun, 26 Jul 2026 02:44:03 GMT

Show changes

MCP: Regenerate Vector Database untuk update content documents

Onnowpurbo — Sun, 26 Jul 2026 02:40:37 GMT

Created blank page

New page

LLM

Onnowpurbo — Sun, 26 Jul 2026 02:39:40 GMT

MCP

MCP: Instalasi pip

Onnowpurbo — Sun, 26 Jul 2026 02:04:46 GMT

Created page with "Error tersebut berarti Python sudah ada, tetapi modul **pip** belum terpasang. Gunakan virtual environment supaya tidak mengganggu Python sistem Ubuntu. Ubuntu juga merekomend..."

New page

Error tersebut berarti Python sudah ada, tetapi modul **pip** belum terpasang. Gunakan virtual environment supaya tidak mengganggu Python sistem Ubuntu. Ubuntu juga merekomendasikan penggunaan `venv` untuk paket yang dipasang melalui pip. ([Ubuntu Documentation][1])

Jalankan sebagai `root`:

```bash
cd /opt/ai-stack/batch

apt update
apt install -y python3-full python3-venv python3-pip
```

Buat virtual environment:

```bash
python3 -m venv .venv
```

Aktifkan:

```bash
source .venv/bin/activate
```

Prompt biasanya berubah menjadi:

```text
(.venv) root@server2:/opt/ai-stack/batch#
```

Pastikan Python sudah memakai virtual environment:

```bash
which python3
```

Seharusnya:

```text
/opt/ai-stack/batch/.venv/bin/python3
```

Kemudian instal dependensi:

```bash
python3 -m pip install --upgrade pip
python3 -m pip install pymupdf pyyaml
```

Verifikasi:

```bash
python3 - <<'PY'
import pymupdf
import yaml

print("PyMuPDF berhasil:", pymupdf.__version__)
print("PyYAML berhasil:", yaml.__version__)
PY
```

Setelah itu jalankan batch converter:

```bash
chmod +x batch_pdf_to_md.sh
chmod +x pdf_to_rag_md.py

./batch_pdf_to_md.sh /path/folder/pdf
```

Contoh:

```bash
./batch_pdf_to_md.sh \
/opt/ai-stack/documents \
/opt/ai-stack/output
```

Setiap kali keluar dari terminal atau login ulang, aktifkan kembali environment sebelum menjalankan script:

```bash
cd /opt/ai-stack/batch
source .venv/bin/activate
./batch_pdf_to_md.sh /opt/ai-stack/documents /opt/ai-stack/output
```

Jangan gunakan:

```bash
pip install --break-system-packages
```

karena pemasangan langsung ke Python sistem dapat berbenturan dengan paket bawaan Ubuntu.

[1]: https://documentation.ubuntu.com/ubuntu-for-developers/tutorials/python-use/?utm_source=chatgpt.com "Develop with Python on Ubuntu - Ubuntu for Developers"

LLM

Onnowpurbo — Sun, 26 Jul 2026 02:04:32 GMT

MCP

Batch pdf to md.sh

Onnowpurbo — Sun, 26 Jul 2026 01:47:44 GMT

Created page with "<pre> #!/usr/bin/env bash # Batch wrapper untuk pdf_to_rag_md.py # # Penggunaan: # ./batch_pdf_to_md.sh /path/folder_pdf # ./batch_pdf_to_md.sh /path/folder_pdf /path/fol..."

New page

<pre>

#!/usr/bin/env bash
# Batch wrapper untuk pdf_to_rag_md.py
#
# Penggunaan:
# ./batch_pdf_to_md.sh /path/folder_pdf
# ./batch_pdf_to_md.sh /path/folder_pdf /path/folder_output
# ./batch_pdf_to_md.sh /path/folder_pdf /path/folder_output /path/pdf_to_rag_md.py
#
# Hasil:
# OUTPUT_DIR/<path-relatif>/<nama-pdf>/
# ├── *.md
# └── manifest.json

set -Eeuo pipefail
IFS=$'\n\t'

PROGRAM_NAME="$(basename "$0")"
SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"

usage() {
cat <<EOF
Penggunaan:
$PROGRAM_NAME INPUT_PATH [OUTPUT_DIR] [PYTHON_SCRIPT]

Argumen:
INPUT_PATH Folder yang akan dicari secara rekursif, atau satu file PDF.
OUTPUT_DIR Folder induk hasil konversi.
Default: INPUT_PATH/output untuk input folder,
atau folder_file/output untuk input satu PDF.
PYTHON_SCRIPT Lokasi script Python konverter.
Default: dicari di folder yang sama dengan shell script.

Contoh:
$PROGRAM_NAME /opt/ai-stack/documents
$PROGRAM_NAME /opt/ai-stack/documents /opt/ai-stack/output
$PROGRAM_NAME ./pdf ./output ./pdf_to_rag_md.py
EOF
}

log() {
printf '[%s] %s\n' "$(date '+%Y-%m-%d %H:%M:%S')" "$*"
}

fail() {
printf 'ERROR: %s\n' "$*" >&2
exit 1
}

if [[ ${1:-} == "-h" || ${1:-} == "--help" ]]; then
usage
exit 0
fi

[[ $# -ge 1 && $# -le 3 ]] || {
usage >&2
exit 2
}

command -v python3 >/dev/null 2>&1 || fail "python3 tidak ditemukan."
command -v find >/dev/null 2>&1 || fail "Perintah find tidak ditemukan."

INPUT_PATH="$1"
[[ -e "$INPUT_PATH" ]] || fail "Path input tidak ditemukan: $INPUT_PATH"

# Ubah menjadi absolute path tanpa membutuhkan realpath.
if [[ -d "$INPUT_PATH" ]]; then
INPUT_PATH="$(cd -- "$INPUT_PATH" && pwd -P)"
INPUT_IS_DIR=1
else
INPUT_DIR="$(cd -- "$(dirname -- "$INPUT_PATH")" && pwd -P)"
INPUT_PATH="$INPUT_DIR/$(basename -- "$INPUT_PATH")"
INPUT_IS_DIR=0
fi

if [[ $# -ge 2 ]]; then
OUTPUT_DIR="$2"
else
if (( INPUT_IS_DIR )); then
OUTPUT_DIR="$INPUT_PATH/output"
else
OUTPUT_DIR="$(dirname -- "$INPUT_PATH")/output"
fi
fi
mkdir -p -- "$OUTPUT_DIR"
OUTPUT_DIR="$(cd -- "$OUTPUT_DIR" && pwd -P)"
[[ "$OUTPUT_DIR" != "$INPUT_PATH" ]] \
|| fail "OUTPUT_DIR tidak boleh sama persis dengan folder input. Gunakan subfolder, misalnya: $INPUT_PATH/output"

if [[ $# -ge 3 ]]; then
PYTHON_SCRIPT="$3"
else
if [[ -f "$SCRIPT_DIR/pdf_to_rag_md.py" ]]; then
PYTHON_SCRIPT="$SCRIPT_DIR/pdf_to_rag_md.py"
elif [[ -f "$SCRIPT_DIR/pdf_to_rag_md(2).py" ]]; then
PYTHON_SCRIPT="$SCRIPT_DIR/pdf_to_rag_md(2).py"
else
fail "Script Python tidak ditemukan. Letakkan pdf_to_rag_md.py di $SCRIPT_DIR atau berikan argumen PYTHON_SCRIPT."
fi
fi

[[ -f "$PYTHON_SCRIPT" ]] || fail "Script Python tidak ditemukan: $PYTHON_SCRIPT"
PYTHON_SCRIPT="$(cd -- "$(dirname -- "$PYTHON_SCRIPT")" && pwd -P)/$(basename -- "$PYTHON_SCRIPT")"

# Pastikan script Python valid dan dependensinya tersedia sebelum batch dimulai.
python3 -m py_compile "$PYTHON_SCRIPT" \
|| fail "Script Python gagal diperiksa dengan py_compile."

python3 - <<'PY' \
|| fail "Dependensi Python belum lengkap. Instal dengan: python3 -m pip install pymupdf pyyaml"
try:
import pymupdf # noqa: F401
except ImportError:
import fitz # noqa: F401
import yaml # noqa: F401
PY

find_input_files() {
if [[ "$OUTPUT_DIR" == "$INPUT_PATH/"* ]]; then
find "$INPUT_PATH" -path "$OUTPUT_DIR" -prune -o -type f "$@" -print0
else
find "$INPUT_PATH" -type f "$@" -print0
fi
}

printf '\n=== Daftar semua file pada input ===\n'
if (( INPUT_IS_DIR )); then
while IFS= read -r -d '' file; do
printf '%s\n' "$file"
done < <(find_input_files | sort -z)
else
printf '%s\n' "$INPUT_PATH"
fi
printf '=== Akhir daftar file ===\n\n'

PDF_FILES=()
if (( INPUT_IS_DIR )); then
while IFS= read -r -d '' pdf; do
PDF_FILES+=("$pdf")
done < <(find_input_files -iname '*.pdf' | sort -z)
else
[[ "${INPUT_PATH,,}" == *.pdf ]] \
|| fail "File input bukan PDF: $INPUT_PATH"
PDF_FILES+=("$INPUT_PATH")
fi

TOTAL=${#PDF_FILES[@]}
if (( TOTAL == 0 )); then
log "Tidak ada file PDF yang ditemukan."
exit 0
fi

LOG_FILE="$OUTPUT_DIR/batch_conversion.log"
SUMMARY_FILE="$OUTPUT_DIR/batch_summary.tsv"
printf 'status\tinput_pdf\toutput_folder\n' > "$SUMMARY_FILE"
: > "$LOG_FILE"

log "Ditemukan $TOTAL file PDF."
log "Output utama: $OUTPUT_DIR"
log "Log batch: $LOG_FILE"

SUCCESS=0
FAILED=0
INDEX=0

for PDF_FILE in "${PDF_FILES[@]}"; do
((INDEX += 1))

if (( INPUT_IS_DIR )); then
RELATIVE_PATH="${PDF_FILE#"$INPUT_PATH"/}"
else
RELATIVE_PATH="$(basename -- "$PDF_FILE")"
fi

RELATIVE_PARENT="$(dirname -- "$RELATIVE_PATH")"
PDF_NAME="$(basename -- "$RELATIVE_PATH")"
PDF_STEM="${PDF_NAME%.*}"

if [[ "$RELATIVE_PARENT" == "." ]]; then
PDF_OUTPUT_DIR="$OUTPUT_DIR/$PDF_STEM"
else
PDF_OUTPUT_DIR="$OUTPUT_DIR/$RELATIVE_PARENT/$PDF_STEM"
fi

mkdir -p -- "$PDF_OUTPUT_DIR"

printf '\n[%d/%d] Konversi: %s\n' "$INDEX" "$TOTAL" "$PDF_FILE"
printf ' Output : %s\n' "$PDF_OUTPUT_DIR"

printf '\n===== [%d/%d] %s =====\n' "$INDEX" "$TOTAL" "$PDF_FILE" \
| tee -a "$LOG_FILE"

set +e
python3 "$PYTHON_SCRIPT" \
"$PDF_FILE" \
--output-dir "$PDF_OUTPUT_DIR" \
--overwrite 2>&1 | tee -a "$LOG_FILE"
EXIT_CODE=${PIPESTATUS[0]}
set -e

if (( EXIT_CODE == 0 )); then
printf 'SUCCESS\t%s\t%s\n' "$PDF_FILE" "$PDF_OUTPUT_DIR" \
>> "$SUMMARY_FILE"
((SUCCESS += 1))
log "BERHASIL: $PDF_FILE" | tee -a "$LOG_FILE"
else
printf 'FAILED(%d)\t%s\t%s\n' "$EXIT_CODE" "$PDF_FILE" "$PDF_OUTPUT_DIR" \
>> "$SUMMARY_FILE"
((FAILED += 1))
log "GAGAL (exit $EXIT_CODE): $PDF_FILE" | tee -a "$LOG_FILE"
fi
done

printf '\n=== Ringkasan batch ===\n'
printf 'Total PDF : %d\n' "$TOTAL"
printf 'Berhasil : %d\n' "$SUCCESS"
printf 'Gagal : %d\n' "$FAILED"
printf 'Output : %s\n' "$OUTPUT_DIR"
printf 'Ringkasan : %s\n' "$SUMMARY_FILE"
printf 'Log : %s\n' "$LOG_FILE"

(( FAILED == 0 ))

</pre>

MCP: Convert PDF ke .md

Onnowpurbo — Sun, 26 Jul 2026 01:45:10 GMT

MCP: Convert PDF ke .md

Onnowpurbo — Sun, 26 Jul 2026 01:44:24 GMT

Created page with "Shell script sudah dibuat berdasarkan opsi CLI pada Python terlampir. ### File * [Download paket lengkap ZIP](sandbox:/mnt/data/pdf_batch_converter.zip) * [Download shell s..."

New page

Shell script sudah dibuat berdasarkan opsi CLI pada Python terlampir.

### File

* [Download paket lengkap ZIP](sandbox:/mnt/data/pdf_batch_converter.zip)
* [Download shell script](sandbox:/mnt/data/batch_pdf_to_md.sh)
* [Download Python script dengan nama sederhana](sandbox:/mnt/data/pdf_to_rag_md.py)

### Instalasi

Letakkan `batch_pdf_to_md.sh` dan `pdf_to_rag_md.py` dalam folder yang sama:

```bash
chmod +x batch_pdf_to_md.sh
chmod +x pdf_to_rag_md.py

python3 -m pip install pymupdf pyyaml
```

### Menjalankan

Output otomatis ditempatkan di subfolder `output`:

```bash
./batch_pdf_to_md.sh /opt/ai-stack/documents
```

Dengan folder output khusus:

```bash
./batch_pdf_to_md.sh \
/opt/ai-stack/documents \
/opt/ai-stack/output
```

Atau menentukan lokasi Python script secara eksplisit:

```bash
./batch_pdf_to_md.sh \
/opt/ai-stack/documents \
/opt/ai-stack/output \
/opt/scripts/pdf_to_rag_md.py
```

Script akan:

1. Menampilkan semua file dalam path input.
2. Mencari seluruh PDF secara rekursif, termasuk subfolder.
3. Menjalankan Python converter untuk setiap PDF.
4. Membuat folder output terpisah untuk setiap PDF agar `manifest.json` tidak saling menimpa.
5. Membuat `batch_conversion.log`.
6. Membuat `batch_summary.tsv` berisi status berhasil atau gagal.

Contoh hasil:

```text
/opt/ai-stack/output/
├── Buku Pertama/
│ ├── Buku Pertama 01 Topik.md
│ ├── Buku Pertama 02 Topik.md
│ └── manifest.json
├── AI/
│ └── Buku Kedua/
│ ├── Buku Kedua 01 Topik.md
│ └── manifest.json
├── batch_conversion.log
└── batch_summary.tsv
```

Shell script tersebut sudah diuji dengan beberapa PDF, nama file yang mengandung spasi, dan PDF di dalam subfolder.

LLM

Onnowpurbo — Sun, 26 Jul 2026 01:44:11 GMT

MCP

Pdf to rag md.py

Onnowpurbo — Fri, 24 Jul 2026 21:03:25 GMT

Created page with "<pre> #!/usr/bin/env python3 """ Convert a text-based PDF into RAG-friendly Markdown files, one file per topic. Main features ------------- - Uses the PDF table of contents w..."

Show changes

Requirements-pdf-to-rag-md.txt

Onnowpurbo — Fri, 24 Jul 2026 20:57:25 GMT

Created page with " pymupdf>=1.26,<2 pyyaml>=6,<7"

New page

pymupdf>=1.26,<2
pyyaml>=6,<7

RAG: PDF to md

Onnowpurbo — Fri, 24 Jul 2026 20:56:52 GMT

RAG: PDF to md

Onnowpurbo — Fri, 24 Jul 2026 20:54:35 GMT

Created page with "## File Python * [Unduh `pdf_to_rag_md.py`](sandbox:/mnt/data/pdf_to_rag_md.py) * [Unduh `requirements-pdf-to-rag-md.txt`](sandbox:/mnt/data/requirements-pdf-to-rag-md.txt)..."

New page

## File Python

* [Unduh `pdf_to_rag_md.py`](sandbox:/mnt/data/pdf_to_rag_md.py)
* [Unduh `requirements-pdf-to-rag-md.txt`](sandbox:/mnt/data/requirements-pdf-to-rag-md.txt)

Skrip sudah diperiksa dengan `py_compile` dan diuji pada:

* PDF dengan bookmark dan struktur heading.
* PDF tanpa heading, menggunakan fallback setiap lima halaman.

## Instalasi

```bash
mkdir -p ~/Apps/pdf-to-rag
cd ~/Apps/pdf-to-rag

python3 -m venv .venv
source .venv/bin/activate

pip install --upgrade pip
pip install -r requirements-pdf-to-rag-md.txt
```

## Menjalankan

```bash
python pdf_to_rag_md.py "Judul Buku.pdf"
```

Menentukan folder output:

```bash
python pdf_to_rag_md.py "Judul Buku.pdf" \
--output-dir hasil-rag
```

Menambahkan tag metadata:

```bash
python pdf_to_rag_md.py "Judul Buku.pdf" \
--tags "RAG,AI,LLM,dokumentasi"
```

Jika folder output sudah ada:

```bash
python pdf_to_rag_md.py "Judul Buku.pdf" \
--overwrite
```

## Format filename

Untuk PDF yang memiliki heading:

```text
Judul Buku 01 BAB 1 Pendahuluan.md
Judul Buku 02 1.1 Latar Belakang.md
Judul Buku 03 1.2 Tujuan.md
Judul Buku 04 BAB 2 Metode.md
```

Jika PDF tidak memiliki heading, otomatis fallback per lima halaman:

```text
Judul Buku 01 Bagian Halaman 1-5.md
Judul Buku 02 Bagian Halaman 6-10.md
Judul Buku 03 Bagian Halaman 11-15.md
```

Judul buku diambil secara berurutan dari:

1. Metadata title PDF.
2. Teks judul dengan font terbesar pada halaman awal.
3. Nama file PDF.

## Konten yang dibuang

Secara default, skrip membuang:

* Gambar dan blok nonteks.
* Caption `Gambar`, `Figure`, atau `Fig`.
* Baris `Sumber:` dan `Source:` pada caption.
* Nomor halaman.
* Header dan footer berulang.
* Footnote yang terdeteksi di bagian bawah halaman.
* Daftar isi.
* Daftar gambar dan daftar tabel.
* Daftar istilah dan glosarium.
* Daftar singkatan, simbol, dan nomenklatur.
* Indeks.
* Daftar pustaka, bibliography, dan references.
* Kata pengantar, prakata, dan foreword.
* Ucapan terima kasih.
* Tentang penulis.
* Halaman sampul dan copyright yang terdeteksi.
* Karakter tersembunyi, soft hyphen, dan spasi berlebihan.

## Metadata pada setiap file Markdown

Setiap file memiliki YAML front matter seperti:

```yaml
---
schema_version: '1.0'
document_id: pdf-914f553ce7c36f8704e4
topic_id: pdf-914f553ce7c36f8704e4-topic-0001
chunk_id: pdf-914f553ce7c36f8704e4-topic-0001

book_title: Buku Uji RAG
title: BAB 1 Pendahuluan
topic: BAB 1 Pendahuluan
topic_index: 1

language: id
tags:
- RAG
- AI

source:
file: Buku Uji RAG.pdf
sha256: 914f553ce7c36f8704e412b1fcb51b90
page_start: 3
page_end: 8
pages:
- 3
- 4
- 5
- 6
- 7
- 8
trace: Buku Uji RAG.pdf#page=3-8
pdf_title: Buku Uji RAG
pdf_author: Nama Penulis

rag:
unit: topic
filename_pattern: Judul Buku 00 Topik.md
topic_detection: pdf_toc
word_count: 1450
character_count: 9860
content_sha256: 76a95b85fe3c9e48882c351138aa5f86
suggested_splitter: markdown_headers_then_token_window

extraction:
engine: PyMuPDF
images: ignored
figure_captions: removed
junk_sections: removed
standalone_page_number_filter: enabled
footnote_filter: bottom_position_and_small_font

output_file: Buku Uji RAG 01 BAB 1 Pendahuluan.md
generated_at: '2026-07-25T03:00:00+00:00'
---
```

Skrip juga menghasilkan:

```text
manifest.json
```

Manifest berisi daftar semua topik, filename, rentang halaman, metode pendeteksian topik, hash dokumen, dan halaman nonkonten yang dibuang.

PDF hasil scan yang tidak memiliki selectable text harus menjalani OCR terlebih dahulu.

RAG

Onnowpurbo — Fri, 24 Jul 2026 20:53:52 GMT

Created page with " ==Pranala Menarik== * RAG: PDF to md"

New page

==Pranala Menarik==

* [[RAG: PDF to md]]

MCP: Instalasi

Onnowpurbo — Fri, 24 Jul 2026 09:56:10 GMT

Created page with "# PANDUAN INSTALASI LOCAL AI STACK BERBASIS DOCKER ## Ollama + Open WebUI + AnythingLLM + MCP + n8n **Perangkat:** ```text Laptop : Dell RAM : 16 GB GPU..."

Show changes

LLM

Onnowpurbo — Fri, 24 Jul 2026 03:47:33 GMT

ComfyUI

ComfyUI: Text to Speech

Onnowpurbo — Fri, 24 Jul 2026 02:38:57 GMT

Show changes

ComfyUI: Text to Speech

Onnowpurbo — Thu, 23 Jul 2026 23:43:35 GMT

Created page with "Saya sudah membuat workflow **Text-to-Speech Bahasa Indonesia** paling sederhana: [Download workflow JSON ComfyUI TTS Indonesia](sandbox:/mnt/data/comfyui_tts_bahasa_indonesi..."

New page

Saya sudah membuat workflow **Text-to-Speech Bahasa Indonesia** paling sederhana:

[Download workflow JSON ComfyUI TTS Indonesia](sandbox:/mnt/data/comfyui_tts_bahasa_indonesia_sederhana.json)

Workflow hanya menggunakan dua node:

```text
Edge TTS → Save Audio
```

Node menggunakan suara perempuan Indonesia **Gadis**, kecepatan normal, dan menyimpan hasil sebagai WAV. Custom node tersebut juga menyediakan suara laki-laki Indonesia **Ardi**, serta pengaturan kecepatan dan tinggi nada. ([GitHub][1])

## 1. Instal custom node

Pada server:

```bash
cd /opt/ai-stack
```

Jalankan:

```bash
docker compose exec -u root comfyui bash -lc '
set -e

cd /opt/ComfyUI/custom_nodes

if [ ! -d ComfyUI-EdgeTTS ]; then
git clone https://github.com/1038lab/ComfyUI-EdgeTTS.git
fi

python -m pip install --no-cache-dir \
-r ComfyUI-EdgeTTS/requirements.txt
'
```

Kemudian restart:

```bash
docker compose restart comfyui
```

Repositori resminya memang mengarahkan instalasi ke folder `custom_nodes`, dilanjutkan dengan pemasangan `requirements.txt`. ([GitHub][2])

Periksa apakah berhasil:

```bash
docker compose logs --tail=100 comfyui
```

Cari apakah node berikut berhasil dimuat:

```text
EdgeTTS
Save_Audio
```

## 2. Upload workflow

Buka:

```text
http://192.168.0.230:8188
```

Kemudian seret file berikut ke canvas ComfyUI:

```text
comfyui_tts_bahasa_indonesia_sederhana.json
```

Workflow JSON merupakan format resmi untuk menyimpan graph, node, widget, dan hubungan antar-node ComfyUI. ([ComfyUI][3])

## 3. Jalankan TTS

Pada node **Edge TTS**, ubah teks:

```text
Halo, selamat datang. Ini adalah contoh text to speech sederhana dalam Bahasa Indonesia menggunakan ComfyUI.
```

Suara default:

```text
[Indonesian] id-ID Gadis
```

Untuk suara laki-laki, pilih:

```text
[Indonesian] id-ID Ardi
```

Lalu tekan:

```text
Ctrl + Enter
```

atau klik **Queue**.

## 4. Lokasi hasil

File akan tersimpan sebagai:

```text
/opt/ComfyUI/output/TTS/indonesia-0001.wav
```

Nomor akan bertambah otomatis:

```text
indonesia-0002.wav
indonesia-0003.wav
indonesia-0004.wav
```

Node `Save_Audio` memang menyimpan keluaran di direktori output ComfyUI dan memberikan nomor urut ketika opsi overwrite dimatikan. ([GitHub][4])

**Catatan:** workflow ini menggunakan layanan Microsoft Edge TTS secara online, sehingga container ComfyUI memerlukan akses internet ketika menghasilkan suara. Tidak memerlukan API key. ([GitHub][5])

[1]: https://github.com/1038lab/ComfyUI-EdgeTTS/blob/main/ailab_edgeTTS.py "ComfyUI-EdgeTTS/ailab_edgeTTS.py at main · 1038lab/ComfyUI-EdgeTTS · GitHub"
[2]: https://github.com/1038lab/ComfyUI-EdgeTTS "GitHub - 1038lab/ComfyUI-EdgeTTS: ComfyUI-EdgeTTS is a powerful text-to-speech node for ComfyUI, leveraging Microsoft's Edge TTS capabilities. It enables seamless conversion of text into natural-sounding speech, supporting multiple languages and voices. Ideal for enhancing user interactions, this node is easy to integrate and customize, making it perfect for various applications. · GitHub"
[3]: https://docs.comfy.org/specs/workflow_json_0.4?utm_source=chatgpt.com "Workflow JSON 0.4 - ComfyUI"
[4]: https://github.com/1038lab/ComfyUI-EdgeTTS/blob/main/ailab_audio.py "ComfyUI-EdgeTTS/ailab_audio.py at main · 1038lab/ComfyUI-EdgeTTS · GitHub"
[5]: https://github.com/rany2/edge-tts?utm_source=chatgpt.com "GitHub - rany2/edge-tts: Use Microsoft Edge's online text-to-speech service from Python WITHOUT needing Microsoft Edge or Windows or an API key · GitHub"

LLM

Onnowpurbo — Thu, 23 Jul 2026 23:43:30 GMT

ComfyUI

LLM: Ubuntu 26.04 server Ollama GPU + Open-WebUI + n8n + WAHA + ComfyUI docker

Onnowpurbo — Thu, 23 Jul 2026 18:10:39 GMT

Created page with "# Instalasi AI Stack di Ubuntu Server 26.04 Target perangkat: * Laptop Dell * NVIDIA GeForce RTX 4060 Laptop GPU 8 GB * Ubuntu Server 26.04 * Docker Engine + Docker Compose..."

New page

# Instalasi AI Stack di Ubuntu Server 26.04

Target perangkat:

* Laptop Dell
* NVIDIA GeForce RTX 4060 Laptop GPU 8 GB
* Ubuntu Server 26.04
* Docker Engine + Docker Compose
* Ollama memakai GPU
* ComfyUI memakai GPU
* Open WebUI **tanpa GPU**
* n8n tanpa GPU
* WAHA tanpa GPU

Karena bagian “gunakan folder awal …” belum lengkap, panduan ini memakai:

```text
/opt/ai-stack
```

Docker secara resmi sudah mencantumkan Ubuntu 26.04 LTS sebagai sistem yang didukung. ([Docker Documentation][1])

---

## 1. Arsitektur akhir

```text
/opt/ai-stack/
├── .env
├── compose.yaml
├── ollama/
├── open-webui/
├── n8n/
├── waha/
│ ├── .env
│ ├── sessions/
│ └── media/
└── comfyui/
├── Dockerfile
├── models/
│ ├── checkpoints/
│ ├── vae/
│ ├── loras/
│ ├── clip/
│ ├── controlnet/
│ └── upscale_models/
├── input/
├── output/
├── custom_nodes/
└── user/
```

Port yang digunakan:

| Aplikasi | Port | Alamat |
| ---------- | ----: | ----------------------------------- |
| Open WebUI | 3000 | `http://IP-SERVER:3000` |
| n8n | 5678 | `http://IP-SERVER:5678` |
| WAHA | 3001 | `http://IP-SERVER:3001/dashboard` |
| ComfyUI | 8188 | `http://IP-SERVER:8188` |
| Ollama | 11434 | Hanya localhost dan jaringan Docker |

---

# BAGIAN A — PERSIAPAN UBUNTU

## 2. Update Ubuntu Server

Masuk melalui terminal atau SSH, kemudian jalankan:

```bash
sudo apt update
sudo apt full-upgrade -y
```

Instal paket dasar:

```bash
sudo apt install -y \
ca-certificates \
curl \
gnupg \
git \
openssl \
ubuntu-drivers-common \
ufw
```

Reboot:

```bash
sudo reboot
```

Setelah server hidup kembali, login lagi melalui SSH.

---

# BAGIAN B — DRIVER NVIDIA RTX 4060

## 3. Pastikan GPU terdeteksi

```bash
lspci | grep -i nvidia
```

Contoh hasil:

```text
NVIDIA Corporation AD107M [GeForce RTX 4060 Max-Q / Mobile]
```

Lihat driver yang tersedia:

```bash
sudo ubuntu-drivers list --gpgpu
```

Untuk server AI/headless, instal driver komputasi yang direkomendasikan otomatis:

```bash
sudo ubuntu-drivers install --gpgpu
```

Ubuntu merekomendasikan `ubuntu-drivers` karena alat ini memilih paket driver yang sesuai dan mendukung penggunaan Secure Boot melalui modul yang ditandatangani. ([Ubuntu][2])

Reboot:

```bash
sudo reboot
```

---

## 4. Periksa driver NVIDIA

Setelah login kembali:

```bash
nvidia-smi
```

Hasil yang benar kurang lebih seperti:

```text
NVIDIA-SMI ...
Driver Version: ...
CUDA Version: ...
NVIDIA GeForce RTX 4060 Laptop GPU
```

Jangan lanjut ke instalasi Docker GPU sebelum `nvidia-smi` berhasil.

Apabila muncul:

```text
NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver
```

Periksa Secure Boot:

```bash
mokutil --sb-state
```

Pada beberapa laptop, Secure Boot harus dinonaktifkan melalui BIOS atau kunci MOK driver harus dikonfirmasi ketika boot.

---

# BAGIAN C — INSTALASI DOCKER

## 5. Hapus paket Docker lama yang mungkin konflik

```bash
for pkg in \
docker.io \
docker-doc \
docker-compose \
docker-compose-v2 \
podman-docker \
containerd \
runc
do
sudo apt remove -y "$pkg" 2>/dev/null || true
done
```

Docker menyarankan menghapus paket distribusi yang dapat bertabrakan dengan Docker Engine resmi. ([Docker Documentation][1])

---

## 6. Tambahkan repository resmi Docker

Buat direktori keyring:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
```

Ambil kunci resmi Docker:

```bash
sudo curl -fsSL \
https://download.docker.com/linux/ubuntu/gpg \
-o /etc/apt/keyrings/docker.asc
```

Atur agar kunci dapat dibaca APT:

```bash
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

Tambahkan repository Docker:

```bash
sudo tee /etc/apt/sources.list.d/docker.sources >/dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Update repository:

```bash
sudo apt update
```

---

## 7. Instal Docker Engine dan Docker Compose

```bash
sudo apt install -y \
docker-ce \
docker-ce-cli \
containerd.io \
docker-buildx-plugin \
docker-compose-plugin
```

Aktifkan Docker saat boot:

```bash
sudo systemctl enable --now docker
```

Periksa status:

```bash
sudo systemctl status docker --no-pager
```

Uji Docker:

```bash
sudo docker run --rm hello-world
```

---

## 8. Izinkan user menjalankan Docker tanpa sudo

```bash
sudo usermod -aG docker "$USER"
```

Arti opsi:

* `-a` berarti menambahkan user tanpa menghapus grup yang sudah dimiliki.
* `-G docker` berarti menambahkan user ke grup Docker.

Logout dari SSH:

```bash
exit
```

Login kembali, kemudian periksa:

```bash
docker version
docker compose version
```

Uji kembali tanpa `sudo`:

```bash
docker run --rm hello-world
```

---

# BAGIAN D — NVIDIA CONTAINER TOOLKIT

## 9. Tambahkan repository NVIDIA Container Toolkit

```bash
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
| sudo gpg --dearmor \
-o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
```

Tambahkan repository:

```bash
curl -fsSL \
https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
| sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
| sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
```

Update APT:

```bash
sudo apt update
```

Instal NVIDIA Container Toolkit:

```bash
sudo apt install -y nvidia-container-toolkit
```

Konfigurasikan Docker agar mengenali NVIDIA Runtime:

```bash
sudo nvidia-ctk runtime configure --runtime=docker
```

Restart Docker:

```bash
sudo systemctl restart docker
```

Langkah tersebut mengikuti prosedur NVIDIA untuk mengaktifkan GPU di dalam container Docker. ([NVIDIA Docs][3])

---

## 10. Uji GPU dari dalam Docker

```bash
docker run --rm --gpus all ubuntu:24.04 nvidia-smi
```

Pastikan RTX 4060 muncul di hasil perintah.

Ollama juga menyarankan pengujian GPU Docker sebelum mencoba menjalankan model. Ollama membutuhkan NVIDIA Container Toolkit untuk akselerasi NVIDIA di Docker. ([Ollama][4])

---

# BAGIAN E — MEMBUAT STRUKTUR FOLDER

## 11. Buat folder utama

```bash
sudo mkdir -p /opt/ai-stack
sudo chown -R "$USER":"$USER" /opt/ai-stack
cd /opt/ai-stack
```

Buat folder data:

```bash
mkdir -p \
ollama \
open-webui \
n8n \
waha/sessions \
waha/media \
comfyui/input \
comfyui/output \
comfyui/custom_nodes \
comfyui/user
```

Buat folder model ComfyUI:

```bash
mkdir -p \
comfyui/models/checkpoints \
comfyui/models/vae \
comfyui/models/loras \
comfyui/models/clip \
comfyui/models/controlnet \
comfyui/models/upscale_models
```

Atur kepemilikan folder n8n. Container resmi n8n berjalan dengan UID `1000`:

```bash
sudo chown -R 1000:1000 /opt/ai-stack/n8n
```

Lihat struktur:

```bash
find /opt/ai-stack -maxdepth 3 -type d | sort
```

---

# BAGIAN F — KONFIGURASI RAHASIA

## 12. Cari IP server

```bash
SERVER_IP=$(ip route get 1.1.1.1 | awk '{print $7; exit}')
echo "$SERVER_IP"
```

Periksa juga dengan:

```bash
hostname -I
```

Apabila ada beberapa IP, gunakan IP LAN yang dipakai komputer lain untuk mengakses server.

---

## 13. Buat file `.env` utama

Pastikan sedang di:

```bash
cd /opt/ai-stack
```

Buat konfigurasi:

```bash
SERVER_IP=$(ip route get 1.1.1.1 | awk '{print $7; exit}')

cat > .env <<EOF
SERVER_IP=${SERVER_IP}
WEBUI_SECRET_KEY=$(openssl rand -hex 32)
N8N_ENCRYPTION_KEY=$(openssl rand -hex 32)
EOF
```

Amankan file:

```bash
chmod 600 .env
```

Periksa:

```bash
cat .env
```

Contoh:

```text
SERVER_IP=192.168.0.100
WEBUI_SECRET_KEY=...
N8N_ENCRYPTION_KEY=...
```

---

# BAGIAN G — KONFIGURASI WAHA

## 14. Generate konfigurasi WAHA

WAHA menyediakan perintah `init-waha` untuk membuat username, password dashboard, dan API key secara acak. ([GitHub][5])

Jalankan:

```bash
cd /opt/ai-stack

docker run --rm \
-v "$PWD/waha:/app/env" \
devlikeapro/waha:latest \
init-waha /app/env
```

Periksa file:

```bash
cat waha/.env
```

Biasanya terdapat variabel seperti:

```text
WAHA_API_KEY=...
WAHA_DASHBOARD_USERNAME=...
WAHA_DASHBOARD_PASSWORD=...
```

Amankan:

```bash
chmod 600 waha/.env
```

Atur alamat eksternal WAHA agar menggunakan port host `3001`:

```bash
SERVER_IP=$(grep '^SERVER_IP=' .env | cut -d= -f2)

if grep -q '^WAHA_BASE_URL=' waha/.env; then
sed -i \
"s#^WAHA_BASE_URL=.*#WAHA_BASE_URL=http://${SERVER_IP}:3001#" \
waha/.env
else
echo "WAHA_BASE_URL=http://${SERVER_IP}:3001" >> waha/.env
fi
```

Periksa:

```bash
grep -E 'WAHA_BASE_URL|WAHA_DASHBOARD_USERNAME|WAHA_API_KEY' waha/.env
```

WAHA menyimpan sesi pada `/app/.sessions` dan media pada `/app/.media`; kedua lokasi ini akan dipetakan ke folder host agar tidak hilang saat container dibuat ulang. ([GitHub][6])

---

# BAGIAN H — DOCKERFILE COMFYUI

## 15. Buat Dockerfile ComfyUI

Panduan ini membangun image dari repository resmi ComfyUI dan memasang PyTorch CUDA. Repository resmi ComfyUI berada di organisasi Comfy-Org. ([GitHub][7])

Buat file:

```bash
cd /opt/ai-stack

cat > comfyui/Dockerfile <<'EOF'
FROM nvidia/cuda:12.8.1-cudnn-runtime-ubuntu24.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PIP_NO_CACHE_DIR=1
ENV PYTHONUNBUFFERED=1
ENV PATH="/opt/venv/bin:${PATH}"

RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
git \
curl \
ffmpeg \
build-essential \
python3 \
python3-dev \
python3-pip \
python3-venv \
libgl1 \
libglib2.0-0 \
libsm6 \
libxext6 \
&& rm -rf /var/lib/apt/lists/*

RUN python3 -m venv /opt/venv \
&& pip install --upgrade pip setuptools wheel

WORKDIR /opt

RUN git clone --depth 1 \
https://github.com/Comfy-Org/ComfyUI.git \
/opt/ComfyUI

WORKDIR /opt/ComfyUI

RUN pip install \
torch \
torchvision \
torchaudio \
--index-url https://download.pytorch.org/whl/cu128

RUN pip install -r requirements.txt

EXPOSE 8188

CMD ["python", "main.py", \
"--listen", "0.0.0.0", \
"--port", "8188", \
"--preview-method", "auto"]
EOF
```

PyTorch menyediakan paket CUDA untuk Linux melalui indeks wheel CUDA yang sesuai. ([PyTorch Documentation][8])

---

# BAGIAN I — DOCKER COMPOSE

## 16. Buat file `compose.yaml`

```bash
cd /opt/ai-stack

cat > compose.yaml <<'EOF'
name: ai-stack

services:

ollama:
image: ollama/ollama:latest
container_name: ollama
restart: unless-stopped

ports:
- "127.0.0.1:11434:11434"

volumes:
- ./ollama:/root/.ollama

environment:
OLLAMA_HOST: "0.0.0.0:11434"

# Lepaskan model dari VRAM setelah tidak digunakan.
OLLAMA_KEEP_ALIVE: "5m"

# RTX 4060 Laptop hanya memiliki VRAM 8 GB.
OLLAMA_MAX_LOADED_MODELS: "1"
OLLAMA_NUM_PARALLEL: "1"

deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities:
- gpu

networks:
- ai-net

open-webui:
image: ghcr.io/open-webui/open-webui:main
container_name: open-webui
restart: unless-stopped

depends_on:
- ollama

ports:
- "3000:8080"

volumes:
- ./open-webui:/app/backend/data

environment:
OLLAMA_BASE_URL: "http://ollama:11434"
WEBUI_SECRET_KEY: "${WEBUI_SECRET_KEY}"
TZ: "Asia/Jakarta"

networks:
- ai-net

n8n:
image: docker.n8n.io/n8nio/n8n:latest
container_name: n8n
restart: unless-stopped

ports:
- "5678:5678"

volumes:
- ./n8n:/home/node/.n8n

environment:
N8N_HOST: "${SERVER_IP}"
N8N_PORT: "5678"
N8N_PROTOCOL: "http"

N8N_EDITOR_BASE_URL: "http://${SERVER_IP}:5678/"
WEBHOOK_URL: "http://${SERVER_IP}:5678/"

N8N_ENCRYPTION_KEY: "${N8N_ENCRYPTION_KEY}"

# Diperlukan karena akses masih menggunakan HTTP lokal.
# Ubah menjadi true setelah memakai HTTPS.
N8N_SECURE_COOKIE: "false"

N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS: "true"
N8N_DIAGNOSTICS_ENABLED: "false"
N8N_PERSONALIZATION_ENABLED: "false"

GENERIC_TIMEZONE: "Asia/Jakarta"
TZ: "Asia/Jakarta"

networks:
- ai-net

waha:
image: devlikeapro/waha:latest
container_name: waha
restart: unless-stopped

ports:
- "3001:3000"

env_file:
- ./waha/.env

volumes:
- ./waha/sessions:/app/.sessions
- ./waha/media:/app/.media

networks:
- ai-net

comfyui:
build:
context: ./comfyui
dockerfile: Dockerfile

image: local/comfyui:cu128
container_name: comfyui
restart: unless-stopped

ports:
- "8188:8188"

volumes:
- ./comfyui/models:/opt/ComfyUI/models
- ./comfyui/input:/opt/ComfyUI/input
- ./comfyui/output:/opt/ComfyUI/output
- ./comfyui/custom_nodes:/opt/ComfyUI/custom_nodes
- ./comfyui/user:/opt/ComfyUI/user

shm_size: "4gb"

deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities:
- gpu

networks:
- ai-net

networks:
ai-net:
name: ai-net
EOF
```

Konfigurasi tersebut memastikan:

* Ollama memperoleh akses GPU.
* ComfyUI memperoleh akses GPU.
* Open WebUI memakai image `main`, bukan image `cuda`.
* Open WebUI tidak mendapat reservasi perangkat GPU.
* n8n dan WAHA tidak mendapat reservasi perangkat GPU.
* Semua aplikasi dapat berkomunikasi melalui jaringan `ai-net`.

Open WebUI mendokumentasikan image `main` untuk instalasi biasa dan koneksi ke Ollama menggunakan `OLLAMA_BASE_URL`; image `cuda` hanya diperlukan bila Open WebUI sendiri membutuhkan GPU. ([Open WebUI][9])

n8n merekomendasikan Docker untuk sebagian besar instalasi self-hosted karena dependensi aplikasi dapat diisolasi dari sistem operasi. ([n8n Documentation][10])

---

## 17. Validasi Docker Compose

```bash
cd /opt/ai-stack
docker compose config
```

Apabila tidak muncul pesan error, konfigurasi YAML valid.

---

# BAGIAN J — MENJALANKAN STACK

## 18. Download image aplikasi

```bash
docker compose pull
```

Perintah ini menarik image:

* Ollama
* Open WebUI
* n8n
* WAHA

ComfyUI akan dibangun secara lokal.

---

## 19. Build ComfyUI

```bash
docker compose build --pull comfyui
```

Periksa image yang dibuat:

```bash
docker images | grep comfyui
```

Hasil yang diharapkan:

```text
local/comfyui cu128
```

---

## 20. Jalankan semua aplikasi

```bash
docker compose up -d
```

Periksa container:

```bash
docker compose ps
```

Contoh:

```text
NAME STATUS
ollama Up
open-webui Up
n8n Up
waha Up
comfyui Up
```

---

## 21. Periksa log

Semua aplikasi:

```bash
docker compose logs --tail=100
```

Ollama:

```bash
docker compose logs --tail=100 ollama
```

Open WebUI:

```bash
docker compose logs --tail=100 open-webui
```

n8n:

```bash
docker compose logs --tail=100 n8n
```

WAHA:

```bash
docker compose logs --tail=100 waha
```

ComfyUI:

```bash
docker compose logs --tail=100 comfyui
```

Untuk melihat log secara langsung:

```bash
docker compose logs -f comfyui
```

Tekan `Ctrl+C` untuk keluar dari tampilan log. Container tetap berjalan.

---

# BAGIAN K — PENGUJIAN

## 22. Uji Ollama

Periksa API:

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

Periksa GPU dari container Ollama:

```bash
docker exec ollama nvidia-smi
```

Download contoh model ringan:

```bash
docker exec -it ollama ollama pull llama3.2:3b
```

Jalankan model:

```bash
docker exec -it ollama ollama run llama3.2:3b
```

Ollama mendokumentasikan penggunaan container resmi `ollama/ollama`, akses GPU NVIDIA, dan perintah `docker exec ... ollama run`. ([Ollama][11])

Keluar dari chat Ollama dengan:

```text
/bye
```

Periksa model:

```bash
docker exec ollama ollama list
```

---

## 23. Buka Open WebUI

Dari komputer lain pada jaringan yang sama:

```text
http://IP-SERVER:3000
```

Contoh:

```text
http://192.168.0.100:3000
```

Akun pertama yang dibuat akan menjadi administrator.

Open WebUI sudah diarahkan ke:

```text
http://ollama:11434
```

Jadi tidak perlu memasukkan alamat Ollama secara manual.

---

## 24. Buka n8n

```text
http://IP-SERVER:5678
```

Contoh:

```text
http://192.168.0.100:5678
```

Buat akun administrator n8n melalui halaman awal.

Dari node HTTP Request di n8n, alamat internal yang dapat digunakan:

```text
Ollama:
http://ollama:11434

WAHA:
http://waha:3000

Open WebUI:
http://open-webui:8080
```

Contoh endpoint Ollama:

```text
http://ollama:11434/api/generate
```

Contoh endpoint WAHA:

```text
http://waha:3000/api/sendText
```

---

## 25. Buka WAHA

Dashboard:

```text
http://IP-SERVER:3001/dashboard
```

Swagger/API:

```text
http://IP-SERVER:3001
```

Lihat username dan password:

```bash
grep -E \
'WAHA_DASHBOARD_USERNAME|WAHA_DASHBOARD_PASSWORD|WAHA_API_KEY' \
/opt/ai-stack/waha/.env
```

Masuk ke dashboard, buat sesi `default`, kemudian scan QR menggunakan WhatsApp pada telepon.

WAHA menggunakan QR untuk menghubungkan sesi dan menyediakan endpoint HTTP untuk mengirim pesan. ([GitHub][5])

**Catatan penting:** WAHA merupakan klien otomatisasi tidak resmi. Dokumentasi WAHA sendiri menjelaskan bahwa WhatsApp tidak mengizinkan bot atau klien tidak resmi sehingga penggunaannya tidak sepenuhnya aman dari pemblokiran akun. Gunakan nomor pengujian atau nomor nonkritis dan jangan melakukan spam. ([WAHA][12])

---

## 26. Buka ComfyUI

```text
http://IP-SERVER:8188
```

Contoh:

```text
http://192.168.0.100:8188
```

Periksa apakah PyTorch mendeteksi GPU:

```bash
docker exec comfyui python -c \
'import torch; print("CUDA:", torch.cuda.is_available()); print("GPU:", torch.cuda.get_device_name(0) if torch.cuda.is_available() else "Tidak terdeteksi")'
```

Hasil yang benar:

```text
CUDA: True
GPU: NVIDIA GeForce RTX 4060 Laptop GPU
```

---

# BAGIAN L — MEMASUKKAN MODEL COMFYUI

## 27. Copy checkpoint Stable Diffusion

Misalnya model berada pada:

```text
~/Downloads/DreamShaper_8_pruned.safetensors
```

Copy:

```bash
cp \
~/Downloads/DreamShaper_8_pruned.safetensors \
/opt/ai-stack/comfyui/models/checkpoints/
```

Periksa:

```bash
ls -lh /opt/ai-stack/comfyui/models/checkpoints/
```

Restart ComfyUI:

```bash
cd /opt/ai-stack
docker compose restart comfyui
```

Lokasi umum model:

| Jenis | Folder |
| ---------- | -------------------------------- |
| Checkpoint | `comfyui/models/checkpoints/` |
| LoRA | `comfyui/models/loras/` |
| VAE | `comfyui/models/vae/` |
| CLIP | `comfyui/models/clip/` |
| ControlNet | `comfyui/models/controlnet/` |
| Upscaler | `comfyui/models/upscale_models/` |

---

# BAGIAN M — PENGELOLAAN GPU 8 GB

## 28. Hindari Ollama dan ComfyUI memakai VRAM berat bersamaan

RTX 4060 memiliki VRAM 8 GB. Ollama dan ComfyUI boleh hidup bersamaan, tetapi model baru memakai banyak VRAM ketika sedang dimuat.

Konfigurasi berikut sudah membantu Ollama melepaskan model setelah lima menit:

```yaml
OLLAMA_KEEP_ALIVE: "5m"
OLLAMA_MAX_LOADED_MODELS: "1"
OLLAMA_NUM_PARALLEL: "1"
```

Periksa pemakaian GPU:

```bash
watch -n 1 nvidia-smi
```

Keluar dengan:

```text
Ctrl+C
```

Apabila ComfyUI mengalami `CUDA out of memory`, hentikan Ollama sementara:

```bash
cd /opt/ai-stack
docker compose stop ollama
```

Jalankan kembali setelah selesai memakai ComfyUI:

```bash
docker compose start ollama
```

Sebaliknya, untuk memberikan GPU sepenuhnya kepada Ollama:

```bash
docker compose stop comfyui
```

Jalankan kembali ComfyUI:

```bash
docker compose start comfyui
```

---

# BAGIAN N — FIREWALL

## 29. Batasi akses hanya dari jaringan lokal

Contoh jaringan lokal:

```text
192.168.0.0/24
```

Izinkan SSH terlebih dahulu:

```bash
sudo ufw allow OpenSSH
```

Izinkan Open WebUI:

```bash
sudo ufw allow from 192.168.0.0/24 to any port 3000 proto tcp
```

Izinkan n8n:

```bash
sudo ufw allow from 192.168.0.0/24 to any port 5678 proto tcp
```

Izinkan WAHA:

```bash
sudo ufw allow from 192.168.0.0/24 to any port 3001 proto tcp
```

Izinkan ComfyUI:

```bash
sudo ufw allow from 192.168.0.0/24 to any port 8188 proto tcp
```

Aktifkan firewall:

```bash
sudo ufw enable
```

Periksa:

```bash
sudo ufw status numbered
```

Port Ollama tidak perlu dibuka karena dipetakan hanya ke:

```text
127.0.0.1:11434
```

Open WebUI dan n8n tetap dapat mengakses Ollama melalui jaringan internal Docker.

---

# BAGIAN O — PERINTAH OPERASIONAL

## 30. Start semua aplikasi

```bash
cd /opt/ai-stack
docker compose up -d
```

## 31. Stop semua aplikasi

```bash
cd /opt/ai-stack
docker compose stop
```

## 32. Start kembali

```bash
docker compose start
```

## 33. Restart semua aplikasi

```bash
docker compose restart
```

## 34. Hapus container tanpa menghapus data

```bash
docker compose down
```

Folder data tetap berada di `/opt/ai-stack`.

Jalankan kembali:

```bash
docker compose up -d
```

## 35. Periksa status

```bash
docker compose ps
```

## 36. Periksa penggunaan resource

```bash
docker stats
```

---

# BAGIAN P — UPDATE

## 37. Update Ollama, Open WebUI, n8n, dan WAHA

```bash
cd /opt/ai-stack

docker compose pull
docker compose up -d
```

Open WebUI menyarankan memakai tag versi tertentu untuk lingkungan produksi daripada selalu memakai tag bergerak seperti `main`. Setelah sistem stabil, image sebaiknya dipasangi nomor versi agar update tidak mendadak mengubah perilaku aplikasi. ([Open WebUI][9])

---

## 38. Update ComfyUI

Karena source ComfyUI diambil saat proses build:

```bash
cd /opt/ai-stack

docker compose build \
--pull \
--no-cache \
comfyui

docker compose up -d comfyui
```

Periksa:

```bash
docker compose logs --tail=100 comfyui
```

---

# BAGIAN Q — TROUBLESHOOTING

## 39. Docker tidak mendeteksi GPU

Pesan:

```text
could not select device driver "nvidia"
```

Jalankan:

```bash
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

Uji:

```bash
docker run --rm --gpus all ubuntu:24.04 nvidia-smi
```

---

## 40. n8n mengalami `permission denied`

```bash
sudo chown -R 1000:1000 /opt/ai-stack/n8n
docker compose restart n8n
```

---

## 41. Open WebUI tidak menemukan Ollama

Periksa Ollama:

```bash
docker compose ps ollama
docker compose logs --tail=100 ollama
```

Uji melalui jaringan Docker:

```bash
docker run --rm \
--network ai-net \
curlimages/curl:latest \
http://ollama:11434/api/tags
```

Periksa konfigurasi Open WebUI:

```bash
docker inspect open-webui \
--format '{{range .Config.Env}}{{println .}}{{end}}' \
| grep OLLAMA
```

Hasil yang benar:

```text
OLLAMA_BASE_URL=http://ollama:11434
```

---

## 42. ComfyUI kehabisan VRAM

Periksa:

```bash
nvidia-smi
```

Hentikan Ollama sementara:

```bash
docker compose stop ollama
docker compose restart comfyui
```

Gunakan model lebih ringan atau kurangi resolusi gambar.

---

## 43. WAHA kehilangan sesi setelah restart

Periksa pemetaan volume:

```bash
docker inspect waha \
--format '{{json .Mounts}}' \
| python3 -m json.tool
```

Pastikan terdapat:

```text
/opt/ai-stack/waha/sessions -> /app/.sessions
/opt/ai-stack/waha/media -> /app/.media
```

Periksa folder:

```bash
ls -lah /opt/ai-stack/waha/sessions
ls -lah /opt/ai-stack/waha/media
```

---

# Checklist akhir

```bash
cd /opt/ai-stack

nvidia-smi
docker version
docker compose version
docker compose ps
curl http://127.0.0.1:11434/api/tags
docker exec comfyui python -c 'import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))'
```

Hasil akhir yang diharapkan:

```text
Ollama : GPU RTX 4060
ComfyUI : GPU RTX 4060
Open WebUI : CPU, terhubung ke Ollama
n8n : CPU
WAHA : CPU
Data : tersimpan di /opt/ai-stack
Timezone : Asia/Jakarta
```

[1]: https://docs.docker.com/engine/install/ubuntu/ "Install Docker Engine on Ubuntu | Docker Docs"
[2]: https://ubuntu.com/server/docs/how-to/graphics/install-nvidia-drivers/ "NVIDIA drivers installation - Ubuntu Server documentation"
[3]: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html "Installing the NVIDIA Container Toolkit — NVIDIA Container Toolkit"
[4]: https://docs.ollama.com/troubleshooting?utm_source=chatgpt.com "Troubleshooting - Ollama"
[5]: https://github.com/devlikeapro/waha-docs/blob/main/content//docs/overview/quick-start/index.md "waha-docs/content/docs/overview/quick-start/index.md at main · devlikeapro/waha-docs · GitHub"
[6]: https://github.com/devlikeapro/waha/blob/core/docker-compose.yaml "waha/docker-compose.yaml at core · devlikeapro/waha · GitHub"
[7]: https://github.com/comfyanonymous "comfyanonymous (comfyanonymous) · GitHub"
[8]: https://docs.pytorch.org/get-started/locally/?utm_source=chatgpt.com "Start Locally | PyTorch"
[9]: https://docs.openwebui.com/getting-started/quick-start/ "Quick Start / Open WebUI"
[10]: https://docs.n8n.io/deploy/host-n8n/install-options/install-with-docker?utm_source=chatgpt.com "Install with Docker | Deploy"
[11]: https://docs.ollama.com/docker?utm_source=chatgpt.com "Docker - Ollama"
[12]: https://waha.devlike.pro/docs/overview/introduction/?utm_source=chatgpt.com "📖 Introduction | WAHA"

LLM

Onnowpurbo — Thu, 23 Jul 2026 18:10:23 GMT

Pranala Menarik

ComfyUI: Instalasi via docker compose

Onnowpurbo — Tue, 21 Jul 2026 11:39:13 GMT

Show changes

ComfyUI: Instalasi via docker compose

Onnowpurbo — Tue, 21 Jul 2026 09:17:44 GMT

Created page with "## Menambahkan ComfyUI ke Docker Compose yang sudah ada Cara yang relatif aman adalah **membangun image ComfyUI sendiri dari repositori resmi**, bukan memakai image komunitas..."

New page

## Menambahkan ComfyUI ke Docker Compose yang sudah ada

Cara yang relatif aman adalah **membangun image ComfyUI sendiri dari repositori resmi**, bukan memakai image komunitas yang isinya tidak selalu jelas. Instalasi resmi ComfyUI menggunakan repositori `Comfy-Org/ComfyUI`, memasang PyTorch dan `requirements.txt`, lalu menjalankan `main.py`. ComfyUI-Manager sekarang diaktifkan melalui `manager_requirements.txt` dan parameter `--enable-manager`. ([GitHub][1])

Struktur akhirnya:

```text
local-ai/
├── compose.yaml
└── comfyui/
├── Dockerfile
├── .dockerignore
└── data/
├── models/
├── input/
├── output/
├── custom_nodes/
├── user/
└── cache/
```

### 1. Pastikan GPU NVIDIA dapat digunakan Docker

Periksa driver:

```bash
nvidia-smi
```

Periksa NVIDIA Container Toolkit:

```bash
dpkg -l | grep nvidia-container-toolkit
```

Jika belum terpasang:

```bash
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
| sudo gpg --dearmor \
-o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
```

```bash
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
| sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' \
| sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
```

```bash
sudo apt update
sudo apt install -y nvidia-container-toolkit
```

Konfigurasikan runtime NVIDIA:

```bash
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
```

Itu adalah prosedur resmi NVIDIA untuk Debian dan Ubuntu. ([NVIDIA Docs][2])

Tes akses GPU dari container:

```bash
docker run --rm --gpus all \
nvidia/cuda:12.9.0-base-ubuntu22.04 \
nvidia-smi
```

Walaupun host memakai Ubuntu 24.04, container boleh menggunakan basis Ubuntu 22.04.

---

## 2. Buat direktori ComfyUI

Masuk ke direktori tempat `compose.yaml` berada:

```bash
cd ~/Apps/LocalAI
```

Sesuaikan apabila lokasi compose berbeda.

Buat struktur folder:

```bash
mkdir -p comfyui/data/{input,output,custom_nodes,user,cache}
```

```bash
mkdir -p comfyui/data/models/{checkpoints,vae,loras,controlnet,clip,clip_vision,diffusion_models,text_encoders,unet,upscale_models,embeddings}
```

Periksa:

```bash
find comfyui -maxdepth 3 -type d
```

---

## 3. Buat Dockerfile ComfyUI

Buat file:

```bash
nano comfyui/Dockerfile
```

Isi:

```dockerfile
FROM python:3.12-slim-bookworm

ENV DEBIAN_FRONTEND=noninteractive \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1

# Paket sistem yang diperlukan ComfyUI dan berbagai custom node.
RUN apt-get update && apt-get install -y --no-install-recommends \
git \
ca-certificates \
curl \
ffmpeg \
build-essential \
libgl1 \
libglib2.0-0 \
libgomp1 \
&& rm -rf /var/lib/apt/lists/*

WORKDIR /opt

# Mengambil ComfyUI dari repositori resmi.
RUN git clone --depth 1 https://github.com/Comfy-Org/ComfyUI.git

WORKDIR /opt/ComfyUI

# Memasang PyTorch dengan dukungan NVIDIA CUDA 12.8.
RUN python -m pip install --upgrade pip setuptools wheel \
&& python -m pip install \
torch torchvision torchaudio \
--index-url https://download.pytorch.org/whl/cu128 \
&& python -m pip install -r requirements.txt \
&& python -m pip install -r manager_requirements.txt

EXPOSE 8188

CMD ["python", "main.py", \
"--listen", "0.0.0.0", \
"--port", "8188", \
"--enable-manager", \
"--preview-method", "auto"]
```

CUDA 12.8 dipilih karena cocok untuk keluarga GPU NVIDIA modern seperti Turing, Ampere, dan Blackwell, termasuk RTX 20, RTX 30, RTX 40, dan RTX 50. PyTorch masih menyediakan wheel CUDA 12.8 secara terpisah. ([GitHub][3])

---

## 4. Buat `.dockerignore`

Ini penting agar file model yang ukurannya puluhan gigabyte tidak ikut dikirim sebagai Docker build context.

```bash
nano comfyui/.dockerignore
```

Isi:

```text
data/
__pycache__/
*.pyc
*.pyo
.git/
```

---

## 5. Tambahkan service ComfyUI ke `compose.yaml`

Tambahkan bagian berikut **setelah service `waha` tetapi sebelum bagian paling bawah `volumes:`**:

```yaml
################################
# 5. COMFYUI (Image Generation)
################################
comfyui:
build:
context: ./comfyui
dockerfile: Dockerfile
image: local/comfyui:cu128
container_name: comfyui
restart: unless-stopped

ports:
- "192.168.0.230:8188:8188"

environment:
- TZ=Asia/Jakarta
- NVIDIA_VISIBLE_DEVICES=all
- NVIDIA_DRIVER_CAPABILITIES=compute,utility

volumes:
- ./comfyui/data/models:/opt/ComfyUI/models
- ./comfyui/data/input:/opt/ComfyUI/input
- ./comfyui/data/output:/opt/ComfyUI/output
- ./comfyui/data/custom_nodes:/opt/ComfyUI/custom_nodes
- ./comfyui/data/user:/opt/ComfyUI/user
- ./comfyui/data/cache:/root/.cache

shm_size: "8gb"

deploy:
resources:
reservations:
devices:
- driver: nvidia
count: all
capabilities: ["gpu"]
```

Bagian akhir compose tetap seperti sebelumnya:

```yaml
volumes:
ollama_data:
openwebui_data:
n8n_data:
```

Tidak perlu menambahkan `comfyui_data` karena ComfyUI menggunakan bind mount ke direktori `./comfyui/data`.

Docker Compose memang mendukung reservasi GPU melalui `deploy.resources.reservations.devices`, dan `capabilities: ["gpu"]` wajib dicantumkan. ([Docker Documentation][4])

### Tentang pengaturan port

Baris ini:

```yaml
ports:
- "192.168.0.230:8188:8188"
```

berarti ComfyUI hanya mendengarkan melalui alamat LAN server `192.168.0.230`.

Apabila alamat server berbeda, ubah IP tersebut. Untuk membuka melalui seluruh interface, gunakan:

```yaml
ports:
- "8188:8188"
```

Namun ComfyUI sebaiknya tidak langsung dibuka ke internet, terutama ketika Manager aktif karena Manager dapat memasang dan menjalankan kode dari custom node.

---

## 6. Validasi YAML

Jalankan:

```bash
docker compose config
```

Jika tidak ada pesan kesalahan, build hanya service ComfyUI:

```bash
docker compose build comfyui
```

Kemudian jalankan:

```bash
docker compose up -d comfyui
```

Keterangan:

* `up` membuat dan menjalankan container.
* `-d` menjalankan container di belakang layar.
* `comfyui` berarti hanya service ComfyUI yang dijalankan.

Periksa status:

```bash
docker compose ps
```

Seharusnya terdapat:

```text
comfyui running 192.168.0.230:8188->8188/tcp
```

---

## 7. Periksa log ComfyUI

```bash
docker compose logs -f --tail=100 comfyui
```

Cari informasi seperti:

```text
Device: cuda:0
Using pytorch attention
Starting server
To see the GUI go to: http://0.0.0.0:8188
```

Tekan `Ctrl+C` untuk keluar dari tampilan log. Container tetap berjalan.

---

## 8. Verifikasi PyTorch dan GPU

Jalankan:

```bash
docker exec comfyui python -c \
'import torch; print("CUDA tersedia:", torch.cuda.is_available()); print("PyTorch:", torch.__version__); print("CUDA:", torch.version.cuda); print("GPU:", torch.cuda.get_device_name(0) if torch.cuda.is_available() else "Tidak ada")'
```

Hasil yang diharapkan:

```text
CUDA tersedia: True
PyTorch: 2.x.x
CUDA: 12.8
GPU: NVIDIA GeForce RTX ...
```

---

## 9. Buka ComfyUI

Dari komputer dalam jaringan yang sama:

```text
http://192.168.0.230:8188
```

ComfyUI tidak menyertakan checkpoint model secara otomatis. Tempatkan file model `*.safetensors` di:

```text
comfyui/data/models/checkpoints/
```

VAE ditempatkan di:

```text
comfyui/data/models/vae/
```

LoRA ditempatkan di:

```text
comfyui/data/models/loras/
```

Lokasi checkpoint dan VAE tersebut sesuai struktur model resmi ComfyUI. ([GitHub][1])

Setelah memasukkan model, restart:

```bash
docker compose restart comfyui
```

---

## 10. Perintah operasional

Menghentikan ComfyUI saja:

```bash
docker compose stop comfyui
```

Menjalankannya kembali:

```bash
docker compose start comfyui
```

Restart:

```bash
docker compose restart comfyui
```

Menghapus container tanpa menghapus model dan hasil gambar:

```bash
docker compose rm -sf comfyui
```

Membangun ulang ComfyUI versi terbaru:

```bash
docker compose build --no-cache comfyui
docker compose up -d comfyui
```

`--no-cache` memaksa Docker mengambil ulang kode dan memasang ulang dependency, bukan menggunakan layer build lama.

---

## Jika VRAM tidak cukup

Ollama dan ComfyUI memakai GPU NVIDIA yang sama. Ketika model Ollama masih berada di VRAM, ComfyUI dapat mengalami:

```text
CUDA out of memory
```

Untuk pengujian, hentikan Ollama sementara:

```bash
docker compose stop ollama
```

Jalankan ComfyUI:

```bash
docker compose restart comfyui
```

Setelah selesai membuat gambar:

```bash
docker compose start ollama
```

Terakhir, sebaiknya pindahkan `WHATSAPP_API_KEY`, password dashboard WAHA, dan password Swagger dari YAML ke file `.env`, serta ganti nilai password yang saat ini masih sederhana sebelum server dapat diakses pengguna lain.

[1]: https://github.com/comfy-org/ComfyUI "GitHub - Comfy-Org/ComfyUI: The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. · GitHub"
[2]: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/1.17.7/install-guide.html "Installing the NVIDIA Container Toolkit — NVIDIA Container Toolkit"
[3]: https://github.com/pytorch/pytorch/releases?utm_source=chatgpt.com "Releases · pytorch/pytorch"
[4]: https://docs.docker.com/compose/how-tos/gpu-support/ "Run Docker Compose services with GPU access | Docker Docs"

LLM

Onnowpurbo — Tue, 21 Jul 2026 09:13:23 GMT

ComfyUI

@@ Line 92: / Line 92: @@
 * [[MCP: Instalasi pip]]
 * [[MCP: Regenerate Vector Database untuk update content documents]]
 ==Nvidia==

@@ Line 91: / Line 91: @@
 * [[MCP: Convert PDF ke .md]]
 * [[MCP: Instalasi pip]]
 ==Nvidia==

@@ Line 90: / Line 90: @@
 * [[MCP: Instalasi]]
 * [[MCP: Convert PDF ke .md]]
 ==Nvidia==

← Older revision		Revision as of 01:44, 26 July 2026
Line 89:		Line 89:

	* [[MCP: Instalasi]]		* [[MCP: Instalasi]]
		+	* [[MCP: Convert PDF ke .md]]

	==Nvidia==		==Nvidia==

@@ Line 85: / Line 85: @@
 * [[ComfyUI: Instalasi via docker compose]]
 * [[ComfyUI: Text to Speech]]
 ==Nvidia==

@@ Line 4: / Line 4: @@
 * [Download paket lengkap ZIP](sandbox:/mnt/data/pdf_batch_converter.zip)
-* [Download shell script](sandbox:/mnt/data/batch_pdf_to_md.sh)
+* [Download shell script][[batch_pdf_to_md.sh]]
-* [Download Python script dengan nama sederhana](sandbox:/mnt/data/pdf_to_rag_md.py)
+* [Download Python script dengan nama sederhana][[pdf_to_rag_md.py]]
 ### Instalasi

@@ Line 1: / Line 1: @@
 ## File Python
-* [Unduh `pdf_to_rag_md.py`](sandbox:/mnt/data/pdf_to_rag_md.py)
+* [[pdf_to_rag_md.py]]
-* [Unduh `requirements-pdf-to-rag-md.txt`](sandbox:/mnt/data/requirements-pdf-to-rag-md.txt)
+* [[requirements-pdf-to-rag-md.txt]]
 Skrip sudah diperiksa dengan `py_compile` dan diuji pada:

@@ Line 44: / Line 44: @@
 * [[LLM: docker shell access]]
 * [[LLM: Ubuntu 26.04 server Ollama GPU + Open-WebUI + n8n + WAHA + Wazuh docker]]
 * [[LLM: Ubuntu 26.04 server Ollama GPU + Open-WebUI + n8n + WAHA + Wazuh + Webmail docker]] '''NOT RECOMMEND'''

@@ Line 82: / Line 82: @@
 * [[ComfyUI: Instalasi venv]]
 * [[ComfyUI: Instalasi venv GPU]]
 ==Nvidia==