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

Internet OFFLINE: Ubuntu 26.04 install asterisk

Onnowpurbo — Mon, 20 Jul 2026 02:41:55 GMT

Created page with "# Instalasi Asterisk Ubuntu Server 26.04 ## Extension SIP 1000–1100 Panduan berikut mengadaptasi pendekatan buku *VoIP Desa Menggunakan Asterisk*: instalasi melalui APT, p..."

New page

# Instalasi Asterisk Ubuntu Server 26.04

## Extension SIP 1000–1100

Panduan berikut mengadaptasi pendekatan buku *VoIP Desa Menggunakan Asterisk*: instalasi melalui APT, penggunaan PJSIP, dialplan lokal, firewall, pengujian, dan dokumentasi akun. Buku menggunakan struktur satu akun PJSIP yang terdiri atas **endpoint, authentication, dan AOR**, serta menyarankan server memakai alamat IP statis.

Ubuntu 26.04 LTS menyediakan paket **Asterisk 22.5.2** melalui komponen `universe`, sehingga tidak perlu melakukan kompilasi dari source code. ([Ubuntu Packages][1])

Hasil akhir:

* Asterisk aktif otomatis saat server hidup.
* SIP menggunakan PJSIP dan UDP port 5060.
* RTP menggunakan UDP port 10000–20000.
* Tersedia **101 akun**, dari 1000 sampai 1100.
* Setiap extension memiliki password acak berbeda.
* Semua extension dapat saling menelepon.
* Daftar username dan password tersimpan dalam CSV yang hanya dapat dibaca root.

---

## 1. Siapkan informasi jaringan

Contoh yang digunakan:

```text
Hostname server : asterisk-desa
IP server : 192.168.10.10
Gateway : 192.168.10.1
Jaringan LAN : 192.168.10.0/24
```

Sesuaikan dengan jaringan yang sebenarnya.

Periksa jaringan server:

```bash
ip -br addr
ip route
hostnamectl
```

Atur hostname:

```bash
sudo hostnamectl set-hostname asterisk-desa
```

Tambahkan hostname ke `/etc/hosts`:

```bash
sudo nano /etc/hosts
```

Pastikan terdapat baris:

```text
127.0.1.1 asterisk-desa
```

Server Asterisk sebaiknya menggunakan **IP statis** atau DHCP reservation agar alamat server tidak berubah.

---

## 2. Perbarui Ubuntu Server

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

Setelah server hidup kembali, masuk melalui SSH:

```bash
ssh namauser@192.168.10.10
```

Periksa versi Ubuntu:

```bash
lsb_release -a
```

atau:

```bash
cat /etc/os-release
```

---

## 3. Instal Asterisk dan perangkat bantu

Aktifkan repository `universe`:

```bash
sudo add-apt-repository universe
sudo apt update
```

Instal Asterisk:

```bash
sudo apt install -y \
asterisk \
asterisk-core-sounds-en \
ufw \
fail2ban \
sngrep \
tcpdump \
openssl
```

APT merupakan mekanisme resmi Ubuntu untuk memasang dan memelihara paket perangkat lunak. ([Ubuntu][2])

Aktifkan layanan Asterisk:

```bash
sudo systemctl enable --now asterisk
```

Periksa status:

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

Periksa versi:

```bash
sudo asterisk -rx "core show version"
```

Periksa modul PJSIP:

```bash
sudo asterisk -rx "module show like pjsip"
```

PJSIP menghubungkan sebuah endpoint dengan objek autentikasi dan AOR; endpoint harus memiliki AOR agar Asterisk mengetahui kontak tujuan panggilan. ([Asterisk Documentation][3])

---

## 4. Backup konfigurasi bawaan

Jangan langsung menghapus konfigurasi asli.

```bash
BACKUP_DIR="/root/asterisk-config-$(date +%Y%m%d-%H%M%S)"
sudo mkdir -p "$BACKUP_DIR"
sudo cp -a /etc/asterisk/. "$BACKUP_DIR/"
```

Periksa hasil backup:

```bash
sudo ls -lah "$BACKUP_DIR"
```

---

## 5. Membuat konfigurasi utama PJSIP

Buat ulang `/etc/asterisk/pjsip.conf`:

```bash
sudo tee /etc/asterisk/pjsip.conf >/dev/null <<'EOF'
;==========================================================
; Konfigurasi PJSIP Asterisk Desa
; Ubuntu Server 26.04
; Extension 1000-1100
;==========================================================

[global]
type=global
user_agent=Asterisk-Desa

;----------------------------------------------------------
; Transport SIP
;----------------------------------------------------------

[transport-udp]
type=transport
protocol=udp
bind=0.0.0.0:5060

; Apabila seluruh perangkat hanya berada di LAN,
; external_media_address dan external_signaling_address
; tidak diperlukan.

;----------------------------------------------------------
; Template endpoint
;----------------------------------------------------------

[endpoint-template](!)
type=endpoint
transport=transport-udp
context=internal
disallow=all
allow=ulaw
allow=alaw

; DTMF untuk IVR dan layanan berbasis tombol telepon
dtmf_mode=rfc4733

; Pengaturan yang membantu client Wi-Fi/NAT
direct_media=no
rtp_symmetric=yes
force_rport=yes
rewrite_contact=yes

; Jangan izinkan pemanggilan tanpa autentikasi
allow_subscribe=yes
language=en

;----------------------------------------------------------
; Template autentikasi
;----------------------------------------------------------

[auth-template](!)
type=auth
auth_type=userpass

;----------------------------------------------------------
; Template Address of Record
;----------------------------------------------------------

[aor-template](!)
type=aor

; Satu extension hanya boleh dipakai satu perangkat
max_contacts=1

; Hapus registrasi lama bila perangkat berganti alamat
remove_existing=yes

; Pemeriksaan berkala perangkat
qualify_frequency=60

;----------------------------------------------------------
; Akun extension dibuat otomatis di file berikut
;----------------------------------------------------------

#include "pjsip-extensions.conf"
EOF
```

Konfigurasi sengaja menggunakan template agar 101 extension tidak harus memiliki seluruh parameter yang ditulis berulang kali.

---

## 6. Membuat extension 1000–1100 otomatis

Buat skrip generator:

```bash
sudo tee /usr/local/sbin/generate-asterisk-extensions.sh >/dev/null <<'EOF'
#!/usr/bin/env bash

set -euo pipefail

CONFIG_FILE="/etc/asterisk/pjsip-extensions.conf"
PASSWORD_FILE="/root/asterisk-extension-passwords.csv"
TEMP_CONFIG="$(mktemp)"
TEMP_PASSWORD="$(mktemp)"

cleanup() {
rm -f "$TEMP_CONFIG" "$TEMP_PASSWORD"
}

trap cleanup EXIT

cat > "$TEMP_CONFIG" <<'HEADER'
;==========================================================
; Dibuat otomatis oleh generate-asterisk-extensions.sh
; Jangan menyimpan file password ke repository publik.
;==========================================================

HEADER

printf '%s\n' '"extension","username","password","server","transport"' \
> "$TEMP_PASSWORD"

SERVER_IP="$(hostname -I | awk '{print $1}')"

if [[ -z "$SERVER_IP" ]]; then
SERVER_IP="GANTI_DENGAN_IP_SERVER"
fi

for EXTENSION in $(seq 1000 1100); do
PASSWORD="$(openssl rand -hex 16)"

cat >> "$TEMP_CONFIG" <<EOF_CONFIG
;----------------------------------------------------------
; Extension ${EXTENSION}
;----------------------------------------------------------

[${EXTENSION}](endpoint-template)
auth=auth-${EXTENSION}
aors=aor-${EXTENSION}
callerid="Extension ${EXTENSION}" <${EXTENSION}>

[auth-${EXTENSION}](auth-template)
username=${EXTENSION}
password=${PASSWORD}

[aor-${EXTENSION}](aor-template)

EOF_CONFIG

printf '"%s","%s","%s","%s","UDP"\n' \
"$EXTENSION" \
"$EXTENSION" \
"$PASSWORD" \
"$SERVER_IP" >> "$TEMP_PASSWORD"
done

install -o root -g asterisk -m 0640 \
"$TEMP_CONFIG" "$CONFIG_FILE"

install -o root -g root -m 0600 \
"$TEMP_PASSWORD" "$PASSWORD_FILE"

echo "Berhasil membuat extension 1000 sampai 1100."
echo "Konfigurasi : $CONFIG_FILE"
echo "Password : $PASSWORD_FILE"
EOF
```

Jadikan executable:

```bash
sudo chmod 750 /usr/local/sbin/generate-asterisk-extensions.sh
```

Jalankan:

```bash
sudo /usr/local/sbin/generate-asterisk-extensions.sh
```

Periksa jumlah extension:

```bash
sudo grep -Ec '^\[[0-9]{4}\]$endpoint-template$$' \
/etc/asterisk/pjsip-extensions.conf
```

Output seharusnya:

```text
101
```

Periksa beberapa konfigurasi awal:

```bash
sudo sed -n '1,80p' /etc/asterisk/pjsip-extensions.conf
```

Lihat daftar akun:

```bash
sudo column -s, -t < /root/asterisk-extension-passwords.csv | head
```

Jangan membagikan seluruh file CSV secara terbuka karena berisi password semua pengguna.

---

## 7. Membuat dialplan panggilan

Buat `/etc/asterisk/extensions.conf`:

```bash
sudo tee /etc/asterisk/extensions.conf >/dev/null <<'EOF'
;==========================================================
; Dialplan Asterisk Desa
; Extension yang diizinkan: 1000-1100
;==========================================================

[general]
static=yes
writeprotect=no
clearglobalvars=no

[globals]
RINGTIME=30

;----------------------------------------------------------
; Panggilan internal
;----------------------------------------------------------

[internal]

; Extension 1000 sampai 1099
exten => _10XX,1,NoOp(Panggilan internal ${CALLERID(num)} ke ${EXTEN})
same => n,Dial(PJSIP/${EXTEN},${RINGTIME})
same => n,Hangup()

; Extension 1100
exten => 1100,1,NoOp(Panggilan internal ${CALLERID(num)} ke 1100)
same => n,Dial(PJSIP/1100,${RINGTIME})
same => n,Hangup()

;----------------------------------------------------------
; Nomor pengujian
;----------------------------------------------------------

; 600 - Echo test
exten => 600,1,Answer()
same => n,Wait(1)
same => n,Echo()
same => n,Hangup()

; 601 - Menyebutkan nomor extension pemanggil
exten => 601,1,Answer()
same => n,Playback(your)
same => n,Playback(extension)
same => n,SayDigits(${CALLERID(num)})
same => n,Hangup()

; Nomor tidak dikenal
exten => i,1,Playback(invalid)
same => n,Hangup()
EOF
```

Dialplan `_10XX` hanya menerima nomor 1000–1099, sementara 1100 dibuat secara eksplisit. Dengan demikian, nomor 1101 dan seterusnya tidak dapat dipanggil.

---

## 8. Memastikan rentang RTP

Periksa konfigurasi RTP:

```bash
sudo grep -Ev '^[[:space:]]*(;|$)' /etc/asterisk/rtp.conf
```

Bila belum jelas, buat konfigurasi berikut:

```bash
sudo tee /etc/asterisk/rtp.conf >/dev/null <<'EOF'
[general]
rtpstart=10000
rtpend=20000
strictrtp=yes
icesupport=yes
EOF
```

SIP dipakai untuk mengatur sesi dan registrasi, sedangkan suara dikirim melalui RTP. Konsep ini juga menjadi dasar konfigurasi pada buku.

---

## 9. Atur kepemilikan dan permission

```bash
sudo chown root:asterisk \
/etc/asterisk/pjsip.conf \
/etc/asterisk/pjsip-extensions.conf \
/etc/asterisk/extensions.conf \
/etc/asterisk/rtp.conf
```

```bash
sudo chmod 640 \
/etc/asterisk/pjsip.conf \
/etc/asterisk/pjsip-extensions.conf \
/etc/asterisk/extensions.conf \
/etc/asterisk/rtp.conf
```

Pastikan file password hanya dapat dibaca root:

```bash
sudo chmod 600 /root/asterisk-extension-passwords.csv
```

---

## 10. Validasi lalu restart Asterisk

Restart:

```bash
sudo systemctl restart asterisk
```

Periksa layanan:

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

Periksa log jika gagal:

```bash
sudo journalctl -u asterisk -n 100 --no-pager
```

Masuk CLI:

```bash
sudo asterisk -rvvv
```

Di dalam CLI, jalankan:

```text
core show version
pjsip show transports
pjsip show endpoints
dialplan show internal
```

Keluar:

```text
exit
```

Periksa jumlah endpoint dari shell:

```bash
sudo asterisk -rx "pjsip show endpoints" |
grep -E 'Endpoint: +[0-9]{4}/' |
wc -l
```

Targetnya:

```text
101
```

---

## 11. Konfigurasi firewall

Ubuntu menggunakan `ufw` sebagai perangkat firewall host yang mudah dikelola. ([Ubuntu][4])

**Sangat penting:** izinkan SSH sebelum mengaktifkan firewall agar koneksi administrator tidak terputus.

Contoh untuk LAN `192.168.10.0/24`:

```bash
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
```

Izinkan SIP hanya dari jaringan LAN:

```bash
sudo ufw allow from 192.168.10.0/24 to any port 5060 proto udp \
comment 'Asterisk SIP dari LAN'
```

Izinkan RTP hanya dari LAN:

```bash
sudo ufw allow from 192.168.10.0/24 to any port 10000:20000 proto udp \
comment 'Asterisk RTP dari LAN'
```

Aktifkan firewall:

```bash
sudo ufw enable
```

Periksa:

```bash
sudo ufw status numbered
```

Jangan membuka UDP 5060 dan 10000–20000 ke seluruh Internet kecuali benar-benar diperlukan. Untuk akses antarlokasi, pendekatan yang lebih aman adalah membawa SIP dan RTP melalui VPN seperti WireGuard. Buku juga merekomendasikan komunikasi antar-Asterisk melalui WireGuard daripada mengekspos SIP langsung ke Internet.

---

## 12. Registrasi Linphone

Ambil satu akun uji:

```bash
sudo grep '^"1000"' /root/asterisk-extension-passwords.csv
sudo grep '^"1001"' /root/asterisk-extension-passwords.csv
```

Contoh pengaturan perangkat pertama:

```text
Display name : Extension 1000
Username : 1000
Password : password dari CSV
Domain : 192.168.10.10
SIP server : sip:192.168.10.10
Transport : UDP
Port : 5060
```

Perangkat kedua:

```text
Display name : Extension 1001
Username : 1001
Password : password dari CSV
Domain : 192.168.10.10
Transport : UDP
Port : 5060
```

Pada beberapa versi Linphone, identitas SIP ditulis:

```text
sip:1000@192.168.10.10
```

Proxy/server:

```text
sip:192.168.10.10;transport=udp
```

Pastikan smartphone dan server berada dalam jaringan yang dapat saling menjangkau.

---

## 13. Pengujian

### Periksa registrasi

```bash
sudo asterisk -rx "pjsip show contacts"
```

atau:

```bash
sudo asterisk -rx "pjsip show endpoint 1000"
```

Endpoint belum terdaftar biasanya terlihat:

```text
Unavailable
```

Setelah registrasi berhasil, akan muncul alamat kontak perangkat.

### Uji panggilan

Lakukan:

```text
1000 → 1001
1001 → 1000
1000 → 1100
1100 → 1000
```

Uji juga nomor yang tidak tersedia:

```text
1101
```

Panggilan ke 1101 seharusnya ditolak karena berada di luar numbering plan.

### Uji suara

Hubungi:

```text
600
```

Bicaralah ke mikrofon. Suara seharusnya dikirim kembali melalui aplikasi `Echo()`.

### Monitor panggilan langsung

```bash
sudo asterisk -rvvv
```

Kemudian:

```text
core show channels
pjsip show contacts
```

Aktifkan SIP logger hanya ketika troubleshooting:

```text
pjsip set logger on
```

Matikan kembali setelah selesai:

```text
pjsip set logger off
```

Dokumentasi resmi Asterisk juga menyarankan pemeriksaan hubungan `auth`, endpoint, dan AOR ketika registrasi PJSIP gagal. ([Asterisk Documentation][5])

---

## 14. Troubleshooting cepat

### Asterisk tidak dapat dijalankan

```bash
sudo systemctl status asterisk
sudo journalctl -u asterisk -b --no-pager
```

Periksa konfigurasi:

```bash
sudo asterisk -rx "pjsip show endpoints"
```

### Client tidak dapat register

Periksa port:

```bash
sudo ss -lunp | grep ':5060'
```

Seharusnya terdapat proses Asterisk yang mendengarkan pada:

```text
0.0.0.0:5060
```

Periksa firewall:

```bash
sudo ufw status verbose
```

Periksa log:

```bash
sudo tail -f /var/log/asterisk/full
```

Jika `/var/log/asterisk/full` belum tersedia, gunakan:

```bash
sudo journalctl -u asterisk -f
```

### Username atau password ditolak

```bash
sudo asterisk -rx "pjsip show endpoint 1000"
sudo grep -A4 '\[auth-1000\]' \
/etc/asterisk/pjsip-extensions.conf
```

Pastikan client menggunakan username **1000**, bukan `auth-1000`.

### Telepon berdering tetapi suara tidak terdengar

Periksa:

```bash
sudo ufw status
sudo ss -lunp | grep asterisk
```

Pantau RTP:

```bash
sudo tcpdump -ni any udp portrange 10000-20000
```

Penyebab umum:

* Firewall RTP tertutup.
* Client berada pada jaringan NAT berbeda.
* Wi-Fi memiliki client isolation.
* Router memblokir komunikasi antarklien.
* Alamat server yang dimasukkan salah.

### Melihat paket SIP dengan sngrep

```bash
sudo sngrep
```

Gunakan tombol:

```text
Enter : membuka call flow
F10 : keluar
```

---

## 15. Backup setelah konfigurasi berhasil

```bash
sudo tar \
--create \
--gzip \
--preserve-permissions \
--file="/root/asterisk-ready-$(date +%Y%m%d-%H%M%S).tar.gz" \
/etc/asterisk \
/root/asterisk-extension-passwords.csv
```

Periksa:

```bash
sudo ls -lh /root/asterisk-ready-*.tar.gz
```

Backup tersebut mengandung seluruh password extension. Simpan secara terenkripsi dan jangan diletakkan di web server atau repository Git publik.

---

## 16. Checklist hasil akhir

Jalankan seluruh pemeriksaan berikut:

```bash
systemctl is-enabled asterisk
systemctl is-active asterisk
sudo asterisk -rx "core show version"
sudo asterisk -rx "pjsip show transports"
sudo asterisk -rx "pjsip show endpoints"
sudo asterisk -rx "dialplan show internal"
sudo ufw status
sudo ss -lunp | grep -E ':5060|asterisk'
```

Kondisi yang diharapkan:

```text
Asterisk service : active
Start saat boot : enabled
Transport SIP : UDP 0.0.0.0:5060
Jumlah extension : 101
Nomor pertama : 1000
Nomor terakhir : 1100
Dialplan : internal
RTP : UDP 10000-20000
Password akun : berbeda untuk setiap extension
Firewall : hanya membuka SIP/RTP dari LAN
```

Konfigurasi ini sudah cukup untuk **telepon internal 1000–1100**. Layanan lanjutan seperti voicemail, ring group, IVR, ConfBridge, paging, queue, SIP trunk, dan WireGuard dapat ditambahkan setelah registrasi serta panggilan dasar stabil.

[1]: https://packages.ubuntu.com/resolute/asterisk?utm_source=chatgpt.com "Details of package asterisk in resolute"
[2]: https://ubuntu.com/server/docs/how-to/software/package-management/?utm_source=chatgpt.com "Install and manage packages - Ubuntu Server documentation"
[3]: https://docs.asterisk.org/Configuration/Channel-Drivers/SIP/Configuring-res_pjsip/PJSIP-Configuration-Sections-and-Relationships/?utm_source=chatgpt.com "PJSIP Configuration Sections and Relationships"
[4]: https://ubuntu.com/server/docs/how-to/security/firewalls/?utm_source=chatgpt.com "Firewall - Ubuntu Server documentation"
[5]: https://docs.asterisk.org/Configuration/Channel-Drivers/SIP/Configuring-res_pjsip/Asterisk-PJSIP-Troubleshooting-Guide/?utm_source=chatgpt.com "Asterisk PJSIP Troubleshooting Guide"

Internet offline

Onnowpurbo — Mon, 20 Jul 2026 02:41:21 GMT

Ubuntu 24.04

Epub

Onnowpurbo — Tue, 14 Jul 2026 18:59:43 GMT

Membuka epub

DVWP

Onnowpurbo — Sat, 04 Jul 2026 01:21:07 GMT

DVWP

Onnowpurbo — Sat, 04 Jul 2026 01:20:56 GMT

Created page with "Ahh siap — '''DVWP = Damn Vulnerable WordPress'''. DVWP lebih realistis dibanding DVWA untuk latihan WordPress security, karena kamu belajar hal-hal yang sering muncul di p..."

New page

Ahh siap — '''DVWP = Damn Vulnerable WordPress'''.

DVWP lebih realistis dibanding DVWA untuk latihan WordPress security, karena kamu belajar hal-hal yang sering muncul di pentest WordPress sungguhan: plugin, theme, `/wp-admin`, `/wp-login.php`, `/wp-content/`, XML-RPC, plugin vulnerable, file terbuka, credential lemah, dan salah konfigurasi.

== 1. Aturan utama: jalankan hanya di lab lokal==

Gunakan DVWP hanya di lingkungan sendiri:

Kali Linux = mesin attacker / latihan
DVWP WordPress = target vulnerable
Network = localhost / host-only / private VM network

Jangan expose DVWP ke internet publik. Karena ini memang sengaja vulnerable.

== 2. Tujuan awal: pahami struktur WordPress==

Sebelum menyerang apa pun, buka websitenya manual dulu dan pahami struktur WordPress:

/wp-login.php → halaman login
/wp-admin/ → dashboard admin
/wp-content/ → tempat theme, plugin, upload
/wp-content/plugins/ → plugin yang terpasang
/wp-content/themes/ → theme yang terpasang
/xmlrpc.php → endpoint XML-RPC WordPress
/wp-json/ → REST API WordPress

Dalam pentest WordPress, banyak celah berasal dari '''plugin dan theme''', bukan hanya dari WordPress core.

== 3. Recon dasar dari Kali Linux==

Misalnya DVWP kamu jalan di:

http://127.0.0.1:31337

Mulai dari cek service:

nmap -sV -p 31337,31338 127.0.0.1

Artinya:

-sV = deteksi service dan versinya
-p = scan hanya port tertentu
127.0.0.1 = mesin lokal

Lalu cek response web:

curl -I http://127.0.0.1:31337

Artinya:

-I = hanya tampilkan HTTP header

Ini membiasakan kamu untuk mengamati dulu sebelum langsung pakai tool besar.

== 4. Gunakan WPScan, tapi jangan bergantung 100% pada tool==

WPScan adalah tool utama untuk enumerasi WordPress.

Contoh:

wpscan --url http://127.0.0.1:31337 --enumerate u,p,t

Artinya:

--url = URL target WordPress
--enumerate = minta WPScan melakukan enumerasi
u = users
p = plugins
t = themes

Alur belajar yang bagus:

1. Jalankan WPScan
2. Lihat user/plugin/theme yang ditemukan
3. Verifikasi manual lewat browser
4. Cek path plugin di /wp-content/plugins/
5. Pahami jenis vulnerability-nya
6. Baru coba eksploitasi di lab

Jangan hanya copy-paste exploit. Biasakan bertanya:

Input mana yang vulnerable?
Butuh login atau tidak?
Impact-nya apa?
Buktinya apa?
Cara fix-nya bagaimana?

== 5. Fokus latihan pada plugin==

WordPress sering vulnerable karena plugin. Jadi untuk tiap plugin, buat catatan kecil seperti ini:

Plugin:
Versi:
Vulnerability:
Butuh login? ya/tidak
Impact:
Evidence / bukti:
Cara memperbaiki:
Referensi:

Ini sangat mirip dengan cara kerja report pentest sungguhan.

== 6. Attack surface WordPress yang perlu dipahami dulu==

Prioritaskan belajar ini:

1. User enumeration
2. Weak/default credentials
3. Vulnerable plugins
4. File upload weakness
5. Directory listing / exposed files
6. XML-RPC abuse
7. REST API exposure
8. phpMyAdmin/adminer exposure
9. wp-config.php atau backup leak
10. Privilege escalation di dalam wp-admin

Penjelasan singkat:

User enumeration
mencari username yang valid di WordPress.

Weak/default credentials
login dengan password lemah atau default.

Vulnerable plugins
plugin lama atau plugin yang punya CVE.

File upload weakness
upload file berbahaya karena validasi buruk.

Directory listing
folder bisa dibuka dan isinya kelihatan.

Exposed files
file sensitif seperti backup, .sql, .zip, .bak, atau config terbuka.

XML-RPC abuse
endpoint xmlrpc.php disalahgunakan untuk brute force atau pingback abuse.

REST API exposure
informasi user/post/settings terlalu terbuka lewat /wp-json/.

phpMyAdmin/adminer exposure
panel database terbuka ke web.

wp-config.php leak
file konfigurasi WordPress bocor, bisa berisi credential database.

== 7. Tool yang bagus untuk latihan DVWP==

Tool utama dari Kali:

Browser + Burp Suite

Untuk melihat, intercept, dan memodifikasi HTTP request.

WPScan

Untuk enumerasi WordPress, plugin, theme, user, dan vulnerability.

Nmap

Untuk cek port dan service yang terbuka.

Gobuster / Feroxbuster

Untuk mencari folder atau file tersembunyi.

Nikto

Untuk cek basic web server misconfiguration.

Curl

Untuk memahami HTTP request dan response secara manual.

Searchsploit

Untuk mencari referensi exploit lokal dari Exploit-DB.

== 8. Workflow beginner yang bagus==

Pakai alur ini setiap latihan:

Step 1: Apakah target bisa diakses?
Step 2: Port/service apa yang terbuka?
Step 3: Apakah ini WordPress?
Step 4: Versi WordPress berapa?
Step 5: User apa saja yang terlihat?
Step 6: Plugin/theme apa yang terpasang?
Step 7: Apakah versi plugin/theme vulnerable?
Step 8: Exploit-nya butuh login atau tidak?
Step 9: Bisa tidak membuktikan impact dengan aman?
Step 10: Bagaimana cara memperbaikinya?

Kebiasaan ini lebih penting daripada menghafal payload.

== 9. Rencana latihan 7 hari==

Hari 1:
Install/start DVWP dan pahami struktur aplikasinya.

Hari 2:
Latihan nmap, curl, browser inspection, dan Burp Suite.

Hari 3:
Jalankan WPScan dan verifikasi user/plugin/theme secara manual.

Hari 4:
Pelajari path plugin di /wp-content/plugins/.

Hari 5:
Latihan directory discovery dan exposed file checking.

Hari 6:
Pilih satu vulnerability plugin, pelajari pelan-pelan, lalu tulis mini report.

Hari 7:
Ulangi dari awal tanpa melihat catatan.

== 10. Buat folder catatan latihan==

Bikin folder seperti ini:

mkdir -p ~/Apps/Pentest/DVWP-notes
cd ~/Apps/Pentest/DVWP-notes

touch 01-recon.md
touch 02-wordpress-structure.md
touch 03-wpscan.md
touch 04-plugins.md
touch 05-exposed-files.md
touch 06-findings-report.md
touch 99-cheatsheet.md

Isi setiap file dengan format:

Target:
Tool yang digunakan:
Command:
Arti command:
Finding:
Evidence / bukti:
Risk:
Fix:
Lesson learned:

== 11. Contoh catatan sederhana==

Target:
http://127.0.0.1:31337

Tool:
WPScan

Command:
wpscan --url http://127.0.0.1:31337 --enumerate u,p,t

Arti:
Melakukan enumerasi user, plugin, dan theme WordPress.

Finding:
Ditemukan beberapa plugin yang bisa dicek lebih lanjut.

Evidence:
Plugin terlihat di path /wp-content/plugins/.

Risk:
Jika plugin versi lama dan vulnerable, attacker bisa mengeksploitasi website.

Fix:
Update plugin, hapus plugin tidak terpakai, batasi akses admin, dan aktifkan hardening WordPress.

Lesson learned:
Dalam WordPress pentest, plugin sering menjadi sumber vulnerability utama.

== 12. Mindset penting saat latihan==

Jangan berpikir:

Payload apa yang harus aku copy-paste?

Tapi biasakan berpikir:

Data apa yang dikirim user?
Server memproses input ini sebagai apa?
Apakah input masuk ke SQL query, command, file path, upload handler, atau HTML output?
Apa buktinya input saya memengaruhi backend?
Impact-nya apa?
Cara mitigasinya apa?

Itu mindset pentester yang benar.

== 13. Batas aman==

Yang boleh dilakukan:

DVWP lokal
VM sendiri
Docker sendiri
Lab kampus/kantor yang memang diizinkan
CTF resmi

Yang jangan dilakukan:

Scan website publik tanpa izin
Brute force login asli
Coba payload ke sistem kantor tanpa scope
Upload shell ke server bukan milik sendiri
Pakai WPScan ke domain publik tanpa izin

Intinya: '''DVWP bukan hanya tempat “nge-hack WordPress”. DVWP adalah tempat belajar cara berpikir pentester WordPress: enumerasi, verifikasi, pahami impact, lalu tulis report dengan rapi.'''

DVWA

Onnowpurbo — Sat, 04 Jul 2026 01:14:00 GMT

Referensi

PM: Install Virtual Environment

Onnowpurbo — Sun, 28 Jun 2026 09:38:47 GMT

11. Cara pakai harian

PM: Install Virtual Environment

Onnowpurbo — Sun, 28 Jun 2026 09:32:04 GMT

Created page with "Berikut langkah lengkap membuat '''virtualenv PM4Py di `~/Apps/PM4Py`''' untuk *process mining*. PM4Py resmi bisa di-install dengan `pip install -U pm4py`, dan saat ini menduk..."

New page

Berikut langkah lengkap membuat '''virtualenv PM4Py di `~/Apps/PM4Py`''' untuk *process mining*. PM4Py resmi bisa di-install dengan `pip install -U pm4py`, dan saat ini mendukung Python 3.9–3.14. ([PyPI][1])

== 1. Install dependency sistem==

sudo apt update
sudo apt install -y python3 python3-venv python3-pip graphviz

Keterangan singkat:

python3-venv

dibutuhkan untuk membuat virtual environment.

graphviz

dibutuhkan agar visualisasi proses seperti Petri net, BPMN, dan *process tree* bisa digambar dengan baik.

== 2. Buat folder kerja==

mkdir -p ~/Apps/PM4Py
cd ~/Apps/PM4Py

== 3. Buat virtualenv==

python3 -m venv venv

Aktifkan:

source venv/bin/activate

Kalau berhasil, prompt terminal biasanya berubah menjadi seperti:

(venv) onno@i3:~/Apps/PM4Py$

== 4. Upgrade pip dan tools dasar==

python -m pip install --upgrade pip setuptools wheel

== 5. Install PM4Py + library pendukung

pip install -U \
pm4py \
pandas \
numpy \
matplotlib \
seaborn \
scikit-learn \
scipy \
networkx \
graphviz \
pyvis \
jupyterlab \
notebook \
ipykernel \
openpyxl \
xlsxwriter

Library utama:

| Library | Fungsi |
| | |
| `pm4py` | library utama *process mining* |
| `pandas`, `numpy` | olah data event log |
| `matplotlib`, `seaborn` | visualisasi data |
| `scikit-learn` | clustering, klasifikasi, anomaly detection |
| `networkx`, `graphviz` | graph/process visualization |
| `jupyterlab`, `notebook` | kerja lewat Jupyter |
| `openpyxl`, `xlsxwriter` | baca/tulis Excel |

== 6. Daftarkan kernel Jupyter==

python -m ipykernel install --user --name pm4py --display-name "Python PM4Py"

Nanti di Jupyter pilih kernel:

Python PM4Py

== 7. Buat file requirements.txt

cat > requirements.txt << 'EOF'
pm4py
pandas
numpy
matplotlib
seaborn
scikit-learn
scipy
networkx
graphviz
pyvis
jupyterlab
notebook
ipykernel
openpyxl
xlsxwriter
EOF

Nanti kalau mau install ulang cukup:

pip install -r requirements.txt

== 8. Test instalasi PM4Py==

Buat file test:

nano test_pm4py.py

Isi:

python
import pm4py
import pandas as pd

print("PM4Py version:", pm4py.__version__)

data = [
{"case:concept:name": "1", "concept:name": "Register", "time:timestamp": "2026-01-01 08:00:00"},
{"case:concept:name": "1", "concept:name": "Check", "time:timestamp": "2026-01-01 09:00:00"},
{"case:concept:name": "1", "concept:name": "Approve", "time:timestamp": "2026-01-01 10:00:00"},

{"case:concept:name": "2", "concept:name": "Register", "time:timestamp": "2026-01-02 08:00:00"},
{"case:concept:name": "2", "concept:name": "Check", "time:timestamp": "2026-01-02 09:00:00"},
{"case:concept:name": "2", "concept:name": "Reject", "time:timestamp": "2026-01-02 10:00:00"},
]

df = pd.DataFrame(data)
df["time:timestamp"] = pd.to_datetime(df["time:timestamp"])

print(df)

= Discover Directly-Follows Graph=

dfg, start_activities, end_activities = pm4py.discover_dfg(df)

print("\nDirectly-Follows Graph:")
print(dfg)

print("\nStart activities:")
print(start_activities)

print("\nEnd activities:")
print(end_activities)

Jalankan:

python test_pm4py.py

Kalau sukses, akan keluar versi PM4Py dan hasil *Directly-Follows Graph*.

== 9. Test lewat Jupyter Notebook==

Jalankan:

jupyter lab

Lalu buat notebook baru dengan kernel:

Python PM4Py

Cell test:

import pm4py
import pandas as pd

pm4py.__version__

Cell berikutnya:

data = [
{"case:concept:name": "1", "concept:name": "A", "time:timestamp": "2026-01-01 08:00:00"},
{"case:concept:name": "1", "concept:name": "B", "time:timestamp": "2026-01-01 09:00:00"},
{"case:concept:name": "1", "concept:name": "C", "time:timestamp": "2026-01-01 10:00:00"},
{"case:concept:name": "2", "concept:name": "A", "time:timestamp": "2026-01-02 08:00:00"},
{"case:concept:name": "2", "concept:name": "B", "time:timestamp": "2026-01-02 09:00:00"},
{"case:concept:name": "2", "concept:name": "D", "time:timestamp": "2026-01-02 10:00:00"},
]

df = pd.DataFrame(data)
df["time:timestamp"] = pd.to_datetime(df["time:timestamp"])

df

Cell process mining:

dfg, start_activities, end_activities = pm4py.discover_dfg(df)

dfg

== 10. Struktur folder yang disarankan==

mkdir -p ~/Apps/PM4Py/{data,notebooks,scripts,output}

Struktur:

~/Apps/PM4Py/
├── venv/
├── data/
├── notebooks/
├── scripts/
├── output/
├── requirements.txt
└── test_pm4py.py

== 11. Cara pakai harian==

Setiap mau kerja:

cd ~/Apps/PM4Py
source venv/bin/activate
jupyter lab

Keluar dari virtualenv:

deactivate

== 12. Kalau ada error Graphviz

Cek:

dot -V

Kalau belum ada:

sudo apt install -y graphviz

Lalu install ulang Python package-nya:

pip install -U graphviz

== 13. Versi ringkas semua command==

sudo apt update
sudo apt install -y python3 python3-venv python3-pip graphviz

mkdir -p ~/Apps/PM4Py
cd ~/Apps/PM4Py

python3 -m venv venv
source venv/bin/activate

python -m pip install --upgrade pip setuptools wheel

pip install -U \
pm4py \
pandas \
numpy \
matplotlib \
seaborn \
scikit-learn \
scipy \
networkx \
graphviz \
pyvis \
jupyterlab \
notebook \
ipykernel \
openpyxl \
xlsxwriter

python -m ipykernel install --user --name pm4py --display-name "Python PM4Py"

mkdir -p data notebooks scripts output

python -c "import pm4py; print(pm4py.__version__)"
jupyter lab

[1]: https://pypi.org/project/pm4py/?utm_source=chatgpt.com "pm4py"

Process Mining

Onnowpurbo — Sun, 28 Jun 2026 09:31:57 GMT

Pranala Menarik

ML: Python Virtual Environment

Onnowpurbo — Sun, 28 Jun 2026 08:24:10 GMT

9. Daftarkan kernel Jupyter

GNS3: Instalasi di Ubuntu 26.04 + VENV + docker

Onnowpurbo — Sun, 28 Jun 2026 08:01:30 GMT

4. Upgrade pip

GNS3: Instalasi di Ubuntu 26.04 + VENV + docker

Onnowpurbo — Sun, 28 Jun 2026 07:31:40 GMT

Created page with "Berikut cara instalasi '''GNS3 di Python virtual environment''' menggunakan folder: ~/Apps/GNS3 Catatan penting: instalasi via `pip/venv` cocok untuk '''GNS3 GUI + GNS3 ser..."

New page

Berikut cara instalasi '''GNS3 di Python virtual environment''' menggunakan folder:

~/Apps/GNS3

Catatan penting: instalasi via `pip/venv` cocok untuk '''GNS3 GUI + GNS3 server''', tetapi emulator seperti '''QEMU/KVM, Dynamips, uBridge, VPCS, Wireshark, Docker''' tetap lebih aman dipasang dari package OS. GNS3 server memang bertugas mengelola QEMU/KVM, Docker, VPCS, VirtualBox, VMware, dan Dynamips. ([PyPI][1])

== 1. Install dependency OS==

Untuk Ubuntu/Debian:

sudo apt update
sudo apt install -y \
python3 \
python3-pip \
python3-venv \
python3-dev \
python3-pyqt6 \
python3-pyqt6.qtsvg \
python3-pyqt6.qtwebsockets \
qemu-kvm \
libvirt-daemon-system \
libvirt-clients \
bridge-utils \
wireshark \
dynamips \
vpcs \
ubridge

Tambahkan user ke grup yang diperlukan:

sudo usermod -aG kvm,libvirt,wireshark,docker $USER

Logout-login dulu setelah perintah di atas, atau reboot:

reboot

== 2. Buat folder kerja GNS3==

mkdir -p ~/Apps/GNS3
cd ~/Apps/GNS3

== 3. Buat Python virtual environment==

python3 -m venv venv

Aktifkan venv:

source ~/Apps/GNS3/venv/bin/activate

Pastikan prompt berubah, biasanya ada `(venv)`.

== 4. Upgrade pip==

python -m pip install --upgrade pip setuptools wheel

== 5. Install GNS3 GUI dan server

Versi PyPI terbaru yang terlihat saat ini adalah '''gns3-gui 3.0.6''', dirilis 28 Januari 2026. ([PyPI][2])
GNS3 juga menyatakan instalasi dari PyPI bisa dilakukan dengan `pip install gns3-gui` dan `gns3-server`; contoh rilis 3.0 memakai `gns3-gui==3.0.5` dan `gns3-server==3.0.5`. ([GNS3][3])

Install versi terbaru:

python -m pip install gns3-gui gns3-server

Atau kalau ingin versi dikunci supaya GUI dan server tidak mismatch:

python -m pip install gns3-gui==3.0.6 gns3-server==3.0.6

Cek hasil instalasi:

gns3 --version
gns3server --version

== 6. Jalankan GNS3==

Aktifkan dulu venv:

source ~/Apps/GNS3/venv/bin/activate

Jalankan server:

gns3server

Di terminal lain, aktifkan venv lagi:

source ~/Apps/GNS3/venv/bin/activate
gns3

Atau langsung jalankan GUI saja:

~/Apps/GNS3/venv/bin/gns3

== 7. Buat script launcher supaya mudah==

Buat file:

nano ~/Apps/GNS3/start-gns3.sh

Isi:

*!/usr/bin/env bash
cd ~/Apps/GNS3 || exit 1
source venv/bin/activate
gns3

Simpan, lalu:

chmod +x ~/Apps/GNS3/start-gns3.sh

Jalankan:

~/Apps/GNS3/start-gns3.sh

== 8. Buat shortcut desktop==

mkdir -p ~/.local/share/applications
nano ~/.local/share/applications/gns3-venv.desktop

Isi:

[Desktop Entry]
Name=GNS3 VENV
Comment=Run GNS3 from ~/Apps/GNS3 Python virtual environment
Exec=/home/onno/Apps/GNS3/start-gns3.sh
Icon=gns3
Terminal=false
Type=Application
Categories=Network;Education;

Aktifkan:

chmod +x ~/.local/share/applications/gns3-venv.desktop
update-desktop-database ~/.local/share/applications 2>/dev/null

== 9. Struktur folder yang disarankan

~/Apps/GNS3/
├── venv/
├── start-gns3.sh
├── projects/
├── images/
└── appliances/

Buat foldernya:

mkdir -p ~/Apps/GNS3/projects ~/Apps/GNS3/images ~/Apps/GNS3/appliances

Di dalam GNS3 GUI, arahkan path project ke:

/home/onno/Apps/GNS3/projects

== 10. Kalau error PyQt

Kalau muncul error seperti modul Qt/PyQt tidak ditemukan, coba:

source ~/Apps/GNS3/venv/bin/activate
python -m pip install PyQt6 PyQt6-Sip PyQt6-WebEngine

Lalu jalankan lagi:

gns3

== 11. Kalau QEMU/KVM tidak jalan==

Cek KVM:

ls -l /dev/kvm
groups

Pastikan user ada di grup `kvm` dan `libvirt`.

Tes QEMU:

qemu-system-x86_64 --version

Cek libvirt:

systemctl status libvirtd

Kalau belum aktif:

sudo systemctl enable --now libvirtd

== 12. Perintah uninstall

Kalau ingin hapus instalasi venv GNS3:

rm -rf ~/Apps/GNS3/venv
rm -f ~/.local/share/applications/gns3-venv.desktop

Package OS seperti QEMU/Wireshark tidak ikut terhapus.

== Ringkasnya==

Paling penting:

mkdir -p ~/Apps/GNS3
cd ~/Apps/GNS3
python3 -m venv venv
source venv/bin/activate
python -m pip install --upgrade pip setuptools wheel
python -m pip install gns3-gui gns3-server
gns3

Untuk penggunaan serius, tetap install juga:

sudo apt install qemu-kvm wireshark dynamips vpcs ubridge

[1]: https://pypi.org/project/gns3-server/?utm_source=chatgpt.com "gns3-server"
[2]: https://pypi.org/project/gns3-gui/?utm_source=chatgpt.com "gns3-gui"
[3]: https://gns3.com/gns3-3-0-released?utm_source=chatgpt.com "GNS3 3.0 Released!"

Gns3

Onnowpurbo — Sun, 28 Jun 2026 07:27:01 GMT

Instalasi

ML: Python Virtual Environment Keras + GPU

Onnowpurbo — Sun, 28 Jun 2026 04:09:51 GMT

4. Buat virtual environment

@@ 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==

@@ Line 147: / Line 147: @@
 * [[USB OFFLINE: Ubuntu 24.04 Webmin]]
 * [[USB OFFLINE: Password dll]]
 ===SLiMS===

@@ Line 16: / Line 16: @@
   sudo apt-get update
   sudo apt-get install calibre
 ==Referensi==

← Older revision		Revision as of 01:21, 4 July 2026
Line 1:		Line 1:
−	~~Ahh siap —~~ '''DVWP = Damn Vulnerable WordPress'''.	+	'''DVWP = Damn Vulnerable WordPress'''.

	DVWP lebih realistis dibanding DVWA untuk latihan WordPress security, karena kamu belajar hal-hal yang sering muncul di pentest WordPress sungguhan: plugin, theme, `/wp-admin`, `/wp-login.php`, `/wp-content/`, XML-RPC, plugin vulnerable, file terbuka, credential lemah, dan salah konfigurasi.		DVWP lebih realistis dibanding DVWA untuk latihan WordPress security, karena kamu belajar hal-hal yang sering muncul di pentest WordPress sungguhan: plugin, theme, `/wp-admin`, `/wp-login.php`, `/wp-content/`, XML-RPC, plugin vulnerable, file terbuka, credential lemah, dan salah konfigurasi.

← Older revision		Revision as of 01:14, 4 July 2026
Line 55:		Line 55:
	* http://www.dvwa.co.uk/		* http://www.dvwa.co.uk/
	* http://www.computersecuritystudent.com/cgi-bin/CSS/process_request_v3.pl?HID=688b0913be93a4d95daed400990c4745&TYPE=SUB		* http://www.computersecuritystudent.com/cgi-bin/CSS/process_request_v3.pl?HID=688b0913be93a4d95daed400990c4745&TYPE=SUB
		+
		+
		+	==Pranala Menarik==
		+
		+	* [[DVWP]]

@@ Line 38: / Line 38: @@
   python -m pip install --upgrade pip setuptools wheel
-== 5. Install PM4Py + library pendukung
+== 5. Install PM4Py + library pendukung==
   pip install -U \
@@ Line 77: / Line 77: @@
   Python PM4Py
-== 7. Buat file requirements.txt
+== 7. Buat file requirements.txt==
   cat > requirements.txt << 'EOF'
@@ Line 109: / Line 109: @@
 Isi:
   import pm4py
   import pandas as pd
@@ Line 130: / Line 129: @@
   print(df)
-= Discover Directly-Follows Graph=
+ # Discover Directly-Follows Graph
   dfg, start_activities, end_activities = pm4py.discover_dfg(df)
@@ Line 217: / Line 216: @@
   deactivate
-== 12. Kalau ada error Graphviz
+== 12. Kalau ada error Graphviz==
 Cek:

@@ Line 20: / Line 20: @@
 ==Pranala Menarik==
 * [[PM: Methods in pm4py]]
 * [[PM: Bottleneck Detection]]

@@ Line 1: / Line 1: @@
-Berikut langkah sederhana di Ubuntu:
+Install Miniconda di Ubuntu 26.04 bisa langsung di home folder, '''tidak perlu `sudo`'''. Ini cocok untuk kasus Bapak karena `apt` tidak menyediakan Python 3.12, sedangkan TensorFlow belum cocok dengan Python 3.14.
- mkdir -p ~/Apps/Python
+Miniconda adalah installer minimal untuk `conda`, Python, dan paket dasar saja. ([Anaconda][1])
-Install paket dasar:
+== 1. Install dependency dasar==
   sudo apt update
-  sudo apt install -y python3 python3-pip python3-venv python3-dev build-essential
+  sudo apt install -y wget curl bzip2 ca-certificates
- python3 -m venv venv
+== 2. Download installer Miniconda==
-Aktifkan virtual environment:
+ cd ~/Downloads
- source venv/bin/activate
+Ini sesuai pola installer Linux resmi: `Miniconda3-latest-Linux-x86_64.sh`. Dokumentasi conda juga menjelaskan installer Linux dijalankan dengan format `bash <conda-installer-name>-latest-Linux-x86_64.sh`. ([Conda Documentation][2])
-Upgrade pip:
+== 3. Jalankan installer==
-  pip install --upgrade pip setuptools wheel
+  bash Miniconda3-latest-Linux-x86_64.sh
-Install library Python untuk coding, ML, Keras, Pandas, NumPy, dan Jupyter:
+Saat muncul pertanyaan:
-  pip install numpy pandas matplotlib scikit-learn tensorflow keras jupyter notebook ipykernel
+  Please, press ENTER to continue
-Tambahkan kernel Jupyter:
+Saat muncul lisensi, tekan `q` untuk keluar dari tampilan lisensi, lalu ketik:
-  python -m ipykernel install --user --name python-ml --display-name "Python ML"
+  yes
-Jalankan Jupyter Notebook:
+Saat ditanya lokasi instalasi, terima default:
-  jupyter notebook
+  /home/onno/miniconda3
-Nanti browser akan terbuka. Pilih kernel:
+== 9. Daftarkan kernel Jupyter==
-  Python ML
+  python -m ipykernel install --user --name python-ml --display-name "Python ML TensorFlow"
-Untuk masuk lagi lain waktu:
+Jalankan Jupyter:
   jupyter notebook
-Tes cepat:
+== Versi cepat: copy-paste==
-  python -c "import numpy, pandas, sklearn, tensorflow, keras; print('OK')"
+  [1]: https://www.anaconda.com/download?utm_source=chatgpt.com "Download Anaconda Distribution"

@@ Line 11: / Line 11: @@
   sudo apt update
   sudo apt install -y \
-    python3 \
+    qemu-system-x86 \
-   python3-pip \
+    qemu-utils \
     libvirt-daemon-system \
     libvirt-clients \
     bridge-utils \
     wireshark \
     dynamips \
-    vpcs \
+    vpcs
 Tambahkan user ke grup yang diperlukan:
@@ Line 53: / Line 48: @@
   python -m pip install --upgrade pip setuptools wheel
-== 5. Install GNS3 GUI dan server
+== 5. Install GNS3 GUI dan server==
 Versi PyPI terbaru yang terlihat saat ini adalah '''gns3-gui 3.0.6''', dirilis 28 Januari 2026. ([PyPI][2])

@@ Line 23: / Line 23: @@
 * [[GNS3: Instalasi di Ubuntu 24.04]]
 * [[GNS3: Instalasi di Ubuntu 26.04]]
 * [[GNS3: Reset]]
 * [[GNS3: Router fisik dekat PC running GNS3]]

@@ Line 61: / Line 61: @@
   cd ~/Apps/Python
-  python -m venv keras-gpu
+  python3 -m venv keras-gpu
   source keras-gpu/bin/activate