MCP: Instalasi

From OnnoWiki
Jump to navigation Jump to search
  1. PANDUAN INSTALASI LOCAL AI STACK BERBASIS DOCKER
    1. Ollama + Open WebUI + AnythingLLM + MCP + n8n
    • Perangkat:**

```text Laptop : Dell RAM : 16 GB GPU : NVIDIA RTX 4060 VRAM : 8 GB Penyimpanan : SSD 250 GB Sistem : Ubuntu Server 26.04 LTS Folder utama : /opt/ai-stack ```

    • Model yang digunakan:**

```text Model LLM : qwen3:8b Model embedding : bge-m3 ```

Panduan ini diverifikasi pada **24 Juli 2026**. Docker Engine saat ini mencantumkan Ubuntu Resolute 26.04 LTS sebagai sistem yang didukung.

---

  1. 1. TUJUAN INSTALASI

Sistem ini akan menyediakan:

1. **Ollama** 

  * Menjalankan `qwen3:8b` menggunakan GPU RTX 4060.
  * Menjalankan `bge-m3` untuk embedding dokumen.

2. **Open WebUI** 

  * Antarmuka chat berbasis web.
  * Tidak diberi akses GPU secara langsung.
  * Menggunakan Ollama sebagai backend.
  * Menggunakan `bge-m3` untuk embedding file Markdown dan PDF.

3. **AnythingLLM** 

  * Menjalankan RAG.
  * Menganalisis PDF, DOCX, Markdown, dan teks.
  * Melakukan ekstraksi entitas atau NER.
  * Menggunakan `qwen3:8b` melalui Ollama.
  * Menggunakan `bge-m3` sebagai embedding model.
  * Menggunakan LanceDB sebagai vector database lokal.

4. **MCP** 

  * Mengambil halaman web.
  * Melakukan ekstraksi isi halaman HTML menjadi Markdown.
  * Melihat dan membaca file lokal.
  * Mengubah PDF dan DOCX menjadi Markdown.

5. **n8n** 

  * Menjalankan otomasi workflow.
  * Menghubungkan Ollama dengan API, database, file, dan aplikasi lain.

---

  1. 2. ARSITEKTUR SISTEM

```text 

                        RTX 4060 8 GB
                              │
                              ▼
                        Ollama Docker
                   ┌──────────┴──────────┐
                   │                     │
               qwen3:8b               bge-m3
                   │                     │
         ┌─────────┼─────────┐           │
         │         │         │           │
         ▼         ▼         ▼           ▼
  AnythingLLM  Open WebUI    n8n    Embedding RAG
         │
         ▼
    MCP Client
         │
    ┌────┼─────────────────┐
    │    │                 │
    ▼    ▼                 ▼

Filesystem MCP Fetch MCP MarkItDown MCP 

    │                     │                 │
    ▼                     ▼                 ▼

File lokal Web/HTML biasa PDF dan DOCX ```

    1. Hubungan Ollama dengan MCP

Ollama bukan MCP server dan bukan komponen yang menjalankan MCP tool secara langsung.

Alurnya adalah:

```text Pengguna 

  │
  ▼

AnythingLLM 

  │
  ├── mengirim prompt dan definisi tool ke qwen3:8b
  │
  ▼

qwen3:8b memilih tool 

  │
  ▼

AnythingLLM menjalankan MCP tool 

  │
  ▼

Hasil tool dikirim kembali ke qwen3:8b 

  │
  ▼

Jawaban akhir ```

AnythingLLM Docker mendukung MCP **Tools**, tetapi dokumentasinya saat ini tidak menyatakan dukungan MCP Resources, Prompts, atau Sampling. AnythingLLM juga sudah menyertakan `npx`, `uv`, `uvx`, Node.js, dan Bash yang diperlukan untuk menjalankan MCP server.

---

  1. 3. PEMILIHAN MODEL
    1. 3.1 Model utama: `qwen3:8b`

```text Nama : qwen3:8b Parameter : sekitar 8,19 miliar Quantization : Q4_K_M Ukuran file : sekitar 5,2 GB Jenis input : teks ```

Qwen3 mendukung lebih dari 100 bahasa dan dialek, mempunyai kemampuan tool use, serta dirancang untuk penggunaan agent dan integrasi external tools. Hal tersebut menjadikannya pilihan yang masuk akal untuk Bahasa Indonesia, RAG, analisis teks, ekstraksi informasi, dan MCP pada GPU 8 GB.

Model ini digunakan oleh:

```text AnythingLLM Open WebUI n8n MCP agent melalui AnythingLLM ```

    1. 3.2 Model embedding: `bge-m3`

```text Nama : bge-m3 Parameter : sekitar 567 juta Ukuran file : sekitar 1,2 GB Context : hingga 8192 token Jenis : embedding model ```

BGE-M3 dirancang untuk embedding multibahasa, mendukung lebih dari 100 bahasa, dan dapat memproses teks sampai sekitar 8192 token. Model ini digunakan untuk mengubah teks menjadi vector sebelum disimpan dalam vector database.

Model ini digunakan oleh:

```text Open WebUI AnythingLLM ```

    1. 3.3 Perkiraan penyimpanan model

```text qwen3:8b : sekitar 5,2 GB bge-m3 : sekitar 1,2 GB

Total : sekitar 6,4 GB ```

Angka tersebut hanya ukuran file model. Docker images, cache, dokumen, log, database, dan vector database memerlukan kapasitas tambahan.

Karena SSD hanya 250 GB:

  • gunakan hanya satu LLM utama;
  • gunakan satu embedding model;
  • jangan memasang model 14B, 27B, 32B, atau lebih besar;
  • simpan backup pada disk eksternal;
  • periksa penggunaan disk secara berkala.

---

  1. 4. BATASAN SISTEM

Konfigurasi awal yang aman:

```text Context Ollama : 4096 Request paralel : 1 Model aktif bersamaan : 1 Embedding : bge-m3 Jumlah pengguna : satu atau beberapa pengguna ringan ```

Dokumentasi Ollama menggunakan context default 4096 pada GPU dengan VRAM di bawah 24 GiB. Context yang lebih besar membutuhkan lebih banyak memori.

Pengaturan satu model aktif berarti Ollama dapat bergantian memuat `bge-m3` dan `qwen3:8b`. Ini lebih aman untuk VRAM 8 GB, walaupun respons RAG pertama dapat sedikit lebih lambat.

---

  1. 5. PEMERIKSAAN AWAL

Login ke Ubuntu Server melalui console atau SSH.

Periksa sistem operasi:

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

Periksa arsitektur:

```bash uname -m ```

Hasil yang diharapkan:

```text x86_64 ```

Periksa GPU:

```bash lspci | grep -Ei 'NVIDIA|VGA|3D' ```

Periksa RAM:

```bash free -h ```

Periksa kapasitas disk:

```bash df -h / ```

Periksa alamat IP:

```bash ip -br address ```

Catat alamat IP server, misalnya:

```text 192.168.0.10 ```

---

  1. 6. UPDATE UBUNTU

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

sudo apt install -y \ 

   ca-certificates \
   curl \
   gnupg \
   jq \
   openssl \
   pciutils \
   ubuntu-drivers-common \
   linux-headers-$(uname -r)

```

Reboot:

```bash sudo reboot ```

Login kembali setelah server aktif.

---

  1. 7. INSTALASI DRIVER NVIDIA
    1. 7.1 Periksa driver yang tersedia

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

    1. 7.2 Instal driver rekomendasi Ubuntu

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

Ubuntu merekomendasikan penggunaan `ubuntu-drivers` untuk memilih driver yang sesuai. Opsi `--gpgpu` ditujukan untuk sistem komputasi atau server GPU.

Reboot:

```bash sudo reboot ```

    1. 7.3 Verifikasi GPU

```bash nvidia-smi ```

Hasil harus menampilkan:

```text NVIDIA GeForce RTX 4060 ```

Jangan melanjutkan ke instalasi Ollama GPU sebelum `nvidia-smi` berhasil.

---

  1. 8. INSTALASI DOCKER ENGINE

Hapus paket Docker lama yang mungkin terpasang:

```bash sudo apt remove -y \ 

   docker.io \
   docker-compose \
   docker-compose-v2 \
   docker-doc \
   podman-docker \
   containerd \
   runc 2>/dev/null || true

```

Tambahkan repository resmi Docker:

```bash sudo apt update sudo apt install -y ca-certificates curl

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

sudo curl -fsSL \ 

   https://download.docker.com/linux/ubuntu/gpg \
   -o /etc/apt/keyrings/docker.asc

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

Buat file repository:

```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 ```

Instal Docker:

```bash sudo apt update

sudo apt install -y \ 

   docker-ce \
   docker-ce-cli \
   containerd.io \
   docker-buildx-plugin \
   docker-compose-plugin

```

Perintah tersebut mengikuti metode instalasi repository resmi Docker untuk Ubuntu.

Aktifkan Docker:

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

Periksa status:

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

Periksa versi:

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

Tes:

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

---

  1. 9. INSTALASI NVIDIA CONTAINER TOOLKIT

Tambahkan repository NVIDIA:

```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

```

Instal toolkit:

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

Konfigurasikan Docker runtime:

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

NVIDIA menggunakan `nvidia-ctk runtime configure --runtime=docker` untuk menghubungkan NVIDIA Container Runtime dengan Docker.

Tes akses GPU dari container:

```bash sudo docker run --rm --gpus all ubuntu nvidia-smi ```

Hasil harus menampilkan RTX 4060. Ollama juga merekomendasikan pengujian container GPU dengan metode tersebut ketika melakukan troubleshooting.

---

  1. 10. MEMBUAT STRUKTUR DIREKTORI

Gunakan folder utama:

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

Buat direktori:

```bash sudo mkdir -p \ 

   /opt/ai-stack/ollama \
   /opt/ai-stack/open-webui \
   /opt/ai-stack/anythingllm/storage/plugins \
   /opt/ai-stack/documents \
   /opt/ai-stack/n8n

```

Atur pemilik:

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

AnythingLLM dan n8n biasanya menggunakan UID 1000 di dalam container. Atur direktori penyimpanannya:

```bash sudo chown -R 1000:1000 \ 

   /opt/ai-stack/anythingllm/storage \
   /opt/ai-stack/n8n

```

Atur direktori dokumen:

```bash sudo chmod 755 /opt/ai-stack/documents ```

Struktur akhir:

```text /opt/ai-stack/ ├── .env ├── docker-compose.yml ├── ollama/ ├── open-webui/ ├── anythingllm/ │ └── storage/ │ └── plugins/ ├── documents/ └── n8n/ ```

Seluruh data persisten aplikasi disimpan di bawah `/opt/ai-stack`. Docker tetap menyimpan image dan layer internalnya di direktori standar Docker.

---

  1. 11. MEMBUAT SECRET

Masuk ke direktori:

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

Buat `.env`:

```bash umask 077

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

Lindungi file:

```bash chmod 600 /opt/ai-stack/.env ```

Periksa nama variabel tanpa menampilkan secret:

```bash cut -d= -f1 /opt/ai-stack/.env ```

Hasil:

```text WEBUI_SECRET_KEY N8N_ENCRYPTION_KEY ```

Open WebUI menggunakan secret persisten untuk keamanan session, sedangkan n8n menggunakan encryption key untuk mengenkripsi credential yang disimpan.

Jangan mengunggah file `.env` ke GitHub atau membagikannya.

---

  1. 12. MEMBUAT KONFIGURASI MCP

AnythingLLM menyimpan konfigurasi MCP pada:

```text /app/server/storage/plugins/anythingllm_mcp_servers.json ```

Karena storage dipasang ke host, lokasi file pada host adalah:

```text /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json ```

Buat file:

```bash cat > \ /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json \ <<'JSON' { 

 "mcpServers": {
   "filesystem-local": {
     "command": "npx",
     "args": [
       "-y",
       "@modelcontextprotocol/server-filesystem",
       "/documents"
     ]
   },
   "fetch-web": {
     "command": "uvx",
     "args": [
       "mcp-server-fetch"
     ]
   },
   "markitdown-documents": {
     "command": "uvx",
     "args": [
       "markitdown-mcp"
     ]
   }
 }

} JSON ```

Atur pemilik dan permission:

```bash sudo chown 1000:1000 \ /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json

sudo chmod 600 \ /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json ```

Validasi JSON:

```bash jq . \ /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json ```

    1. 12.1 Fungsi `filesystem-local`

Filesystem MCP hanya diberi akses ke:

```text /documents ```

Package resmi yang digunakan adalah:

```text @modelcontextprotocol/server-filesystem ```

MCP server ini membatasi akses pada direktori yang diberikan sebagai argument.

Dalam Docker Compose, folder tersebut akan dipasang sebagai read-only:

```text /opt/ai-stack/documents:/documents:ro ```

Dengan demikian, agent dapat membaca tetapi tidak dapat mengubah file pada host.

    1. 12.2 Fungsi `fetch-web`

Fetch MCP digunakan untuk:

  • mengambil HTML halaman web;
  • mengubah HTML menjadi Markdown;
  • membaca artikel;
  • membaca dokumentasi;
  • mengambil konten URL biasa.

Perintah resminya:

```text uvx mcp-server-fetch ```

Secara default, permintaan yang dibuat model mengikuti aturan `robots.txt`. Fetch MCP juga dapat mengakses alamat internal jika tidak dibatasi, sehingga AnythingLLM hanya boleh digunakan oleh pengguna tepercaya.

Fetch MCP bukan browser lengkap. Sistem ini tidak dijanjikan dapat melewati:

  • login;
  • CAPTCHA;
  • proteksi anti-bot;
  • situs yang seluruh isinya membutuhkan JavaScript browser;
  • larangan scraping dari pemilik situs.
    1. 12.3 Fungsi `markitdown-documents`

MarkItDown MCP digunakan untuk mengubah:

```text PDF DOCX HTML file teks ```

menjadi Markdown.

Perintahnya:

```text uvx markitdown-mcp ```

Tool yang diekspos adalah:

```text convert_to_markdown(uri) ```

URI yang didukung meliputi `file:`, `http:`, `https:`, dan `data:`. MarkItDown dapat membaca file yang dapat diakses prosesnya, sehingga hanya folder `/documents` yang dipasang ke AnythingLLM.

PDF hasil scan yang hanya berisi gambar mungkin tidak menghasilkan teks yang baik. OCR tidak dipasang dalam panduan dasar ini.

---

  1. 13. MEMBUAT `docker-compose.yml`

Masuk ke direktori:

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

Buat file:

```bash cat > docker-compose.yml <<'YAML' name: ai-stack

x-logging: &default-logging 

 driver: json-file
 options:
   max-size: "10m"
   max-file: "3"

services: 

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

   environment:
     OLLAMA_CONTEXT_LENGTH: "4096"
     OLLAMA_MAX_LOADED_MODELS: "1"
     OLLAMA_NUM_PARALLEL: "1"
     OLLAMA_FLASH_ATTENTION: "1"
     OLLAMA_KV_CACHE_TYPE: "q8_0"
     OLLAMA_KEEP_ALIVE: "5m"

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

   volumes:
     - /opt/ai-stack/ollama:/root/.ollama

   ports:
     - "127.0.0.1:11434:11434"

   networks:
     - ai-network

   logging: *default-logging

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

   depends_on:
     - ollama

   environment:
     OLLAMA_BASE_URL: http://ollama:11434
     WEBUI_SECRET_KEY: ${WEBUI_SECRET_KEY}

     RAG_EMBEDDING_ENGINE: ollama
     RAG_EMBEDDING_MODEL: bge-m3
     RAG_OLLAMA_BASE_URL: http://ollama:11434
     RAG_TOP_K: "5"

   volumes:
     - /opt/ai-stack/open-webui:/app/backend/data

   ports:
     - "3000:8080"

   networks:
     - ai-network

   logging: *default-logging

 anythingllm:
   image: mintplexlabs/anythingllm:latest
   container_name: anythingllm
   restart: unless-stopped

   depends_on:
     - ollama

   volumes:
     - /opt/ai-stack/anythingllm/storage:/app/server/storage
     - /opt/ai-stack/documents:/documents:ro

   ports:
     - "3001:3001"

   networks:
     - ai-network

   logging: *default-logging

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

   environment:
     TZ: Asia/Jakarta
     GENERIC_TIMEZONE: Asia/Jakarta
     N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY}

   volumes:
     - /opt/ai-stack/n8n:/home/node/.n8n

   ports:
     - "5678:5678"

   networks:
     - ai-network

   logging: *default-logging

networks: 

 ai-network:
   name: ai-network
   driver: bridge

YAML ```

    1. Penjelasan konfigurasi penting
      1. Ollama

```text OLLAMA_CONTEXT_LENGTH=4096 ```

Membatasi context awal agar sesuai dengan VRAM 8 GB.

```text OLLAMA_MAX_LOADED_MODELS=1 ```

Membatasi satu model aktif dalam memori.

```text OLLAMA_NUM_PARALLEL=1 ```

Membatasi satu proses inference pada satu waktu. Kebutuhan memori Ollama meningkat sesuai jumlah request paralel dan context yang digunakan.

```text OLLAMA_FLASH_ATTENTION=1 ```

Mengaktifkan Flash Attention ketika didukung.

```text OLLAMA_KV_CACHE_TYPE=q8_0 ```

Mengurangi penggunaan memori KV cache. Dokumentasi Ollama menyatakan `q8_0` menggunakan sekitar setengah memori dibandingkan `f16`, dengan penurunan presisi yang relatif kecil.

      1. Open WebUI

Image:

```text ghcr.io/open-webui/open-webui:main-slim ```

dipilih karena lebih kecil dan tidak membawa model lokal bawaan. Image tersebut ditujukan untuk sistem dengan keterbatasan penyimpanan.

Open WebUI tidak diberi konfigurasi GPU. Semua inference dan embedding diteruskan ke container Ollama.

      1. AnythingLLM

Storage persisten:

```text /opt/ai-stack/anythingllm/storage ```

dipasang pada:

```text /app/server/storage ```

Ini mengikuti struktur penyimpanan Docker AnythingLLM.

      1. n8n

Data n8n disimpan di:

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

dan dipasang pada:

```text /home/node/.n8n ```

n8n dijalankan menggunakan image resmi `docker.n8n.io/n8nio/n8n`.

---

  1. 14. VALIDASI DOCKER COMPOSE

```bash cd /opt/ai-stack

sudo docker compose config ```

Jika terdapat kesalahan YAML atau environment variable, Docker akan menampilkannya.

Download image:

```bash sudo docker compose pull ```

Periksa penggunaan disk:

```bash sudo docker system df ```

---

  1. 15. MENJALANKAN OLLAMA

Jalankan Ollama terlebih dahulu:

```bash cd /opt/ai-stack

sudo docker compose up -d ollama ```

Periksa:

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

Verifikasi GPU dari container:

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

Jika perintah tersebut tidak tersedia di dalam image, gunakan:

```bash sudo docker run --rm --gpus all ubuntu nvidia-smi ```

---

  1. 16. DOWNLOAD MODEL

Download Qwen3:

```bash sudo docker compose exec ollama \ 

   ollama pull qwen3:8b

```

Download embedding model:

```bash sudo docker compose exec ollama \ 

   ollama pull bge-m3

```

Periksa daftar model:

```bash sudo docker compose exec ollama ollama list ```

Hasil harus memuat:

```text qwen3:8b bge-m3 ```

Jangan menarik model tambahan sebelum memeriksa ruang SSD.

---

  1. 17. MENGUJI QWEN3

Uji dari command line:

```bash sudo docker compose exec ollama \ 

   ollama run qwen3:8b \
   "Jawab singkat dalam bahasa Indonesia: jelaskan fungsi RAG."

```

Uji melalui API:

```bash curl http://127.0.0.1:11434/api/chat \ 

   -H "Content-Type: application/json" \
   -d '{
     "model": "qwen3:8b",
     "messages": [
       {
         "role": "user",
         "content": "Jawab dalam bahasa Indonesia. Apa fungsi RAG?"
       }
     ],
     "stream": false
   }' | jq -r '.message.content'

```

Periksa model yang sedang aktif:

```bash sudo docker compose exec ollama ollama ps ```

Perhatikan kolom:

```text PROCESSOR ```

Target yang diharapkan:

```text 100% GPU ```

Ollama menggunakan `ollama ps` untuk memperlihatkan apakah model berada di GPU, CPU, atau dibagi antara keduanya.

Pantau GPU:

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

---

  1. 18. MENGUJI EMBEDDING BGE-M3

```bash curl http://127.0.0.1:11434/api/embed \ 

   -H "Content-Type: application/json" \
   -d '{
     "model": "bge-m3",
     "input": "Dokumen ini membahas kebijakan keamanan informasi."
   }' | jq '.embeddings[0] | length'

```

Hasil harus berupa jumlah dimensi vector, bukan pesan error.

Embedding mengubah teks menjadi vector numerik yang digunakan untuk pencarian semantik dan RAG.

---

  1. 19. MENJALANKAN SEMUA SERVICE

```bash cd /opt/ai-stack

sudo docker compose up -d ```

Periksa:

```bash sudo docker compose ps ```

Container berikut harus berstatus `Up`:

```text ollama open-webui anythingllm n8n ```

Periksa log:

```bash sudo docker compose logs --tail=100 open-webui sudo docker compose logs --tail=100 anythingllm sudo docker compose logs --tail=100 n8n ```

Tampilkan alamat IP server:

```bash hostname -I ```

Alamat layanan:

```text Open WebUI : http://IP-SERVER:3000 AnythingLLM: http://IP-SERVER:3001 n8n : http://IP-SERVER:5678 ```

Contoh:

```text http://192.168.0.10:3000 http://192.168.0.10:3001 http://192.168.0.10:5678 ```

---

  1. 20. KONFIGURASI OPEN WEBUI

Buka:

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

Buat akun administrator pertama.

    1. 20.1 Koneksi Ollama

Masuk ke:

```text Admin Panel → Settings → Connections ```

Pastikan:

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

Variabel resmi Open WebUI untuk koneksi ini adalah `OLLAMA_BASE_URL`.

    1. 20.2 Konfigurasi embedding

Masuk ke:

```text Admin Panel → Settings → Documents ```

Atur:

```text Embedding Engine : Ollama Ollama URL : http://ollama:11434 Embedding Model : bge-m3 Top K : 5 ```

Open WebUI mendukung penggunaan Ollama sebagai embedding engine melalui `RAG_EMBEDDING_ENGINE`, `RAG_EMBEDDING_MODEL`, dan `RAG_OLLAMA_BASE_URL`.

    1. 20.3 Membuat Knowledge Base

Masuk ke:

```text Workspace → Knowledge → Create Knowledge ```

Upload:

```text .md .pdf ```

Kemudian gunakan Knowledge tersebut dalam percakapan.

Contoh prompt:

```text Gunakan hanya informasi dari dokumen yang diberikan.

Buat ringkasan dalam bahasa Indonesia.

Pisahkan: - fakta yang tertulis; - interpretasi; - informasi yang tidak tersedia.

Jangan menambahkan fakta dari luar dokumen. ```

Open WebUI melakukan alur:

```text PDF atau Markdown 

      ↓

Ekstraksi teks 

      ↓

Chunking 

      ↓

Embedding dengan bge-m3 

      ↓

Vector database 

      ↓

Retrieval 

      ↓

qwen3:8b ```

Apabila embedding model diganti, dokumen lama harus diindeks ulang karena vector dari embedding model berbeda tidak kompatibel.

---

  1. 21. KONFIGURASI ANYTHINGLLM

Buka:

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

Lakukan konfigurasi awal.

    1. 21.1 LLM Provider

Pilih:

```text LLM Provider : Ollama Base URL : http://ollama:11434 Model : qwen3:8b Context : 4096 ```

    1. 21.2 Embedding Provider

Pilih:

```text Embedding Provider : Ollama Base URL : http://ollama:11434 Embedding Model : bge-m3 ```

    1. 21.3 Vector database

Gunakan:

```text Vector Database: LanceDB ```

LanceDB tersedia sebagai vector database lokal bawaan sehingga tidak memerlukan container database tambahan. AnythingLLM mendukung Ollama sebagai LLM dan embedding provider serta menyediakan pilihan vector database lokal.

    1. 21.4 Membuat workspace

Buat:

```text Nama workspace: Analisis Dokumen dan NER ```

Rekomendasi awal:

```text Model : qwen3:8b Context : 4096 Temperature : 0.1–0.2 Retrieved chunks : 4–6 Embedding : bge-m3 ```

---

  1. 22. DUA CARA MEMBACA DOKUMEN DI ANYTHINGLLM
    1. 22.1 Menggunakan RAG

Upload PDF atau DOCX ke workspace AnythingLLM.

Alurnya:

```text Dokumen 

  ↓

Parser AnythingLLM 

  ↓

Chunking 

  ↓

Embedding bge-m3 

  ↓

LanceDB 

  ↓

Retrieval 

  ↓

qwen3:8b ```

Gunakan metode ini untuk:

  • koleksi dokumen;
  • tanya jawab berulang;
  • pencarian semantik;
  • knowledge base;
  • dokumen yang ingin digunakan jangka panjang.
    1. 22.2 Menggunakan MCP MarkItDown

Gunakan MarkItDown MCP untuk membaca file tertentu secara langsung.

Alurnya:

```text File PDF atau DOCX 

       ↓

MarkItDown MCP 

       ↓

Markdown 

       ↓

qwen3:8b ```

Metode ini tidak otomatis memasukkan file ke vector database.

Gunakan untuk:

  • membaca satu file;
  • mengonversi PDF atau DOCX;
  • menganalisis file secara langsung;
  • ekstraksi informasi sekali jalan.

---

  1. 23. MENGAKTIFKAN MCP DI ANYTHINGLLM

Masuk ke:

```text Settings → Agent Skills ```

Klik:

```text Refresh ```

Pastikan muncul:

```text filesystem-local fetch-web markitdown-documents ```

AnythingLLM memuat konfigurasi dari file `anythingllm_mcp_servers.json`. MCP dapat dijalankan melalui Agent Skills atau menggunakan mode `@agent`.

Pada penggunaan pertama, `npx` dan `uvx` dapat mengunduh package MCP yang dibutuhkan. Package tersebut berada di dalam container dan mungkin perlu diunduh ulang jika container dihapus dan dibuat ulang.

---

  1. 24. MEMASUKKAN FILE LOKAL

Contoh menyalin PDF:

```bash sudo cp /lokasi/asli/laporan.pdf \ 

   /opt/ai-stack/documents/

```

Contoh menyalin DOCX:

```bash sudo cp /lokasi/asli/proposal.docx \ 

   /opt/ai-stack/documents/

```

Atur permission:

```bash sudo find /opt/ai-stack/documents \ 

   -type d -exec chmod 755 {} \;

sudo find /opt/ai-stack/documents \ 

   -type f -exec chmod 644 {} \;

```

Periksa dari host:

```bash ls -lah /opt/ai-stack/documents ```

Periksa dari container:

```bash sudo docker exec anythingllm ls -lah /documents ```

---

  1. 25. PENGUJIAN MCP FILESYSTEM

Aktifkan agent di AnythingLLM, kemudian gunakan:

```text @agent

Gunakan tool filesystem-local.

Tampilkan daftar file yang berada di direktori /documents.

Jangan membuat, mengubah, memindahkan, atau menghapus file. ```

Karena volume menggunakan mode `:ro`, proses di dalam container tidak dapat mengubah file host.

---

  1. 26. PENGUJIAN MCP PDF

Misalnya terdapat:

```text /opt/ai-stack/documents/laporan.pdf ```

Gunakan prompt:

```text @agent

Gunakan tool markitdown-documents untuk membaca:

file:///documents/laporan.pdf

Setelah file berhasil dibaca:

1. Buat ringkasan dalam bahasa Indonesia. 2. Sebutkan fakta penting. 3. Sebutkan orang, organisasi, lokasi, tanggal, dan nilai uang. 4. Pisahkan fakta dan interpretasi. 5. Jangan menambahkan informasi yang tidak terdapat dalam dokumen. ```

---

  1. 27. PENGUJIAN MCP DOCX

Misalnya terdapat:

```text /opt/ai-stack/documents/proposal.docx ```

Gunakan:

```text @agent

Gunakan tool markitdown-documents untuk membaca:

file:///documents/proposal.docx

Ekstrak:

- tujuan dokumen; - nama orang; - organisasi; - lokasi; - tanggal; - nilai uang; - risiko; - keputusan; - tindakan lanjutan.

Jangan menebak informasi yang tidak ditulis. ```

---

  1. 28. PENGUJIAN MCP WEB

Gunakan situs yang memang boleh diakses dan dibaca.

Contoh:

```text @agent

Gunakan tool fetch-web untuk mengambil:

https://example.com

Jelaskan:

- judul halaman; - pokok isi; - organisasi yang disebutkan; - tanggal jika tersedia; - informasi yang tidak dapat diverifikasi.

Jangan menambahkan informasi dari luar halaman. ```

Untuk halaman lain, ganti URL tersebut.

MCP fetch tidak boleh digunakan untuk:

  • melewati login;
  • melewati CAPTCHA;
  • mengabaikan larangan scraping;
  • mengambil data pribadi tanpa izin;
  • menyerang alamat internal;
  • mengakses sistem yang tidak berwenang.

---

  1. 29. PROMPT NER UNTUK ANYTHINGLLM

`qwen3:8b` merupakan general-purpose instruction model, bukan model NER statistik khusus. Model ini dapat melakukan zero-shot NER, tetapi hasil penting tetap perlu diverifikasi manusia.

Gunakan prompt berikut:

```text Anda adalah mesin ekstraksi entitas.

Gunakan hanya teks yang terdapat dalam dokumen atau konteks.

Kembalikan JSON valid dengan format berikut:

{ 

 "entities": [
   {
     "text": "teks persis dari dokumen",
     "type": "PERSON|ORGANIZATION|LOCATION|DATE|TIME|MONEY|PERCENTAGE|PRODUCT|EVENT|LAW|OTHER",
     "evidence": "kalimat tempat entitas ditemukan",
     "confidence": "high|medium|low"
   }
 ]

}

Aturan:

1. Jangan menulis teks di luar JSON. 2. Jangan membuat entitas yang tidak tertulis. 3. Jangan memperluas singkatan jika kepanjangannya tidak tersedia. 4. Jangan mengubah ejaan nama. 5. Jangan menebak hubungan antarentitas. 6. Jangan menyimpulkan kewarganegaraan, jabatan, atau afiliasi jika tidak ditulis. 7. Jika tidak ditemukan entitas, kembalikan:

{"entities":[]}

8. Confidence menunjukkan kejelasan teks, bukan probabilitas statistik. ```

Untuk ekstraksi hubungan:

```text Berdasarkan entitas yang ditemukan, ekstrak hanya hubungan yang dinyatakan secara eksplisit.

Kembalikan JSON:

{ 

 "relations": [
   {
     "subject": "",
     "predicate": "",
     "object": "",
     "evidence": ""
   }
 ]

}

Jangan membuat hubungan berdasarkan asumsi. ```

---

  1. 30. KONFIGURASI N8N

Buka:

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

Buat akun administrator.

    1. 30.1 Koneksi n8n ke Ollama

Gunakan alamat:

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

Jangan gunakan:

```text http://localhost:11434 ```

Di dalam container n8n, `localhost` menunjuk ke container n8n sendiri. Dokumentasi n8n menjelaskan bahwa container dalam Docker network yang sama harus mengakses Ollama menggunakan nama container atau nama service.

    1. 30.2 Pengujian menggunakan HTTP Request

Tambahkan node:

```text HTTP Request ```

Konfigurasi:

```text Method : POST URL : http://ollama:11434/api/chat ```

Header:

```text Content-Type: application/json ```

Body JSON:

```json { 

 "model": "qwen3:8b",
 "messages": [
   {
     "role": "system",
     "content": "Jawab dalam bahasa Indonesia. Jangan menambahkan fakta yang tidak tersedia."
   },
   {
     "role": "user",
     "content": "Ringkas teks berikut: Template:$json.text"
   }
 ],
 "stream": false

} ```

Contoh workflow:

```text Schedule Trigger 

      ↓

Read File atau HTTP Request 

      ↓

Ollama qwen3:8b 

      ↓

Ekstraksi atau ringkasan 

      ↓

Database, email, webhook, atau aplikasi lain ```

---

  1. 31. PEMANTAUAN RESOURCE

Periksa container:

```bash cd /opt/ai-stack sudo docker compose ps ```

Periksa CPU dan RAM:

```bash sudo docker stats --no-stream ```

Periksa RAM host:

```bash free -h ```

Periksa GPU:

```bash nvidia-smi ```

Periksa model Ollama:

```bash sudo docker compose exec ollama ollama ps ```

Periksa penyimpanan Docker:

```bash sudo docker system df ```

Periksa ukuran data:

```bash sudo du -h -d 2 /opt/ai-stack | sort -h ```

Periksa kapasitas filesystem:

```bash df -h / /opt ```

Cari file lebih besar dari 1 GB:

```bash sudo find /opt/ai-stack \ 

   -xdev \
   -type f \
   -size +1G \
   -printf '%s %p\n' \
   | sort -nr \
   | head -20

```

---

  1. 32. PENGELOLAAN SSD 250 GB
    1. Pembersihan image yang tidak digunakan

Periksa dahulu:

```bash sudo docker system df ```

Hapus dangling image:

```bash sudo docker image prune -f ```

Hapus build cache yang tidak digunakan:

```bash sudo docker builder prune -f ```

    1. Menghapus model Ollama

Lihat model:

```bash sudo docker compose exec ollama ollama list ```

Hapus model tertentu:

```bash sudo docker compose exec ollama \ 

   ollama rm NAMA_MODEL

```

Jangan menghapus:

```text qwen3:8b bge-m3 ```

selama masih digunakan.

    1. Hindari perintah berikut

```bash sudo docker compose down -v ```

Opsi `-v` dapat menghapus volume.

Jangan menjalankan tanpa memahami akibatnya:

```bash sudo docker system prune -a --volumes ```

Perintah tersebut dapat menghapus image, cache, network, dan volume yang masih diperlukan.

---

  1. 33. START, STOP, DAN RESTART

Masuk ke folder:

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

Jalankan semua service:

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

Hentikan sementara:

```bash sudo docker compose stop ```

Jalankan kembali:

```bash sudo docker compose start ```

Restart:

```bash sudo docker compose restart ```

Restart satu service:

```bash sudo docker compose restart anythingllm ```

Hapus container tanpa menghapus bind-mounted data:

```bash sudo docker compose down ```

Jalankan kembali:

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

---

  1. 34. UPDATE CONTAINER

Lakukan backup terlebih dahulu.

Kemudian:

```bash cd /opt/ai-stack

sudo docker compose pull sudo docker compose up -d sudo docker image prune -f ```

Periksa:

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

Tag `latest` dan `main-slim` dapat berubah. Setelah sistem terbukti stabil, penggunaan versi atau image digest yang sudah diuji lebih aman untuk instalasi produksi.

---

  1. 35. BACKUP

Pasang disk eksternal, misalnya:

```text /mnt/backup ```

Hentikan aplikasi yang menyimpan database:

```bash cd /opt/ai-stack

sudo docker compose stop \ 

   open-webui \
   anythingllm \
   n8n

```

Buat backup:

```bash sudo tar \ 

   -C /opt \
   -czf /mnt/backup/ai-stack-data-$(date +%F).tar.gz \
   ai-stack/docker-compose.yml \
   ai-stack/.env \
   ai-stack/open-webui \
   ai-stack/anythingllm \
   ai-stack/n8n \
   ai-stack/documents

```

Jalankan kembali:

```bash sudo docker compose start \ 

   open-webui \
   anythingllm \
   n8n

```

Folder model Ollama tidak dimasukkan agar backup lebih kecil. Model dapat diunduh kembali menggunakan:

```bash sudo docker compose exec ollama ollama pull qwen3:8b sudo docker compose exec ollama ollama pull bge-m3 ```

---

  1. 36. KEAMANAN
    1. 36.1 Jangan membuka port ke Internet

Port berikut hanya untuk LAN atau VPN:

```text 3000 : Open WebUI 3001 : AnythingLLM 5678 : n8n ```

Jangan membuat port forwarding langsung dari router.

Gunakan salah satu:

```text WireGuard Tailscale Reverse proxy dengan HTTPS Firewall dengan pembatasan IP ```

Docker memperingatkan bahwa port container yang dipublikasikan dapat melewati sebagian aturan UFW atau firewalld. Karena itu, jangan hanya mengandalkan UFW untuk melindungi service Docker yang dipublikasikan.

    1. 36.2 Ollama hanya tersedia pada host dan Docker network

Compose menggunakan:

```text 127.0.0.1:11434:11434 ```

Ollama tidak dapat diakses langsung dari komputer LAN, tetapi masih dapat diakses oleh container melalui:

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

    1. 36.3 Batasi filesystem MCP

AnythingLLM hanya diberi akses ke:

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

Jangan memasang:

```text / /etc /root /home /var/run/docker.sock ```

ke AnythingLLM.

Jangan menyimpan di folder dokumen:

```text password SSH private key API key file .env database credential token autentikasi ```

    1. 36.4 Jangan memberikan Docker socket kepada AI

Jangan menambahkan:

```text /var/run/docker.sock:/var/run/docker.sock ```

ke AnythingLLM, Open WebUI, n8n, atau MCP.

Akses Docker socket dapat memberikan kontrol administratif terhadap host.

---

  1. 37. TROUBLESHOOTING
    1. 37.1 Ollama tidak menggunakan GPU

Periksa host:

```bash nvidia-smi ```

Periksa Docker:

```bash sudo docker run --rm --gpus all ubuntu nvidia-smi ```

Konfigurasi ulang:

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

cd /opt/ai-stack sudo docker compose restart ollama ```

Periksa:

```bash sudo docker compose exec ollama ollama ps ```

    1. 37.2 Kehabisan VRAM atau RAM

Gejala:

```text CUDA out of memory container exited killed system memakai swap berlebihan ```

Pertahankan:

```text Context : 4096 Parallel request : 1 Loaded models : 1 Model : qwen3:8b ```

Periksa:

```bash free -h nvidia-smi sudo docker stats sudo docker compose exec ollama ollama ps ```

Jangan menaikkan context ke 8192 sebelum konfigurasi 4096 terbukti stabil.

    1. 37.3 AnythingLLM tidak melihat Ollama

Periksa network:

```bash sudo docker network inspect ai-network ```

Uji koneksi dengan container sementara:

```bash sudo docker run --rm \ 

   --network ai-network \
   curlimages/curl:latest \
   http://ollama:11434/api/tags

```

Pastikan AnythingLLM menggunakan:

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

Bukan:

```text http://localhost:11434 ```

    1. 37.4 MCP tidak muncul

Validasi JSON:

```bash jq . \ /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json ```

Periksa permission:

```bash ls -lah \ /opt/ai-stack/anythingllm/storage/plugins/ ```

Perbaiki jika perlu:

```bash sudo chown 1000:1000 \ /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json

sudo chmod 600 \ /opt/ai-stack/anythingllm/storage/plugins/anythingllm_mcp_servers.json ```

Restart:

```bash cd /opt/ai-stack sudo docker compose restart anythingllm ```

Masuk kembali ke:

```text Settings → Agent Skills → Refresh ```

Periksa log:

```bash sudo docker compose logs --tail=200 anythingllm \ 

   | grep -Ei \
   'mcp|npx|uvx|fetch|markitdown|filesystem|error'

```

    1. 37.5 File tidak terlihat

Periksa host:

```bash ls -lah /opt/ai-stack/documents ```

Periksa container:

```bash sudo docker exec anythingllm ls -lah /documents ```

Periksa mount:

```bash sudo docker inspect anythingllm \ 

   --format 'Template:Json .Mounts' | jq

```

    1. 37.6 Open WebUI gagal melakukan embedding

Periksa model:

```bash sudo docker compose exec ollama ollama list ```

Tes:

```bash curl http://127.0.0.1:11434/api/embed \ 

   -H "Content-Type: application/json" \
   -d '{
     "model": "bge-m3",
     "input": "tes embedding"
   }' | jq

```

Pastikan konfigurasi Open WebUI:

```text Embedding Engine : Ollama Embedding Model : bge-m3 Ollama URL : http://ollama:11434 ```

Kemudian lakukan reindex dokumen.

---

  1. 38. CHECKLIST AKHIR
    1. Sistem dan GPU

```text [ ] Ubuntu Server 26.04 sudah diperbarui [ ] nvidia-smi mendeteksi RTX 4060 [ ] Docker Engine aktif [ ] Docker Compose Plugin tersedia [ ] NVIDIA Container Toolkit aktif [ ] Container dapat mengakses GPU ```

    1. Model

```text [ ] qwen3:8b tersedia [ ] bge-m3 tersedia [ ] qwen3:8b berjalan pada GPU [ ] endpoint embedding bge-m3 berhasil ```

    1. Open WebUI

```text [ ] Open WebUI dapat dibuka pada port 3000 [ ] Open WebUI tidak mempunyai akses GPU langsung [ ] Ollama URL menggunakan http://ollama:11434 [ ] Model chat menggunakan qwen3:8b [ ] Embedding menggunakan bge-m3 [ ] File Markdown dapat diindeks [ ] PDF berbasis teks dapat diindeks ```

    1. AnythingLLM

```text [ ] AnythingLLM dapat dibuka pada port 3001 [ ] LLM Provider menggunakan Ollama [ ] Model menggunakan qwen3:8b [ ] Embedder menggunakan bge-m3 [ ] Vector database menggunakan LanceDB [ ] filesystem-local aktif [ ] fetch-web aktif [ ] markitdown-documents aktif [ ] PDF dapat dibaca [ ] DOCX dapat dibaca [ ] NER menghasilkan JSON valid ```

    1. n8n

```text [ ] n8n dapat dibuka pada port 5678 [ ] Data n8n persisten [ ] Timezone Asia/Jakarta [ ] n8n dapat mengakses http://ollama:11434 [ ] qwen3:8b dapat dipanggil dari workflow ```

---

  1. 39. KONFIGURASI FINAL

```text Folder utama : /opt/ai-stack

Ollama image : ollama/ollama:latest Ollama model : qwen3:8b Embedding model : bge-m3 Context awal : 4096 Request paralel : 1 Model aktif : 1 Ollama host port : 127.0.0.1:11434

Open WebUI image : open-webui:main-slim Open WebUI GPU : tidak Open WebUI port : 3000 Open WebUI LLM : qwen3:8b melalui Ollama Open WebUI embedding : bge-m3 melalui Ollama

AnythingLLM port : 3001 AnythingLLM LLM : qwen3:8b AnythingLLM embedding : bge-m3 AnythingLLM vector DB : LanceDB

MCP filesystem : @modelcontextprotocol/server-filesystem MCP web : mcp-server-fetch MCP PDF/DOCX : markitdown-mcp Folder dokumen host : /opt/ai-stack/documents Folder dokumen container : /documents:ro

n8n port : 5678 n8n Ollama URL : http://ollama:11434 Timezone : Asia/Jakarta ```

Konfigurasi ini menggunakan hanya dua model sehingga lebih sesuai untuk RTX 4060 8 GB, RAM 16 GB, dan SSD 250 GB. Open WebUI, AnythingLLM, dan n8n tidak memuat model sendiri; semuanya menggunakan Ollama sebagai backend bersama.

Retrieved from "https://onnocenter.or.id/wiki/index.php?title=MCP:_Instalasi&oldid=73710"