Forem: Nisit Sirimarnkit

สร้าง AI Agent บน LINE ด้วย Garudust (Rust) — ตั้งแต่ต้นจนใช้งานได้จริง

Nisit Sirimarnkit — Thu, 14 May 2026 05:06:47 +0000

ถ้าคุณอยากมี AI Agent ส่วนตัวที่คุยได้ผ่าน LINE โดยไม่ต้องพึ่ง no-code platform บทความนี้จะพาคุณทำตั้งแต่ต้นจนจบ เครื่องมือที่ใช้คือ Garudust — AI Agent framework เขียนด้วย Rust รองรับ OpenAI, Anthropic, Ollama, vLLM และ OpenAI-compatible endpoint ทุกเจ้า

สิ่งที่ต้องมี

เซิร์ฟเวอร์ Linux หรือ macOS (หรือรันบน VPS ก็ได้)
บัญชี LINE Developers (ฟรี) → developers.line.biz
API Key จาก OpenAI, Anthropic, หรือ endpoint อื่นๆ
ngrok — เฉพาะกรณีรันบนเครื่องตัวเองที่ไม่มี public IP

1. ติดตั้ง Garudust

วิธีที่ 1 — ดาวน์โหลด binary

ไปที่ Releases แล้วดาวน์โหลดไฟล์ที่ตรงกับระบบของคุณ:

# Linux x86_64
curl -LO https://github.com/garudust-org/garudust-agent/releases/latest/download/garudust-v0.3.1-x86_64-unknown-linux-musl.tar.gz
tar -xzf garudust-*.tar.gz
sudo mv garudust*/garudust garudust*/garudust-server /usr/local/bin/

วิธีที่ 2 — Build จาก source (ต้องมี Rust 1.87+)

git clone https://github.com/garudust-org/garudust-agent.git
cd garudust-agent
cargo build --release --bin garudust --bin garudust-server
sudo cp target/release/garudust target/release/garudust-server /usr/local/bin/

ตรวจสอบว่าติดตั้งสำเร็จ:

garudust --version
garudust-server --version

2. ตั้งค่า LINE Messaging API

เข้าไปที่ LINE Developers Console
สร้าง Provider ใหม่ (หรือใช้อันที่มีอยู่)
สร้าง Channel ประเภท Messaging API
ที่ tab Basic settings → คัดลอก Channel secret
ที่ tab Messaging API → คลิก Issue เพื่อสร้าง Channel access token (long-lived)
เปิด Use webhook → toggle เป็น Enable

เก็บค่าสองอย่างนี้ไว้:

LINE_CHANNEL_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
LINE_CHANNEL_TOKEN=eyJhbGci...

3. ตั้งค่าไฟล์ config

Garudust แยก secret ออกจาก config เป็น 2 ไฟล์:

~/.garudust/.env — credentials เท่านั้น (ห้าม commit)
~/.garudust/config.yaml — ตั้งค่าพฤติกรรม, platform, port (แชร์ได้)

`~/.garudust/.env`

# LLM provider
ANTHROPIC_API_KEY=sk-ant-...

# LINE adapter — tokens ต้องอยู่ใน .env เสมอ
LINE_CHANNEL_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
LINE_CHANNEL_TOKEN=eyJhbGci...

`~/.garudust/config.yaml`

provider: anthropic
model: claude-sonnet-4-6

system_prompt: |
  คุณคือผู้ช่วย AI ชื่อ "น้องการุด" พูดภาษาไทย ตอบสั้นกระชับ
  ช่วยงานด้านข้อมูล วิเคราะห์ข้อความ และตอบคำถามทั่วไป
  ไม่ตอบเนื้อหาที่ไม่เหมาะสม

platforms:
  line:
    enabled: true
    port: 3002
    webhook_path: /line      # webhook URL: https://your-host/line

หลักการ: config.yaml เก็บโครงสร้าง (enabled, port, webhook_path) ส่วน .env เก็บ secret (LINE_CHANNEL_SECRET, LINE_CHANNEL_TOKEN) เท่านั้น

เมื่อรัน garudust-server แล้ว Garudust จะเปิด HTTP server รอรับ webhook จาก LINE ที่ 0.0.0.0:3002/line โดยอัตโนมัติ — ไม่ต้องตั้งค่า webhook server เพิ่มเอง

4. รัน garudust-server

garudust-server

ดู log จะเห็น:

INFO garudust_server: LINE webhook listening on 0.0.0.0:3002/line
INFO garudust_server: API server listening on 0.0.0.0:3000

Port mapping ของ Garudust:

Port	ใช้สำหรับ
`3000`	HTTP API หลัก (`/chat`, `/health`, `/metrics`)
`3001`	Generic webhook
`3002`	LINE adapter
`3003`	WhatsApp adapter

5. ตั้งค่า Webhook URL ใน LINE Developers Console

ขั้นตอนนี้แตกต่างกันตามสภาพแวดล้อม:

กรณี A — VPS หรือเซิร์ฟเวอร์ที่มี public IP (Production)

ไม่ต้องใช้ ngrok — LINE เข้าถึง server ของคุณได้ตรงๆ ผ่าน nginx

ตั้งค่า nginx reverse proxy ก่อน (ดูขั้นตอนที่ 7) แล้วใช้ URL:

https://yourdomain.com/line

กรณี B — เครื่องตัวเองที่ไม่มี public IP (Dev/ทดสอบ)

LINE ไม่สามารถเข้าถึง localhost ได้และต้องการ HTTPS — ใช้ ngrok สร้าง tunnel ชั่วคราว:

ngrok http 3002

ngrok จะแสดง URL เช่น:

Forwarding  https://abc123.ngrok-free.app -> http://localhost:3002

webhook URL ของคุณคือ:

https://abc123.ngrok-free.app/line

หมายเหตุ: ngrok free tier เปลี่ยน URL ทุกครั้งที่รีสตาร์ท เหมาะสำหรับทดสอบเท่านั้น ใช้ VPS หรือ ngrok paid plan สำหรับ production

ตั้ง webhook URL ใน LINE Developers Console:

Tab Messaging API → ส่วน Webhook settings
ใส่ URL ตามสภาพแวดล้อมของคุณ (จากด้านบน)
คลิก Verify — ควรได้ "Success"
เปิด Use webhook ให้เป็น Enable

ลองส่งข้อความหา LINE Official Account ของคุณ — AI จะตอบกลับทันที

6. เพิ่ม Cron Job (ทำงานอัตโนมัติ)

Garudust มีระบบ cron ในตัว ตั้งค่าใน .env:

# ส่ง briefing ทุกเช้า 8 โมง
GARUDUST_CRON_JOBS="0 8 * * *=สรุปข่าวเทคโนโลยีไทยวันนี้ บันทึกลงไฟล์ ~/briefing.md"

# รวบรวม memory อัตโนมัติทุกคืน 03:00
GARUDUST_MEMORY_CRON="0 3 * * *"

7. Deploy Production (systemd + nginx)

nginx reverse proxy

LINE ต้องการ HTTPS — nginx จัดการ SSL แล้ว proxy ต่อไปยัง Garudust บน port 3002:

# /etc/nginx/sites-available/garudust
server {
    listen 443 ssl;
    server_name yourdomain.com;

    ssl_certificate     /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

    # LINE webhook — proxy ไปที่ Garudust LINE adapter port 3002
    location /line {
        proxy_pass http://127.0.0.1:3002;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    # HTTP API หลัก
    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
    }
}

sudo ln -s /etc/nginx/sites-available/garudust /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

systemd service

# /etc/systemd/system/garudust.service
[Unit]
Description=Garudust AI Agent Server
After=network.target

[Service]
Type=simple
User=ubuntu
ExecStart=/usr/local/bin/garudust-server
Restart=on-failure
RestartSec=5
EnvironmentFile=/home/ubuntu/.garudust/.env
WorkingDirectory=/home/ubuntu

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now garudust
sudo systemctl status garudust

webhook URL สำหรับตั้งใน LINE Console:

https://yourdomain.com/line

สรุป config ทั้งหมด

~/.garudust/.env — secrets เท่านั้น

ANTHROPIC_API_KEY=sk-ant-...
LINE_CHANNEL_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
LINE_CHANNEL_TOKEN=eyJhbGci...
GARUDUST_MEMORY_CRON="0 3 * * *"

~/.garudust/config.yaml — พฤติกรรมและโครงสร้าง

provider: anthropic
model: claude-sonnet-4-6

system_prompt: |
  คุณคือผู้ช่วย AI ชื่อ "น้องการุด" พูดภาษาไทย ตอบสั้นกระชับ

platforms:
  line:
    enabled: true
    port: 3002
    webhook_path: /line

สรุปขั้นตอนตามสภาพแวดล้อม

	Dev (localhost)	Production (VPS)
Garudust รัน webhook ที่	`localhost:3002/line`	`localhost:3002/line`
เปิด HTTPS ด้วย	ngrok tunnel	nginx + Let's Encrypt
Webhook URL ใน LINE Console	`https://xxx.ngrok-free.app/line`	`https://yourdomain.com/line`
ngrok	✅ จำเป็น	❌ ไม่ต้อง

Garudust รองรับ OpenAI, Anthropic, Ollama, vLLM และ OpenAI-compatible endpoint ทุกเจ้า — เปลี่ยน provider ได้แค่แก้ 2 บรรทัดใน config.yaml แล้วรีสตาร์ท

GitHub: garudust-org/garudust-agent
Docs: garudust-org.github.io/garudust-agent

ถ้ามีคำถามหรือเจอปัญหา เปิด Issue บน GitHub ได้เลย หรือ comment ไว้ด้านล่างครับ

ใช้งาน Garudust Agent ร่วมกับ Typhoon Thai LLM: คู่มือฉบับสมบูรณ์

Nisit Sirimarnkit — Wed, 13 May 2026 14:07:29 +0000

Garudust เป็น AI agent ที่เขียนด้วย Rust — binary ขนาด ~10 MB, cold start ไม่ถึง 20 มิลลิวินาที และมี persistent memory ที่จำทุกอย่างข้ามหลาย session

แต่ถ้างานที่ทำเป็นภาษาไทยล้วนๆ — เขียนอีเมลธุรกิจ, ตอบลูกค้า LINE OA, สรุปเอกสารราชการ — การใช้ Typhoon โมเดลภาษาไทยจาก SCB 10X จะได้ผลลัพธ์ที่ดีกว่าอย่างชัดเจน

Typhoon มี free API ที่ compatible กับ OpenAI ที่ https://api.opentyphoon.ai/v1 ซึ่งหมายความว่า Garudust เชื่อมต่อได้ทันทีด้วยการตั้งค่า 2 บรรทัด ไม่ต้องแก้โค้ดแม้แต่บรรทัดเดียว

สิ่งที่ต้องเตรียม

Linux, macOS หรือ Windows (WSL2)
Rust 1.75+ — หรือดาวน์โหลด pre-built binary เลยก็ได้
API key จาก opentyphoon.ai (ฟรี)

ขั้นตอนที่ 1 — ขอ Typhoon API Key

ไปที่ opentyphoon.ai สมัครบัญชีฟรี แล้ว generate API key จาก dashboard

API key จะมีหน้าตาประมาณนี้:

sk-ty-xxxxxxxxxxxxxxxxxxxxxxxxxxxx

Free tier ใช้งานได้กับทั้ง 2 โมเดล:

โมเดล	Req/วินาที	Req/นาที	เหมาะกับ
`typhoon-v2.1-12b-instruct`	5	200	งานทั่วไป, ตอบเร็ว
`typhoon-v2.5-30b-a3b-instruct`	5	200	งานซับซ้อน, reasoning

สำหรับงาน agent ส่วนใหญ่ แนะนำ typhoon-v2.1-12b-instruct ก่อน — เร็วกว่าและเหมาะกับ multi-turn loop มากกว่า

หมายเหตุ: Free API มี rate limit และไม่เหมาะกับ production workload หนักๆ สำหรับการใช้งานจริงในระดับ enterprise รอ production API บน AWS ที่ Typhoon วางแผนจะเปิดในปี 2026

ขั้นตอนที่ 2 — ติดตั้ง Garudust

วิธีที่ 1: ดาวน์โหลด binary สำเร็จรูป (แนะนำ)

# Linux x86_64
curl -LO https://github.com/garudust-org/garudust-agent/releases/latest/download/garudust-x86_64-unknown-linux-musl.tar.gz
tar -xzf garudust-x86_64-unknown-linux-musl.tar.gz
sudo mv garudust garudust-server /usr/local/bin/

แพลตฟอร์ม	ไฟล์
Linux x86_64	`garudust-*-x86_64-unknown-linux-musl.tar.gz`
Linux ARM64	`garudust-*-aarch64-unknown-linux-musl.tar.gz`
macOS Apple Silicon	`garudust-*-aarch64-apple-darwin.tar.gz`
macOS Intel	`garudust-*-x86_64-apple-darwin.tar.gz`
Windows	`garudust-*-x86_64-pc-windows-msvc.zip`

วิธีที่ 2: ติดตั้งจาก crates.io

cargo install garudust garudust-server

ตรวจสอบว่าติดตั้งสำเร็จ:

garudust --version
# garudust 0.2.8

ขั้นตอนที่ 3 — เชื่อมต่อ Garudust กับ Typhoon

Garudust แยก config ออกจาก secret เป็น 2 ไฟล์ใน ~/.garudust/:

config.yaml — ชื่อโมเดล, provider, ค่าพฤติกรรมต่างๆ (แชร์ได้)
.env — API key อย่างเดียว (ห้าม commit เด็ดขาด)

สร้างไฟล์ ~/.garudust/config.yaml:

# เชื่อมต่อ Typhoon ผ่าน OpenAI-compatible endpoint
provider: vllm
model: typhoon-v2.1-12b-instruct
base_url: https://api.opentyphoon.ai/v1

# Context window สำหรับโมเดล 12B
context_window: 8192
compression:
  enabled: true
  threshold_fraction: 0.65

# Memory nudge — บันทึก fact ทุก 5 iteration
nudge_interval: 5

สร้างไฟล์ ~/.garudust/.env:

# Typhoon API key
VLLM_API_KEY=sk-ty-xxxxxxxxxxxxxxxxxxxxxxxxxxxx

ทำไมใช้ VLLM_API_KEY?

Garudust ส่ง key นี้เป็น Authorization: Bearer header ไปยัง base_url ที่กำหนด Typhoon API รับ format นี้ได้ตรงๆ เลย

หรือจะใช้ setup wizard ก็ได้:

garudust setup

เลือก provider เป็น vllm แล้วกรอก base_url และ model ตามด้านบน

ขั้นตอนที่ 4 — ตรวจสอบการเชื่อมต่อ

garudust doctor

ถ้าทุกอย่างถูกต้องจะเห็น:

✓ Config loaded     provider=vllm  model=typhoon-v2.1-12b-instruct
✓ API key present   VLLM_API_KEY
✓ LLM reachable     https://api.opentyphoon.ai/v1 → 200 OK
✓ Memory dir        ~/.garudust/memory/ (0 entries)
✓ Session DB        ~/.garudust/sessions.db

ขั้นตอนที่ 5 — ทดสอบสนทนาภาษาไทย

เปิด TUI แบบ interactive:

garudust

ลองพิมพ์:

คุณ: สวัสดีครับ ช่วยแนะนำตัวเองหน่อยได้ไหม

Agent จะตรวจจับภาษาไทยโดยอัตโนมัติและตอบกลับเป็นภาษาไทย โดยไม่ต้องตั้งค่าภาษาเพิ่มเติม

หรือใช้แบบ one-shot:

garudust "สรุปข้อดีข้อเสียของการเปิดบริษัทในไทยแบบสั้นๆ"

ขั้นตอนที่ 6 — ตั้งให้ตอบไทยเป็นค่าเริ่มต้นถาวร

บอก agent ครั้งเดียว มันจำตลอด:

คุณ: ตั้งแต่นี้ไปตอบเป็นภาษาไทยเสมอ ยกเว้นถ้าฉันถามเป็นภาษาอื่น
Agent: [บันทึกลง memory] เข้าใจแล้วครับ จะตอบเป็นภาษาไทยใน session หน้าทุกครั้ง

Garudust บันทึกลง ~/.garudust/memory/ และโหลดขึ้นมาทุก session โดยอัตโนมัติ ไม่ต้องบอกซ้ำอีก

ตัวอย่างการใช้งานจริง

เขียนอีเมลธุรกิจภาษาไทย

garudust "เขียนอีเมลทางการถึงพาร์ทเนอร์ แจ้งว่าต้องการต่อสัญญา partnership อีก 1 ปี พร้อมเสนอเพิ่มงบ 15% และขอนัดประชุมสัปดาห์หน้า"

สรุปเอกสาร PDF ภาษาไทย

garudust "อ่านไฟล์นี้แล้วสรุปประเด็นสำคัญเป็นภาษาไทย 5 ข้อ: /path/to/contract.pdf"

Agent จะเรียก pdf_read tool โดยอัตโนมัติ แล้วสรุปเนื้อหาให้

เขียน template ตอบ LINE OA

garudust "เขียน template ตอบลูกค้าใน LINE OA สำหรับคำถามเรื่อง shipping 5 แบบ ให้เป็นภาษาไทยที่สุภาพและเป็นมิตร พร้อมระบุวันจัดส่งโดยประมาณ"

สร้าง skill ภาษาไทยให้ใช้ซ้ำได้

คุณ: สร้าง skill สำหรับเขียนรายงานสรุปประจำสัปดาห์เป็นภาษาไทย พร้อม format หัวข้อ ผลงานที่ทำ ปัญหาที่พบ และแผนสัปดาห์หน้า
Agent: [เรียก write_skill]
       บันทึก skill 'weekly-report-th' ไปยัง ~/.garudust/skills/weekly-report-th/SKILL.md แล้ว

ครั้งต่อไปแค่พิมพ์:

garudust "ใช้ skill weekly-report-th สรุปสัปดาห์นี้"

ส่ง briefing ภาษาไทยทุกเช้า (Cron)

เพิ่มใน ~/.garudust/.env:

GARUDUST_CRON_JOBS="0 8 * * *=ค้นหาข่าวเศรษฐกิจและเทคโนโลยีไทยล่าสุด สรุปเป็นรายการ 5 ข้อ บันทึกลงไฟล์ ~/briefing-th.md"

เปิด server:

garudust-server

ทุกวันตี 8 โมงเช้า agent จะค้นหาข่าว สรุปเป็นภาษาไทย และบันทึกไฟล์ให้โดยอัตโนมัติ

เปลี่ยนเป็นโมเดลใหญ่เมื่อต้องการ

สำหรับงานที่ซับซ้อนกว่า เช่น วิเคราะห์สัญญา หรือ multi-step planning:

# เปลี่ยนชั่วคราวใน TUI
/model typhoon-v2.5-30b-a3b-instruct

# หรือเปลี่ยนถาวร
garudust config set model typhoon-v2.5-30b-a3b-instruct

อย่าลืมอัปเดต context_window ใน config.yaml ด้วย:

model: typhoon-v2.5-30b-a3b-instruct
context_window: 32768

แก้ปัญหาเบื้องต้น

อาการ	สาเหตุ	วิธีแก้
`HTTP 401 Unauthorized`	API key ผิด	ตรวจสอบ `VLLM_API_KEY` ใน `~/.garudust/.env`
`HTTP 429 Too Many Requests`	เกิน rate limit	รอ ~1 นาที — Garudust retry อัตโนมัติ
Agent ตอบภาษาอังกฤษตลอด	ยังไม่ได้ตั้ง memory	บอกครั้งเดียว: "ตอบเป็นภาษาไทยเสมอ"
Agent ไม่เรียก tool	โมเดลข้าม tool call	ระบุชัดขึ้น: "ใช้ web_search หา..." หรือเปลี่ยนเป็น 30B
Context เกิน	prompt ยาวเกินไป	ลด `context_window` หรือเปิด compression

Config สรุปฉบับสมบูรณ์

# ~/.garudust/config.yaml

# --- LLM ---
provider: vllm
base_url: https://api.opentyphoon.ai/v1
model: typhoon-v2.1-12b-instruct    # หรือ typhoon-v2.5-30b-a3b-instruct

# --- Context ---
context_window: 8192                # 8192 สำหรับ 12B, 32768 สำหรับ 30B
compression:
  enabled: true
  threshold_fraction: 0.65

# --- Memory ---
nudge_interval: 5                   # บันทึก fact ทุก 5 iteration (0 = ปิด)

# ~/.garudust/.env
VLLM_API_KEY=sk-ty-xxxxxxxxxxxxxxxxxxxxxxxxxxxx

ลิงก์ที่เกี่ยวข้อง

Garudust: github.com/garudust-org/garudust-agent
Typhoon API: opentyphoon.ai
Typhoon Docs: docs.opentyphoon.ai
Typhoon Rate Limits: docs.opentyphoon.ai/en/rate-limits
Garudust Latest Release: v0.2.8

Garudust + Typhoon = AI agent ที่รันบน hardware ของคุณเอง พูดภาษาไทยได้ดี และไม่ส่งข้อมูลออกนอกบ้านถ้าคุณ self-host Typhoon เอง

Garudust: A Self-Improving AI Agent Runtime Built in Rust

Nisit Sirimarnkit — Wed, 13 May 2026 08:31:13 +0000

WELCOME Garudian!!!

Most AI agent frameworks share the same two problems: they're heavy to deploy, and they forget everything the moment a session ends.

Garudust takes a different approach. It's a self-hostable AI agent runtime written entirely in Rust — a single ~10 MB binary that starts in under 20 milliseconds, remembers what you teach it across sessions, and gets smarter with every conversation.

No Python runtime. No Docker required for local use. No cloud dependency.

Current release: v0.2.8 — released 12 May 2025. The project moved from v0.1.0 to v0.2.8 in under two weeks, so it's moving fast.

What Makes Garudust Different?

There's no shortage of AI agent frameworks. Here's why Garudust stands out:

	Garudust	Python-based agents
Binary size	~10 MB	100–500 MB (with deps)
Cold start	< 20 ms	2–10+ seconds
Memory	Persistent across sessions	Usually in-memory only
Self-improvement	Built-in skill learning loop	Manual, if at all
Multi-platform	Telegram, Discord, Slack, LINE, WhatsApp, Matrix, HTTP	Varies
LLM backends	Any OpenAI-compatible + Bedrock	Varies

The self-improvement loop is what makes it genuinely different. When Garudust discovers a repeatable multi-step workflow during a session, it writes a skill file automatically. Next time you ask for the same thing, it already knows how to do it.

Architecture at a Glance

Garudust is a multi-crate Rust workspace. Every concern is its own crate:

crates/
  garudust-core        Shared traits & types — zero I/O
  garudust-transport   LLM adapters (Anthropic, OpenRouter, Bedrock, Ollama, vLLM, …)
  garudust-tools       Tool registry + built-in toolsets
  garudust-memory      FileMemoryStore (markdown) + SessionDb (SQLite + FTS5)
  garudust-agent       Agent run loop, context compressor, prompt builder
  garudust-platforms   Telegram, Discord, Slack, LINE, WhatsApp, Matrix, Webhook
  garudust-cron        Cron scheduler
  garudust-gateway     axum HTTP gateway — /chat, /chat/stream, /chat/ws, /metrics

bin/
  garudust             CLI: interactive TUI, one-shot, setup, doctor, config
  garudust-server      Headless: all platforms + HTTP + cron in one process

This composable design means you can add a new tool, platform adapter, or LLM transport without touching anything outside the relevant crate. Most contributions are under 100 lines.

Getting Started in 3 Minutes

Install

Download a pre-built binary from GitHub Releases — no Rust required:

tar -xzf garudust-*-x86_64-unknown-linux-musl.tar.gz
sudo mv garudust garudust-server /usr/local/bin/

Or install directly from crates.io:

cargo install garudust garudust-server

Or build from source (requires Rust 1.75+):

git clone https://github.com/garudust-org/garudust-agent
cd garudust-agent
cargo build --release

Configure

Run the setup wizard — it walks you through provider selection and saves your API key:

garudust setup

Garudust supports: Anthropic, OpenRouter, AWS Bedrock, Ollama, vLLM, or any OpenAI-compatible endpoint. Swap providers with a single env var — no code changes needed.

The wizard pre-fills existing values and masks secrets. Press Enter to keep a value unchanged — a small detail that makes re-configuration much less painful.

Chat

garudust   # interactive TUI

Or run a one-shot task:

garudust "summarise the git log from the last 7 days into a changelog"
garudust --model anthropic/claude-opus-4-7 "review this PR for security issues"

Persistent Memory

This is the feature that changes how you work with the agent day to day.

Garudust automatically saves facts to ~/.garudust/memory/ — preferences, project conventions, corrections you make:

You: always format JSON with 2-space indent
Agent: Got it — I'll use 2-space indent for JSON from now on.

The next session starts with that preference already loaded. You never repeat yourself.

A built-in nudge fires every few iterations during long tasks, prompting the agent to persist new facts before the session ends:

# ~/.garudust/config.yaml
nudge_interval: 5   # inject memory reminder every 5 LLM iterations (0 = off)

Memory is also protected from prompt injection — recalled facts are wrapped in <untrusted_memory> tags so the model treats them as data, not instructions.

What gets saved:

Preferences — output format, language, tone, tool choices
Project details — paths, configs, conventions, known quirks
Corrections — anything you tell the agent to stop doing

What does not get saved: session logs, task progress, one-off details. Only facts that will matter in future sessions.

The Skill System

Skills are reusable instruction sets stored as plain Markdown files in ~/.garudust/skills/. They're hot-reloaded on every call — edit a file and the next message picks up the change immediately.

~/.garudust/skills/
  git-workflow/SKILL.md
  daily-standup/SKILL.md
  rust-code-review/SKILL.md

Skills are created automatically

When Garudust discovers a multi-step workflow, it writes the skill itself:

You: write a skill for reviewing Rust PRs
Agent: [calls write_skill]
       Saved to ~/.garudust/skills/rust-code-review/SKILL.md

Skills stay up to date

The skill reflection pipeline (v0.2.0) automatically updates skills after complex tasks. If steps are outdated or wrong, the agent patches the file — no manual maintenance required.

Skill-level tool permissions (v0.2.1)

Each skill declares exactly which tools it's allowed to use via frontmatter:

---
name: git-workflow
description: Opinionated Git commit and PR workflow
version: 1.0.0
tools: [terminal, read_file, write_file]
---

Always write conventional commits. Run tests before pushing.
Open a draft PR first, then mark ready when CI is green.

This limits the blast radius of any skill — it can't call tools it hasn't declared.

Install skills from the hub (v0.2.5)

garudust skill install facebook-workflow
garudust skill list
garudust skill uninstall facebook-workflow

Skills pull from garudust-hub and install their required tools automatically. If the tool needs a runtime (python3, node, etc.) that isn't on PATH, you get a warning immediately at install time — not a silent failure at run time.

Multi-Platform Gateway

garudust-server runs HTTP, all platform adapters, and cron jobs in a single process. Set the relevant env vars and start the server — every adapter runs together.

Platform	Required env var(s)
Telegram	`TELEGRAM_TOKEN`
Discord	`DISCORD_TOKEN`
Slack	`SLACK_BOT_TOKEN` + `SLACK_APP_TOKEN`
LINE	`LINE_CHANNEL_SECRET` + `LINE_CHANNEL_ACCESS_TOKEN`
WhatsApp	Meta Cloud API credentials
Matrix	`MATRIX_HOMESERVER` + `MATRIX_USER` + `MATRIX_PASSWORD`
HTTP	Always-on at `POST /chat` — no token needed

TELEGRAM_TOKEN=123:ABC \
LINE_CHANNEL_SECRET=abc... \
garudust-server --anthropic-key sk-ant-...

One binary, every channel.

HTTP API

Three transport modes:

# Blocking
curl -X POST http://localhost:3000/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "write a haiku about Rust"}'

# Streaming (Server-Sent Events)
curl -X POST http://localhost:3000/chat/stream \
  -H "Content-Type: application/json" \
  -d '{"message": "explain async/await in 3 sentences"}'

# WebSocket: ws://localhost:3000/chat/ws
# Send: {"message": "..."} → Receive: text chunks ... {"done": true}

Prometheus-compatible metrics at /metrics. Health check at /health.

Cron Scheduling

Run agent tasks on a schedule with a single env var:

GARUDUST_CRON_JOBS="0 9 * * *=Write a morning briefing and save to ~/briefing.md" \
garudust-server --anthropic-key sk-ant-...

Combined with the skill system and a platform adapter, this becomes a powerful automation layer — daily social media posts, standup summaries, report generation, or any workflow you can describe in plain text.

Built-in Tools

Tool	What it does	Since
`web_fetch`	Fetch any URL (capped at 512 KB)	v0.1.0
`web_search`	Brave Search API; falls back to DuckDuckGo	v0.1.0
`browser`	Control Chrome via CDP — navigate, click, screenshot, JS	v0.1.0
`read_file` / `write_file`	Filesystem access	v0.1.0
`terminal`	Run shell commands (sandboxed via Docker, opt-in)	v0.1.0
`memory`	Persistent key-value store	v0.1.0
`session_search`	Full-text search across past conversations (SQLite FTS5)	v0.1.0
`delegate_task`	Spawn parallel sub-agents; results returned in order	v0.1.0
`list_directory`	Browse filesystem	v0.2.0
`http_request`	Make REST API calls directly without curl	v0.2.0
`pdf_read`	Extract text from PDF files	v0.2.0
`write_skill`	Create or update skills on the fly	v0.1.0

MCP Support

Connect any MCP server in ~/.garudust/config.yaml:

mcp_servers:
  - name: filesystem
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
  - name: postgres
    command: npx
    args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]

Security

A few things worth highlighting for anyone self-hosting:

Terminal sandbox — shell commands run inside a hardened Docker container (--cap-drop ALL, --security-opt no-new-privileges:true, tmpfs /tmp). Opt-in via terminal_sandbox: docker in config.
ConstitutionalApprover — LLM-based approval gate for commands, not regex that can be bypassed via shell obfuscation.
DNS TOCTOU fix — a custom SafeResolver closes the gap where a hostname could resolve to a private IP between the check and the actual request.
Prompt injection protection — recalled memory is wrapped in <untrusted_memory> tags so the model treats it as data, not instructions.
Structured audit log — every tool call is logged at INFO level with session ID, tool name, and arguments.
LLM retry with exponential backoff — transient 429/5xx errors are retried automatically.

Usage Footer

Every completed task appends a summary (added in v0.2.2):

[5 iter | 24657in 689out tok | ~$0.003 @ Qwen3-14B-AWQ]

Iterations, token counts, estimated cost, and model — useful for understanding what tasks actually cost at scale.

Self-Hosted LLM Support

If you run your own LLM (vLLM, Ollama), Garudust connects with zero friction:

# Ollama
OLLAMA_BASE_URL=http://localhost:11434
GARUDUST_MODEL=llama3.2

# vLLM
VLLM_BASE_URL=http://localhost:8000/v1
VLLM_API_KEY=token-abc123
GARUDUST_MODEL=Qwen/Qwen3-14B-AWQ

No cloud required. Your data stays local.

Docker

echo "OPENROUTER_API_KEY=sk-or-..." > .env
docker compose up

The compose file is included in the repo.

Contributing

Good first issues:

New tool — wrap any CLI or API as a Tool impl in garudust-tools
New platform — implement PlatformAdapter (Signal, etc.)
Improve TUI — multi-line input, syntax highlighting, mouse support
Tests — integration, property, snapshot

git clone https://github.com/garudust-org/garudust-agent
cd garudust-agent
cargo build
cargo test --workspace
cargo clippy --workspace --all-targets -- -W clippy::all -W clippy::pedantic

Build an AI-Powered Auto-Post Bot for Facebook with Garudust

Nisit Sirimarnkit — Wed, 13 May 2026 08:07:57 +0000

Social media managers spend hours crafting posts, finding images, and hitting "publish." What if a single terminal command could do all of that — research a topic, write an engaging post, generate a matching image, and publish it to your Facebook Page automatically?

That's exactly what Garudust does. It's an open-source AI agent written in Rust that connects to any OpenAI-compatible LLM (local or cloud) and runs multi-step workflows through a simple skill system.

In this guide, you'll set up Garudust and run a fully automated Facebook post workflow from scratch.

What You'll Build

One command → one full Facebook post:

garudust "use skill facebook-workflow, post about AI news today, page_id=YOUR_PAGE_ID"

The agent will:

🔍 Search the web for recent news on your topic
📄 Read and summarize the best article it finds
🎨 Generate a matching image with overlay text
✍️ Write a detailed post with hashtags in your target language
📢 Publish everything to your Facebook Page — no manual steps

Prerequisites

Before you start, make sure you have:

Rust (stable) — install via rustup.rs
A Facebook Page you manage
A Facebook Developer App with pages_manage_posts permission
An LLM endpoint — local (vLLM / Ollama) or cloud (OpenRouter / Anthropic)
Optional: A Hugging Face token for AI image generation

Step 1 — Install Garudust

cargo install garudust

Then run the interactive setup wizard:

garudust setup

This creates two files:

~/.garudust/config.yaml — non-secret settings
~/.garudust/.env — API keys and tokens

Step 2 — Configure Your LLM

Garudust separates settings from secrets. Open ~/.garudust/config.yaml:

# Non-secret settings — safe to share or commit
model: Qwen/Qwen3-14B-AWQ    # or gpt-4o, claude-3-5-sonnet, etc.
provider: vllm                # vllm | ollama | anthropic | openrouter
base_url: http://localhost:8000/v1

context_window: 32768
compression:
  enabled: true
  threshold_fraction: 0.65

Then add your secrets to ~/.garudust/.env:

# Secrets only — never put model or URL here
VLLM_API_KEY=your-vllm-key
HF_TOKEN=hf_xxxxxxxxxxxx

💡 Design principle: config.yaml holds everything that isn't a secret (model name, provider, URLs, behavior tuning). .env holds only API keys. This makes it trivial to share your config without leaking credentials.

Using a cloud provider instead? Here's how each maps:

Provider	config.yaml	.env
vLLM (local)	`provider: vllm` + `base_url`	`VLLM_API_KEY`
Ollama (local)	`provider: ollama` + `base_url`	(none needed)
Anthropic	`provider: anthropic`	`ANTHROPIC_API_KEY`
OpenRouter	`provider: openrouter`	`OPENROUTER_API_KEY`

Step 3 — Get a Facebook Page Access Token

Go to developers.facebook.com → My Apps → create a new app
Add the Facebook Login product
Open the Graph API Explorer, select your app and your Page
Generate a token with these permissions:
- pages_manage_posts
- pages_read_engagement
Exchange it for a long-lived Page Access Token (valid 60 days)
Add it to your .env:

FACEBOOK_ACCESS_TOKEN=EAAxxxxxxxxxxxxxxxx

Your Page ID is visible in Page Settings under About, or in the Page URL.

Step 4 — Install the Skill and Tools

garudust skill install facebook-workflow

This pulls the skill from garudust-hub and automatically installs the required tools: facebook_post and generate_image.

Verify everything is in place:

garudust skill list
# ✓ facebook-workflow  v3.0.0

garudust tool list
# ✓ facebook_post
# ✓ generate_image
# ✓ web_search
# ✓ web_fetch

Step 5 — Run Your First Auto-Post

garudust "use skill facebook-workflow, research latest AI news, write a detailed post, generate an image, post to page_id=831735183365530"

Watch the agent work through each step:

[web_search]     searching: AI news 2025...
[web_fetch]      fetching top result...
[generate_image] creating /tmp/fb_post_image.png...
[facebook_post]  publishing to page 831735183365530...

Posted — ID: 831735183365530_122126910027165465
[5 iter | 24657in 689out @ Qwen3-14B-AWQ]

Your post is live. ✅

How It Works Under the Hood

The facebook-workflow skill is a plain Markdown file at:

~/.garudust/skills/facebook-workflow/SKILL.md

It guides the agent through four steps:

Step 1 — Research   →  web_search + web_fetch (1 search, 1 fetch)
Step 2 — Image      →  generate_image (1024×576, with overlay text)
Step 3 — Post       →  facebook_post (page_id + message + image_path)
Step 4 — Report     →  confirm post_id or surface the error

Each step explicitly tells the model which tool to call and when. This prevents weak models from staying in "text mode" and skipping tool calls entirely — a common failure mode in multi-step agent workflows.

Automatic Context Management

For models with small context windows (e.g. 27K tokens), Garudust handles overflow automatically:

Compresses conversation history when it reaches 65% of the context limit
Caps max_tokens at context_window / 8 to always leave room for input
Retries with a smaller output budget (/16 → /32) if the first attempt still overflows

You don't need to think about tokens — just set context_window in config.yaml and the agent handles the rest.

Step 6 — Customize the Post Format

The post format is defined directly in the skill file. Edit it:

nano ~/.garudust/skills/facebook-workflow/SKILL.md

Find the post format section and adjust it to your style:

**Post format (minimum 200 words):**

[hook — 1–2 attention-grabbing sentences, use a question or surprising fact]

[background — why this matters, 2–3 sentences of context]

[main content — facts, figures, and deep details from research, 3–4 sentences]

[real example — a company, product, or case study, 2–3 sentences]

[impact & trends — what this means for the future, 2–3 sentences]

[call to action — ask for opinions or suggest next steps, 1–2 sentences]

#hashtag1 #hashtag2 #hashtag3 #hashtag4 #hashtag5

Want posts in English instead of Thai? Change the language note. Want longer posts? Raise the minimum word count. The model will follow whatever format you define here.

Step 7 — Automate with a Daily Cron Job

Create a shell script:

# /usr/local/bin/daily-ai-post.sh
#!/bin/bash
garudust "use skill facebook-workflow, latest AI technology news, write a detailed post, generate an image, post to page_id=YOUR_PAGE_ID" \
  >> ~/.garudust/post.log 2>&1

Make it executable and add it to cron:

chmod +x /usr/local/bin/daily-ai-post.sh
crontab -e

# Post every day at 9:00 AM
0 9 * * * /usr/local/bin/daily-ai-post.sh

That's it — fully automated daily posts with zero manual work.

Troubleshooting

Symptom	Cause	Fix
`required tool facebook_post not called`	Model skipped the tool call	Retry, or switch to a stronger model
`HTTP 400 context overflow`	Prompt too long for context window	Reduce `context_window` or set a smaller `web_fetch` limit
`FACEBOOK_ACCESS_TOKEN not set`	Missing secret	Add to `~/.garudust/.env`
Post published but has no image	`generate_image` failed silently	Check `HF_TOKEN` in `.env`
Token expired after 60 days	Short-lived token used	Regenerate a long-lived Page Access Token

What to Try Next

Multiple languages — add "write in English" or "write in Japanese" to your task
Topic rotation — pass a topics array in a shell script and pick one per day
Multiple pages — loop over page IDs to cross-post automatically
Custom image styles — edit the generate_image prompt in the skill to match your brand