Sử dụng OpenClaw với Ollama: Xây dựng Chuyên viên phân tích dữ liệu cục bộ

Vì sao chạy OpenClaw với Ollama?

Chạy OpenClaw với mô hình Ollama cục bộ biến hệ thống của bạn thành một môi trường AI khép kín. Thay vì gửi prompt và dữ liệu tới API bên ngoài, toàn bộ quy trình, bao gồm suy luận, truy cập tệp và tạo artifact, đều chạy trên máy của bạn.

Thiết lập này đem lại nhiều lợi thế thực tiễn:

• Riêng tư theo thiết kế: Mọi tập dữ liệu, tài liệu và đầu ra trung gian đều ở lại trên thiết bị. Không có gì được truyền tới dịch vụ bên ngoài.
• Minh bạch và kiểm soát hoàn toàn: Mọi bước đều có thể kiểm tra, từ lệnh slash gửi tới OpenClaw cho tới các tệp được tạo và vết thực thi.
• Hoạt động ngoại tuyến: Sau khi mô hình được kéo về qua Ollama, hệ thống hoạt động không cần internet.
• Thực thi kiểu tác tử: Một yêu cầu của người dùng có thể kích hoạt quy trình đa bước thay vì chỉ một phản hồi văn bản.

Hướng dẫn này tập trung xây dựng kiến trúc tác tử cục bộ, trong đó OpenClaw đóng vai trò động cơ thực thi, còn Ollama cung cấp lớp suy luận.

Hướng dẫn OpenClaw Ollama: Xây dựng Chuyên viên phân tích dữ liệu cục bộ

mTrong phần này, chúng ta sẽ xây dựng ứng dụng Local Data Analyst chạy hoàn toàn trên máy của bạn, sử dụng OpenClaw và mô hình Ollama cục bộ. Ở mức tổng quan, hệ thống thực hiện ba nhiệm vụ cốt lõi:

• Nhận một tập dữ liệu CSV từ người dùng
• Tùy chọn nạp thêm tài liệu ngữ cảnh hỗ trợ (PDF, TXT, hoặc Markdown)
• Chạy quy trình phân tích đa bước để tạo insight và trực quan hóa

Hệ thống tạo ra ba artifact đầu ra:

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

Ở hậu trường, quy trình làm việc được phối hợp bởi ba thành phần:

• Giao diện web(web_assistant.py): Tệp Python này xử lý tải lên tệp, tạo thư mục chạy, và gửi lệnh slash tới OpenClaw.
• Tác tử OpenClaw: Tác tử OpenClaw tải workspace skill, thực thi lệnh cục bộ thông qua các công cụ, và dùng LLM cục bộ được lưu trữ qua Ollama để suy luận và tóm tắt.
• Động cơ phân tích (main.py): Tệp này đọc tập dữ liệu, suy luận các cột liên quan, tạo biểu đồ và insight, và ghi toàn bộ đầu ra xuống đĩa.

Khi quy trình hoàn tất, giao diện web sẽ xem trước các artifact đã tạo, cho phép người dùng xem kết quả và vết thực thi.

Bước 1: Cài đặt OpenClaw

Trước khi xây dựng quy trình Local Data Analyst, chúng ta cần OpenClaw Gateway chạy trên máy của bạn. Hãy coi OpenClaw như lớp thực thi trong dự án này: nhận yêu cầu từ giao diện web, tải workspace skill, chạy các công cụ cục bộ (như lệnh shell và script Python), và điều phối toàn bộ quy trình từ đầu đến cuối.

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

Lệnh này cài đặt OpenClaw CLI, chạy trình hướng dẫn khởi tạo để cấu hình môi trường cục bộ và thiết lập daemon của gateway để có thể khởi động/dừng dễ dàng. Dù chúng ta sẽ chạy gateway ở foreground cho bản demo này, việc cài daemon đảm bảo thiết lập tiêu chuẩn và dễ xử lý sự cố.

Giờ hãy xác nhận mọi thứ hoạt động:

openclaw doctor
openclaw gateway status

Lệnh OpenClaw doctor báo rằng OpenClaw được cài đặt đúng. Lệnh OpenClaw gateway status cho biết gateway hiện có đang chạy không. Ở giai đoạn này, có thể hiển thị “not running”, nhưng không sao. Điểm mấu chốt là lệnh hoạt động và cài đặt đã được nhận diện.

Nếu bạn muốn xem chi tiết mọi tùy chọn khởi tạo (kênh, xác thực, skill, bảo mật gateway), bạn có thể tham khảo hướng dẫn OpenClaw để cài đặt từng bước đầy đủ.

Bước 2: Cài đặt Ollama

Tiếp theo, chúng ta sẽ thiết lập Ollama, đóng vai trò backend LLM cục bộ cho dự án này. OpenClaw vẫn điều phối quy trình, nhưng khi cần trí tuệ mô hình để tóm tắt hay suy luận, nó sẽ gọi LLM qua Ollama. 

Chạy các lệnh sau:

brew install ollama
ollama serve
ollama pull qwen3:8b

Các lệnh trên cài đặt runtime của Ollama, khởi động máy chủ mô hình cục bộ để OpenClaw giao tiếp, và tải mô hình qwen3:8b. Chúng ta dùng qwen3:8b vì cân bằng tốt giữa hiệu năng và chất lượng cho đa số laptop, nhưng bạn có thể chọn mô hình khác tùy tài nguyên hệ thống. Bạn cũng có thể tham khảo hướng dẫn thiết lập từ Ollama. 

Bước 3: Cấu hình OpenClaw

Tiếp theo, chúng ta cần cấu hình OpenClaw để sử dụng instance Ollama cục bộ. Điều này đảm bảo mọi suy luận, tóm tắt và phân tích diễn ra hoàn toàn trên máy của bạn, không gọi API bên ngoài.

Tạo thư mục cấu hình cục bộ:

mkdir -p .openclaw-local

Sau đó tạo tệp:

.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 }
    }
  }
}

Cấu hình trên định nghĩa ba thành phần chính:

• baseUrl trỏ tới endpoint API cục bộ do ollama serve mở, trong khi thiết lập api: openai-completions bật giao tiếp tương thích OpenAI. Đăng ký mô hình qwen3:8b nêu rõ khả năng của nó, bao gồm cửa sổ ngữ cảnh 131K lớn để xử lý tập dữ liệu cỡ lớn và giới hạn token để kiểm soát phản hồi. Vì mô hình chạy cục bộ, mọi chi phí đều đặt về 0.
• Phần agent defaults kiểm soát mô hình mà tác tử OpenClaw dùng cho suy luận. Bằng cách đặt mô hình chính là ollama/qwen3:8b, mọi tác vụ của tác tử như diễn giải prompt, tạo tóm tắt, hay suy luận trên dữ liệu đều được định tuyến tự động tới mô hình Ollama cục bộ mà không cần gọi API bên ngoài.
• Cấu hình công cụ quản lý các khả năng bên ngoài như tìm kiếm web, được tắt để đảm bảo quyền riêng tư và ngăn yêu cầu đi ra ngoài. Công cụ fetch vẫn bật để truy xuất tài nguyên giới hạn khi cần. 

Tổng hợp lại, các thiết lập này đảm bảo toàn bộ quy trình chạy riêng tư trên máy của bạn, với OpenClaw xử lý điều phối và Ollama cung cấp trí tuệ cục bộ.

Bước 4: Định nghĩa workspace skill

Ở bước này, chúng ta định nghĩa workspace skill cho OpenClaw biết cách thực thi quy trình. Thay vì dựa vào mô hình để lập kế hoạch sử dụng công cụ, chúng ta dùng chế độ phân phối lệnh (command dispatch), cho phép một lệnh slash kích hoạt trực tiếp lệnh thực thi cục bộ, giúp quy trình nhanh hơn và hoàn toàn cục bộ.

Hãy tạo tệp SKILL.md sau trong workspace của bạn:

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

Cấu hình skill này điều khiển cách OpenClaw thực thi phân tích:

• Phần front matter (khối metadata có cấu trúc ở đầu tệp) định nghĩa một skill có thể được người dùng gọi tên là local-data-analyst, khả dụng dưới dạng lệnh slash /local-data-analyst.
• Lệnh slash là cách OpenClaw kích hoạt thao tác có cấu trúc từ chat hoặc UI.
• Thiết lập command-dispatch: tool bật chế độ phân phối lệnh, trong đó OpenClaw định tuyến trực tiếp lệnh tới một công cụ thay vì hỏi mô hình cần làm gì.
• Với command-arg-mode: raw, toàn bộ chuỗi lệnh được chuyển nguyên trạng cho công cụ exec, đảm bảo thực thi có thể dự đoán.
• Lệnh chạy script cục bộ main.py, trong đó:
• Nạp tập dữ liệu và tài liệu ngữ cảnh tùy chọn
• Sử dụng Ollama (qwen3:8b) để suy luận và tóm tắt
• Tạo ba artifact gồm biểu đồ, báo cáo markdown và vết thực thi công cụ

Như vậy, OpenClaw xử lý điều phối và thực thi, còn Ollama cung cấp suy luận cục bộ. Ở bước tiếp theo, chúng ta sẽ kết nối skill này với giao diện web để người dùng có thể tải dữ liệu và kích hoạt phân tích chỉ bằng một thao tác.

Bước 5: Tạo giao diện web

Tại thời điểm này, chúng ta đã có hai phần cốt lõi: một workspace skill trên OpenClaw và backend mô hình cục bộ (Ollama) cung cấp suy luận. Giờ cần một giao diện nhẹ cho phép bạn tải tệp và kích hoạt chạy mà không phải chạm vào terminal mỗi lần.

Tệp web_assistant.py đóng vai trò máy chủ frontend mỏng, cụ thể:

• Nhận tải lên tệp,
• Tạo thư mục chạy cách ly cho mỗi lần thực thi,
• Xây dựng lệnh slash của OpenClaw trỏ tới các tệp trên đĩa,
• Gọi tác tử OpenClaw cục bộ,
• Chờ đợi đầu ra,
• Trả về artifact sẵn sàng xem trước cho trình duyệt.

Lựa chọn thiết kế then chốt ở đây là máy chủ web không tự chạy logic phân tích. Nó ủy quyền mọi việc cho OpenClaw, vì vậy UI vẫn đơn giản. 

Bước 5.1: Xây dựng lệnh slash

Mục tiêu là tạo ra một chuỗi duy nhất mà OpenClaw có thể nhận như tin nhắn chat, ví dụ: /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}"

Hàm build_slash_command() chuẩn bị chính xác chỉ dẫn sẽ gửi tới OpenClaw. Thay vì thực thi phân tích trực tiếp, ứng dụng web dựng một lệnh slash có cấu trúc để OpenClaw định tuyến tới workspace skill phù hợp. Hàm này thực hiện bốn nhiệm vụ chính:

• Danh sách args định nghĩa lệnh CLI gọi src/main.py. Đây là lệnh bạn có thể tự chạy thủ công từ terminal.
• Cờ --x-column và --y-column chỉ được thêm khi cung cấp. Nếu thiếu, script phân tích có thể tự suy luận cột từ tập dữ liệu.
• Lời gọi shlex.quote() escape mọi tham số, bao gồm prompt của người dùng. Điều này rất quan trọng để xử lý khoảng trắng và ký tự đặc biệt, đồng thời ngăn rủi ro chèn lệnh khi truyền đầu vào người dùng vào lệnh shell.

Hàm trả về chuỗi bắt đầu bằng: /local-data-analyst. Tiền tố này khớp với tên skill đã định nghĩa trong SKILL.md. Khi OpenClaw nhận lệnh slash này, nó lập tức định tuyến yêu cầu tới workspace skill local-data-analyst, sau đó thực thi lệnh bằng công cụ exec.

Bước 5.2: Thực thi OpenClaw 

Giờ chúng ta đã có lệnh slash, hãy gửi nó tới OpenClaw bằng trình chạy tác tử CLI. Đây là nơi ứng dụng web chuyển giao việc thực thi.

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())

Lời gọi tác tử OpenClaw là điểm chuyển giao nơi ứng dụng web dừng xử lý và thay vào đó yêu cầu OpenClaw thực thi quy trình từ đầu đến cuối. 

• Sử dụng --local đảm bảo lần chạy ở lại trên máy của bạn, và tác tử xử lý yêu cầu qua gateway cục bộ và mô hình hậu thuẫn bởi Ollama thay vì dịch vụ lưu trữ.
• Cờ --session-id stealth-web-{run_id} cấp cho mỗi lần chạy không gian tên phiên riêng, giúp ngăn trạng thái rò rỉ giữa các lần chạy và dễ debug một lần thực thi cụ thể sau này. 
• Tham số --message truyền chuỗi lệnh slash y hệt như thể người dùng gõ trong chat; OpenClaw nhận, định tuyến tới skill /local-data-analyst và thực thi lệnh bên dưới qua công cụ exec. 
• Cuối cùng, --timeout 120 đóng vai trò van an toàn để UI web không treo mãi nếu phân tích bị kẹt, và env=openclaw_env() buộc tiến trình con dùng cấu hình và thư mục trạng thái OpenClaw cục bộ của dự án để luôn nhắm đúng thiết lập Ollama đã định.

Ở bước tiếp theo, chúng ta sẽ nạp các artifact đã tạo, bao gồm biểu đồ, báo cáo và vết công cụ, rồi hiển thị bản xem trước nhẹ trong trình duyệt.

Bước 5.3: Thiết lập máy chủ

Cuối cùng, web_assistant.py chạy một máy chủ HTTP nhỏ cục bộ để bạn tương tác qua trình duyệt.

 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

Điều này giúp triển khai đơn giản:

• ThreadingHTTPServer cho phép nhiều yêu cầu mà không chặn toàn bộ ứng dụng.
• Tất cả “công việc thực” diễn ra trong Handler của request, nơi nhận upload, tạo thư mục chạy, kích hoạt OpenClaw và trả bản xem trước.

Lưu ý: Toàn bộ phần triển khai mã web_assistant.py có trong repo GitHub của dự án.

Bước 6: Xây dựng động cơ phân tích cục bộ

Ở thời điểm này, OpenClaw đã có thể thực thi quy trình qua workspace skill, và UI web có thể kích hoạt lần chạy thông qua lệnh slash. Mảnh ghép còn lại là động cơ phân tích nhận tệp bạn tải lên, chạy các bước quy trình và tạo artifact.

Tệp main.py trong repo này tập trung vào hai hàm định nghĩa lõi pipeline, tức là nạp dữ liệu dạng bảng và gọi Ollama cho suy luận cục bộ. 

Bước 6.1: Nạp dữ liệu dạng bảng 

Trình trợ giúp này hỗ trợ nhiều định dạng đầu vào trong khi vẫn giữ quy trình nhất quán.

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

Hàm load_tabular_data() nhận diện kiểu tệp bằng data_path.suffix và định tuyến tới bộ nạp pandas phù hợp. Tệp CSV và TSV được xử lý bằng read_csv(), trong đó TSV/tab chỉ cần chuyển dấu tách sang \t. Đầu vào JSON được xử lý bằng read_json() trước, nếu pandas ném ValueError thì chuyển sang lines=True cho JSONL. Hỗ trợ Excel được thêm qua read_excel() để người dùng có thể tải .xlsx mà không cần tiền xử lý.

Cuối cùng, lời gọi log_event() ghi một mục vết có cấu trúc mà pipeline có thể tuần tự hóa về tool_trace.json sau này. 

Bước 6.2: Tích hợp Ollama 

Vì bản demo này không dựa vào SDK, nó gọi trực tiếp HTTP API cục bộ của Ollama.

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()

Hàm ollama_generate() gửi payload JSON tới endpoint /api/generate của Ollama trên localhost. Payload chỉ định tên mô hình (ví dụ, qwen3:8b), chuỗi prompt cuối cùng và tắt streaming để hàm trả về một phản hồi hoàn chỉnh duy nhất.

Sử dụng urllib.request giúp wrapper này gọn nhẹ và di động, và tham số timeout=45 ngăn workflow treo vô thời hạn nếu mô hình chậm hoặc máy chủ ngưng. Cuối cùng, hàm trích xuất đầu ra từ trường response và trả về văn bản sạch, sau đó dùng để ghi tệp analysis_report.md.

Bước 7: Xây dựng máy chủ web

Dưới đây là script khởi chạy nhỏ để bật UI web cục bộ, nhận tệp tải lên và kích hoạt lần chạy OpenClaw ở hậu trường.

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

Script này làm ba việc:

• set -euo pipefail giúp script “fail fast”, tức dừng khi lỗi, coi biến chưa đặt là lỗi và tránh lỗi âm thầm trong pipeline.
• ROOT=... xác định thư mục nơi script nằm, nên vẫn chạy được ngay cả khi bạn khởi chạy từ nơi khác.
• cd "$ROOT/.." chuyển tới thư mục gốc dự án như mong đợi rồi khởi chạy web_assistant.py, host UI và xử lý toàn bộ pipeline.

Khi script này chạy, UI trình duyệt trở thành cổng vào cho bản demo.

Bước 8: Khởi động hệ thống

Ở bước cuối, chúng ta chạy hệ thống với thiết lập hai tiến trình. Gateway của OpenClaw xử lý toàn bộ thực thi tác vụ, trong khi giao diện web đóng vai trò lớp người dùng để gửi yêu cầu và xem đầu ra đã tạo.

Terminal 1:  Gateway

Trước khi mở giao diện, chúng ta khởi động gateway của OpenClaw. Tiến trình này đóng vai trò lớp thực thi cho hệ thống, xử lý yêu cầu tác tử, tải workspace skill, gọi công cụ cục bộ và định tuyến lời gọi suy luận tới mô hình Ollama.

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

Trong terminal này, OPENCLAW_CONFIG_PATH trỏ OpenClaw tới cấu hình cục bộ của dự án, nơi chúng ta cố định mô hình mặc định là ollama/qwen3:8b và tắt tìm kiếm web để đảm bảo riêng tư.  Tiếp đó, openclaw gateway --force khởi động gateway ngay cả khi OpenClaw cho rằng đã có thứ gì đó đang chạy hoặc cấu hình dở dang. 

Khi gateway sẵn sàng, nó có thể nhận tin nhắn tác tử cục bộ (bao gồm lệnh slash /local-data-analyst của chúng ta).

Terminal 2: Giao diện web

Khi gateway đã chạy, hãy khởi động giao diện web, nơi thu thập đầu vào của người dùng, gửi mỗi yêu cầu tới tác tử OpenClaw cục bộ và hiển thị biểu đồ, báo cáo, cũng như vết thực thi được tạo.

./local_data_analyst/run_web.sh

Sau đó mở:

http://127.0.0.1:8765

Máy chủ web chạy trên 127.0.0.1, vì vậy chỉ truy cập được từ máy của bạn. Khi bạn bấm Run Analysis, UI sẽ ghi một thư mục run, dựng lệnh slash, gọi openclaw agent --local, rồi thăm dò đĩa để tìm tệp đầu ra nhằm hiển thị xem trước:

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

Đầu ra cuối cùng sẽ trông tương tự như sau. Bạn có thể thử bản demo này bằng một số tệp ví dụ.

Kết luận

Trong hướng dẫn này, chúng ta đã xây dựng một ứng dụng AI theo hướng cục bộ, nơi giao diện web đơn giản kích hoạt toàn bộ quy trình tác tử được hỗ trợ bởi OpenClaw và mô hình Ollama cục bộ. Thay vì gọi API bên ngoài, hệ thống giữ toàn bộ vòng lặp trên máy của bạn.

OpenClaw xử lý điều phối và thực thi công cụ, trong khi Ollama cung cấp lớp trí tuệ cục bộ. Kết quả là một quy trình kiểu tác tử, nơi một yêu cầu duy nhất tạo ra các artifact có cấu trúc như trực quan hóa, báo cáo và dấu vết kiểm toán.

Từ đây, bạn có thể mở rộng dự án theo nhiều hướng. Bạn có thể thêm workspace skill mới cho các quy trình khác, tích hợp thêm công cụ cục bộ (ví dụ, truy vấn cơ sở dữ liệu hoặc tìm kiếm tài liệu), hoặc kết nối OpenClaw với các kênh nhắn tin như Slack hay WhatsApp để truy cập từ xa an toàn. 

Bạn cũng có thể thử nghiệm các mô hình Ollama khác để cân bằng hiệu năng và chất lượng theo phần cứng của bạn.

Để tìm hiểu thêm về làm việc với AI trong quy trình của bạn, tôi khuyến nghị xem khóa học Lập trình hỗ trợ AI cho lập trình viên. Tôi cũng khuyên bạn xem hướng dẫn về Moltbook.