Menggunakan OpenClaw dengan Ollama: Membangun Analis Data Lokal

Mengapa Menjalankan OpenClaw dengan Ollama?

Menjalankan OpenClaw dengan model Ollama lokal mengubah sistem Anda menjadi lingkungan AI yang berdiri sendiri. Alih-alih mengirim prompt dan data ke API eksternal, seluruh alur kerja—termasuk penalaran, akses file, dan pembuatan artefak—berjalan di mesin Anda.

Pengaturan ini memberikan beberapa keuntungan praktis:

• Privasi by design: Semua dataset, dokumen, dan output antara tetap berada di perangkat. Tidak ada yang dikirim ke layanan eksternal.
• Transparansi dan kendali penuh: Setiap langkah dapat diperiksa, mulai dari perintah slash yang dikirim ke OpenClaw hingga file yang dihasilkan dan jejak eksekusi.
• Operasi offline: Setelah model di-pull melalui Ollama, sistem bekerja tanpa akses internet.
• Eksekusi bergaya agen: Satu permintaan pengguna dapat memicu alur kerja multi-langkah alih-alih satu respons teks tunggal.

Tutorial ini berfokus pada pembuatan arsitektur agen lokal, di mana OpenClaw bertindak sebagai mesin eksekusi, dan Ollama menyediakan lapisan penalaran.

Tutorial OpenClaw Ollama: Bangun Analis Data Lokal

mPada bagian ini, kita akan membangun aplikasi Analis Data Lokal yang berjalan sepenuhnya di mesin Anda menggunakan OpenClaw dan model Ollama lokal. Secara garis besar, sistem melakukan tiga tugas inti:

• Menerima dataset CSV dari pengguna
• Secara opsional mengimpor dokumen konteks pendukung (PDF, TXT, atau Markdown)
• Menjalankan alur kerja analisis multi-langkah untuk menghasilkan insight dan visualisasi

Sistem menghasilkan tiga artefak output:

• trend_chart.png
• analysis_report.md
• tool_trace.json

Di balik layar, alur kerja dikoordinasikan oleh tiga komponen:

• Antarmuka web(web_assistant.py): File Python ini menangani unggahan file, membuat direktori run, dan mengirim perintah slash ke OpenClaw.
• Agen OpenClaw: Agen OpenClaw memuat skill workspace, mengeksekusi perintah lokal melalui tools, dan menggunakan LLM lokal yang di-host melalui Ollama untuk penalaran dan peringkasan.
• Mesin analisis (main.py): File ini membaca dataset, menyimpulkan kolom yang relevan, membuat bagan dan insight, serta menulis semua output ke disk.

Setelah alur kerja selesai, antarmuka web menampilkan pratinjau artefak yang dihasilkan, sehingga pengguna dapat melihat hasil dan jejak eksekusi.

Langkah 1: Instal OpenClaw

Sebelum kita membangun alur kerja Analis Data Lokal, kita perlu menjalankan OpenClaw Gateway di mesin Anda. Anggap OpenClaw sebagai lapisan eksekusi dalam proyek ini, yang menerima permintaan dari UI web, memuat skill workspace, menjalankan alat lokal (seperti perintah shell dan skrip Python), dan mengoordinasikan alur kerja penuh dari awal hingga akhir.

curl -fsSL https://openclaw.ai/install.sh | bash
openclaw onboard --install-daemon

Perintah ini memasang CLI OpenClaw, menjalankan wizard onboarding untuk mengonfigurasi lingkungan lokal, dan menyiapkan daemon gateway agar dapat dijalankan dan dihentikan dengan mudah. Meskipun kita akan menjalankan gateway di foreground untuk demo ini, memasang daemon memastikan pengaturan standar dan memudahkan pemecahan masalah.

Sekarang, mari kita konfirmasi semuanya berfungsi:

openclaw doctor
openclaw gateway status

Perintah OpenClaw doctor melaporkan bahwa OpenClaw terpasang dengan benar. Status gateway OpenClaw memberi tahu Anda apakah gateway sedang berjalan. Pada tahap ini, mungkin tertulis “not running”, dan itu tidak masalah. Poin utamanya adalah perintah berfungsi dan pemasangan dikenali.

Jika Anda menginginkan panduan terperinci tentang setiap opsi onboarding (kanal, autentikasi, skill, keamanan gateway), Anda dapat merujuk ke tutorial OpenClaw untuk langkah-langkah lengkap.

Langkah 2: Instal Ollama

Selanjutnya, kita akan menyiapkan Ollama, yang akan bertindak sebagai backend LLM lokal untuk proyek ini. OpenClaw tetap akan mengorkestrasi alur kerja, tetapi ketika memerlukan kecerdasan model untuk peringkasan atau penalaran, ia akan memanggil LLM melalui Ollama.

Jalankan perintah berikut:

brew install ollama
ollama serve
ollama pull qwen3:8b

Perintah di atas memasang runtime Ollama, memulai server model lokal yang akan dihubungi OpenClaw, dan mengunduh model qwen3:8b. Kami menggunakan qwen3:8b karena menawarkan keseimbangan yang baik antara kinerja dan kualitas untuk sebagian besar laptop, tetapi Anda bisa memilih model lain berdasarkan sumber daya sistem Anda. Anda juga dapat merujuk ke panduan ini dari Ollama.

Langkah 3: Konfigurasikan OpenClaw

Berikutnya, kita perlu mengonfigurasi OpenClaw untuk menggunakan instance Ollama lokal. Ini memastikan bahwa semua penalaran, peringkasan, dan analisis terjadi sepenuhnya di mesin Anda tanpa panggilan API eksternal.

Buat direktori konfigurasi lokal:

mkdir -p .openclaw-local

Lalu buat file:

.openclaw-local/openclaw.json

{
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://127.0.0.1:11434/v1",
        "apiKey": "ollama-local",
        "api": "openai-completions",
        "models": [
          {
            "id": "qwen3:8b",
            "name": "qwen3:8b",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 131072,
            "maxTokens": 8192
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": { "primary": "ollama/qwen3:8b" }
    }
  },
  "tools": {
    "web": {
      "search": { "enabled": false },
      "fetch": { "enabled": true }
    }
  }
}

Konfigurasi di atas mendefinisikan tiga komponen kunci:

• baseUrl menunjuk ke endpoint API lokal yang diekspos oleh ollama serve, sementara pengaturan api: openai-completions mengaktifkan komunikasi yang kompatibel dengan OpenAI. Pendaftaran model untuk qwen3:8b menentukan kapabilitasnya, termasuk jendela konteks 131K yang besar untuk menangani dataset berukuran besar dan batas token untuk respons yang terkontrol. Karena model berjalan secara lokal, semua nilai biaya disetel ke nol.
• Bagian agent defaults mengontrol model mana yang digunakan agen OpenClaw untuk penalaran. Dengan menetapkan model utama ke ollama/qwen3:8b, setiap tugas agen, seperti menafsirkan prompt, membuat ringkasan, atau melakukan penalaran atas data, secara otomatis diarahkan ke model Ollama lokal tanpa memerlukan panggilan API eksternal.
• Konfigurasi tool mengelola kapabilitas eksternal seperti penelusuran web, yang dinonaktifkan untuk memastikan privasi dan mencegah permintaan keluar. Alat fetch tetap diaktifkan untuk pengambilan sumber daya terbatas saat diperlukan.

Bersama-sama, pengaturan ini memastikan seluruh alur kerja berjalan secara privat di mesin Anda, dengan OpenClaw menangani orkestrasi dan Ollama menyediakan kecerdasan lokal.

Langkah 4: Definisikan skill workspace

Pada langkah ini, kita mendefinisikan skill workspace yang memberi tahu OpenClaw cara mengeksekusi alur kerja. Alih-alih mengandalkan model untuk merencanakan penggunaan alat, kita menggunakan mode command dispatch, yang memungkinkan perintah slash untuk langsung memicu perintah eksekusi lokal, membuat alur kerja lebih cepat dan sepenuhnya lokal.

Mari buat file SKILL.md berikut di workspace Anda:

---
name: local-data-analyst
description: Local Data Analyst: analyze private local data with Ollama, generate chart/report, and keep all data on-device.
user-invocable: true
command-dispatch: tool
command-tool: exec
command-arg-mode: raw
---
Invoke as /local-data-analyst <raw command>.
This skill bypasses model planning and dispatches raw command text directly to the exec tool.
Use this exact command template in this workspace:
python3 /……/main.py --docs-dir <context_dir> --data-file <data_file> --output-dir <output_dir> --prompt "<prompt>" --use-ollama --model qwen3:8b
Expected outputs under <output_dir>:
- trend_chart.png
- analysis_report.md
- tool_trace.json

Konfigurasi skill ini mengontrol bagaimana OpenClaw mengeksekusi analisis:

• Front matter (blok metadata terstruktur di bagian paling atas file) mendefinisikan skill yang dapat dipanggil pengguna bernama local-data-analyst, yang tersedia sebagai perintah slash /local-data-analyst.
• Perintah slash adalah cara OpenClaw memicu tindakan terstruktur dari chat atau UI.
• Pengaturan command-dispatch: tool mengaktifkan mode command dispatch, di mana OpenClaw langsung merutekan perintah ke sebuah tool alih-alih meminta model memutuskan apa yang harus dilakukan.
• Dengan command-arg-mode: raw, string perintah penuh diteruskan tanpa perubahan ke alat exec, memastikan eksekusi yang dapat diprediksi.
• Perintah menjalankan skrip lokal main.py, yang:
• Memuat dataset dan dokumen konteks opsional
• Menggunakan Ollama (qwen3:8b) untuk penalaran dan ringkasan
• Menghasilkan tiga artefak, termasuk bagan, laporan markdown, dan jejak eksekusi tool

Dengan demikian, OpenClaw menangani orkestrasi dan eksekusi, sementara Ollama menyediakan penalaran lokal. Pada langkah berikutnya, kita akan menghubungkan skill ini ke antarmuka web sehingga pengguna dapat mengunggah data dan memicu analisis dengan satu tindakan.

Langkah 5: Buat antarmuka web

Pada titik ini, kita sudah memiliki dua komponen inti yang berfungsi, yaitu skill workspace OpenClaw dan backend model lokal (Ollama) yang menyediakan penalaran. Sekarang kita memerlukan antarmuka ringan yang memungkinkan Anda mengunggah file dan memicu run tanpa menyentuh terminal setiap saat.

File web_assistant.py bertindak sebagai server frontend tipis yang:

• Menerima unggahan file,
• Membuat direktori run terisolasi untuk setiap eksekusi,
• Menyusun perintah slash OpenClaw yang menunjuk ke file di disk,
• Memanggil agen OpenClaw secara lokal,
• Menunggu output,
• Mengembalikan artefak siap pratinjau ke browser.

Pilihan desain kunci di sini adalah server web tidak pernah menjalankan logika analisis itu sendiri. Semua didelegasikan ke OpenClaw, sehingga UI tetap sederhana.

Langkah 5.1: Menyusun perintah slash

Tujuannya adalah menghasilkan satu string yang dapat diterima OpenClaw sebagai pesan chat, seperti: /local-data-analyst python3 ... --data-file ... --output-dir …

def build_slash_command(
    data_path: Path,
    docs_dir: Path,
    output_dir: Path,
    prompt: str,
    model: str,
    x_col: str,
    y_col: str,
) -> str:
    args = [
        "python3",
        str(BASE_DIR / "src" / "main.py"),
        "--docs-dir", str(docs_dir),
        "--data-file", str(data_path),
        "--output-dir", str(output_dir),
        "--prompt", prompt,
        "--use-ollama",
        "--model", model,
    ]
    if x_col:
        args.extend(["--x-column", x_col])
    if y_col:
        args.extend(["--y-column", y_col])
    raw = " ".join(shlex.quote(a) for a in args)
    return f"/local-data-analyst {raw}"

Fungsi build_slash_command() menyiapkan instruksi persis yang akan dikirim ke OpenClaw. Alih-alih mengeksekusi analisis secara langsung, aplikasi web menyusun perintah slash terstruktur yang dapat dirutekan OpenClaw ke skill workspace yang sesuai. Fungsi ini melakukan empat tugas utama:

• Daftar args mendefinisikan pemanggilan CLI ke src/main.py. Ini adalah perintah yang sama yang bisa Anda jalankan secara manual dari terminal.
• Flag --x-column dan --y-column hanya ditambahkan bila disediakan. Jika nilai ini tidak ada, skrip analisis dapat menyimpulkan kolom secara otomatis dari dataset.
• Pemanggilan shlex.quote() melakukan escape semua argumen, termasuk prompt pengguna. Ini penting untuk menangani spasi dan karakter khusus serta mencegah risiko injeksi perintah saat meneruskan input pengguna ke perintah shell.

Fungsi mengembalikan string yang diawali dengan: /local-data-analyst. Prefiks ini cocok dengan nama skill yang didefinisikan di SKILL.md. Saat OpenClaw menerima perintah slash ini, ia segera merutekan permintaan ke skill workspace local-data-analyst, yang kemudian mengeksekusi perintah menggunakan alat exec.

Langkah 5.2: Eksekusi OpenClaw

Sekarang kita sudah memiliki perintah slash, kita mengirimkannya ke OpenClaw menggunakan CLI agent runner. Di sinilah aplikasi web menyerahkan eksekusi.

slash_message = build_slash_command(
    data_path=data_path,
    docs_dir=docs_dir,
    output_dir=output_dir,
    prompt=prompt,
    model=model,
    x_col=x_col,
    y_col=y_col,
)
agent_cmd = [
    "openclaw", "agent",
    "--local",
    "--session-id", f"stealth-web-{run_id}",
    "--message", slash_message,
    "--timeout", "120",
]
proc = subprocess.run(agent_cmd, capture_output=True, 
                     text=True, env=openclaw_env())

Pemanggilan agen OpenClaw adalah titik serah di mana aplikasi web berhenti bekerja dan meminta OpenClaw mengeksekusi alur kerja dari awal hingga akhir.

• Menggunakan --local memastikan run tetap di mesin Anda, dan agen memproses permintaan melalui gateway lokal dan model berbasis Ollama alih-alih layanan yang di-host.
• Flag --session-id stealth-web-{run_id} memberikan setiap run namespace sesi yang terisolasi, yang mencegah state saling memengaruhi antarrun dan memudahkan debug eksekusi tertentu nanti.
• Argumen --message meneruskan string perintah slash persis seperti jika pengguna mengetiknya di chat; OpenClaw menerimanya, merutekannya ke skill /local-data-analyst, dan mengeksekusi perintah dasarnya melalui alat exec.
• Terakhir, --timeout 120 bertindak sebagai katup pengaman agar UI web tidak menggantung selamanya jika analisis macet, dan env=openclaw_env() memaksa subprocess menggunakan konfigurasi OpenClaw lokal proyek dan direktori state sehingga secara konsisten menargetkan pengaturan Ollama yang dimaksud.

Pada langkah berikutnya, kita akan memuat artefak yang dihasilkan, termasuk bagan, laporan, dan jejak alat, serta merender pratinjau ringan di browser.

Langkah 5.3: Penyiapan server

Terakhir, web_assistant.py menjalankan server HTTP lokal kecil agar Anda dapat berinteraksi melalui browser.

 def main() -> int:
    host = "127.0.0.1"
    port = 8765
    server = ThreadingHTTPServer((host, port), Handler)
    print(f"Local Data Analyst web UI: http://{host}:{port}")
    print("Press Ctrl+C to stop.")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass
    return 0

Ini membuat penerapan tetap sederhana:

• ThreadingHTTPServer memungkinkan beberapa permintaan tanpa memblokir seluruh aplikasi.
• Semua “pekerjaan nyata” terjadi di Handler permintaan, yang menerima unggahan, membuat folder run, memicu OpenClaw, dan mengembalikan pratinjau.

Catatan: Implementasi kode lengkap web_assistant.py tersedia di repositori GitHub proyek.

Langkah 6: Bangun mesin analisis lokal

Pada titik ini, OpenClaw sudah dapat mengeksekusi alur kerja melalui skill workspace, dan UI web dapat memicu run melalui perintah slash. Komponen yang tersisa adalah mesin analisis yang mengambil file yang Anda unggah, menjalankan langkah-langkah alur kerja, dan menghasilkan artefak.

File main.py di repo ini berfokus pada dua fungsi yang mendefinisikan inti pipeline, yaitu memuat data tabular dan memanggil Ollama untuk penalaran lokal.

Langkah 6.1: Memuat data tabular

Helper ini mendukung beberapa format input sekaligus menjaga alur kerja tetap konsisten.

def load_tabular_data(data_path: Path, events: List[SkillEvent]) -> pd.DataFrame:
    ext = data_path.suffix.lower()
    if ext == ".csv":
        df = pd.read_csv(data_path)
    elif ext in {".tsv", ".tab"}:
        df = pd.read_csv(data_path, sep="\t")
    elif ext in {".json", ".jsonl"}:
        try:
            df = pd.read_json(data_path)
        except ValueError:
            df = pd.read_json(data_path, lines=True)
    elif ext in {".xlsx", ".xls"}:
        df = pd.read_excel(data_path)
    else:
        raise ValueError(f"Unsupported data file...")
    log_event(events, "fs", "read", f"Loaded data file: {data_path.name}")
    return df

Fungsi load_tabular_data() mendeteksi jenis file menggunakan data_path.suffix dan merutekannya ke loader pandas yang sesuai. File CSV dan TSV ditangani dengan read_csv(), di mana file TSV/tab cukup mengganti delimiter ke \t. Input JSON ditangani menggunakan read_json() terlebih dahulu, dan jika pandas melempar ValueError, ia kembali ke lines=True untuk JSONL. Dukungan Excel ditambahkan melalui read_excel() sehingga pengguna dapat mengunggah file .xlsx tanpa pra‑prosesing.

Terakhir, pemanggilan log_event() mencatat entri jejak terstruktur yang nantinya dapat diserialkan pipeline ke tool_trace.json.

Langkah 6.2: Integrasi Ollama

Karena demo ini tidak bergantung pada SDK, ia memanggil API HTTP lokal Ollama secara langsung.

def ollama_generate(model: str, prompt: str) -> str:
    url = "http://localhost:11434/api/generate"
    payload = json.dumps({
        "model": model, 
        "prompt": prompt, 
        "stream": False
    }).encode("utf-8")
    req = request.Request(url, data=payload, 
                         headers={"Content-Type": "application/json"})    
    with request.urlopen(req, timeout=45) as resp:
        body = json.loads(resp.read().decode("utf-8"))
    return str(body.get("response", "")).strip()

Fungsi ollama_generate() mengirim payload JSON ke endpoint /api/generate milik Ollama di localhost. Payload menentukan nama model (misalnya, qwen3:8b), string prompt final, dan menonaktifkan streaming sehingga fungsi mengembalikan satu respons lengkap.

Menggunakan urllib.request membuat pembungkus ini ringan dan portabel, dan penjaga timeout=45 mencegah alur kerja kita menggantung tanpa batas jika model lambat atau server mati. Terakhir, fungsi mengekstrak output model dari field response dan mengembalikan teks bersih, yang nantinya digunakan untuk menulis file analysis_report.md.

Langkah 7: Bangun server web

Berikut skrip peluncur kecil untuk memulai UI web lokal yang menerima unggahan dan memicu run OpenClaw di belakang layar.

set -euo pipefail
ROOT="$(cd "$(dirname "$0")" && pwd)"
cd "$ROOT/.."
python3 ../web_assistant.py

Skrip ini melakukan tiga hal:

• set -euo pipefail membuat skrip gagal cepat, yaitu berhenti saat terjadi kesalahan, memperlakukan variabel yang tidak disetel sebagai kesalahan, dan menghindari kegagalan diam-diam dalam pipeline.
• ROOT=... menentukan direktori tempat skrip berada, sehingga tetap berfungsi bahkan jika Anda menjalankannya dari tempat lain.
• cd "$ROOT/.." berpindah ke root proyek yang diharapkan lalu menjalankan web_assistant.py, yang meng-host UI dan menangani pipeline lengkap.

Setelah skrip ini berjalan, UI browser Anda menjadi pintu masuk untuk demo.

Langkah 8: Mulai sistem

Untuk langkah terakhir, kita menjalankan sistem menggunakan pengaturan dua proses. Gateway OpenClaw menangani semua eksekusi tugas, sementara antarmuka web berfungsi sebagai lapisan pengguna untuk mengirimkan permintaan dan melihat output yang dihasilkan.

Terminal 1: Gateway

Sebelum meluncurkan antarmuka, kita terlebih dahulu memulai gateway OpenClaw. Proses ini bertindak sebagai lapisan eksekusi untuk sistem, menangani permintaan agen, memuat skill workspace, memanggil alat lokal, dan merutekan panggilan penalaran ke model Ollama.

export OPENCLAW_CONFIG_PATH="$PWD/.openclaw-local/openclaw.json"
openclaw gateway --force

Di terminal ini, OPENCLAW_CONFIG_PATH mengarahkan OpenClaw ke konfigurasi lokal proyek, tempat kita menetapkan model default ke ollama/qwen3:8b dan menonaktifkan penelusuran web demi privasi. Selanjutnya, openclaw gateway --force memulai gateway bahkan jika OpenClaw mengira ada sesuatu yang sudah berjalan atau sebagian terkonfigurasi.

Saat gateway aktif, ia siap menerima pesan agen lokal (termasuk perintah slash /local-data-analyst kita).

Terminal 2: Web UI

Setelah gateway berjalan, kita meluncurkan antarmuka web, yang mengumpulkan input pengguna, mengirim setiap permintaan ke agen OpenClaw lokal, dan menampilkan bagan, laporan, serta jejak eksekusi yang dihasilkan.

./local_data_analyst/run_web.sh

Lalu buka:

http://127.0.0.1:8765

Server web berjalan di 127.0.0.1, jadi hanya dapat diakses dari mesin Anda. Saat Anda mengeklik Run Analysis, UI menulis folder run, menyusun perintah slash, memanggil openclaw agent --local, lalu memeriksa disk untuk file output agar dapat menampilkan pratinjau:

• trend_chart.png
• analysis_report.md
• tool_trace.json

Output akhir akan terlihat seperti ini. Anda dapat menguji demo ini menggunakan beberapa file contoh.

Kesimpulan

Dalam tutorial ini, kita membangun aplikasi AI yang mengutamakan lokal, di mana antarmuka web sederhana memicu alur kerja agen penuh yang didukung oleh OpenClaw dan model Ollama lokal. Alih-alih memanggil API eksternal, sistem menjaga seluruh loop tetap di mesin Anda.

OpenClaw menangani orkestrasi dan eksekusi alat, sementara Ollama menyediakan lapisan kecerdasan lokal. Hasilnya adalah alur kerja bergaya agen di mana satu permintaan menghasilkan artefak terstruktur seperti visualisasi, laporan, dan jejak audit.

Dari sini, Anda dapat memperluas proyek ini ke beberapa arah. Anda bisa menambahkan skill workspace baru untuk alur kerja berbeda, mengintegrasikan alat lokal tambahan (misalnya, kueri basis data atau pencarian dokumen), atau menghubungkan OpenClaw ke kanal perpesanan seperti Slack atau WhatsApp untuk akses jarak jauh yang aman.

Anda juga dapat bereksperimen dengan model Ollama yang berbeda untuk menyeimbangkan kinerja dan kualitas berdasarkan perangkat keras Anda.

Untuk mempelajari lebih lanjut tentang bekerja dengan AI dalam alur kerja Anda, saya sarankan melihat kursus AI-Assisted Coding for Developers. Saya juga menyarankan untuk melihat panduan Moltbook kami.