✦ AizuDemy
Beranda › Kecerdasan Buatan › Cara Membuat AI Agent Lokal dengan Ollama dan FastAPI untuk Automasi Coding

Cara Membuat AI Agent Lokal dengan Ollama dan FastAPI untuk Automasi Coding

A
Aizu Dev
1 jam lalu · 6 views
#Kecerdasan Buatan
Cara Membuat AI Agent Lokal dengan Ollama dan FastAPI untuk Automasi Coding

Risiko Keamanan Cloud AI dan Urgensi Self-Hosted LLM

Mengirimkan basis kode (source code) proprietary ke API cloud pihak ketiga seperti OpenAI, Anthropic, atau Google membawa risiko keamanan teknis dan hukum. Pengiriman kode melalui endpoint eksternal berpotensi mengekspos kredensial sensitif, API key, token autentikasi, serta algoritma inti perusahaan. Pelanggaran standar kepatuhan industri seperti GDPR, SOC2, ISO 27001, dan HIPAA menjadi konsekuensi nyata apabila data sensitif terkirim ke server publik.

Faktor biaya juga menjadi kendala utama. Model lisensi API cloud berbasis token menghasilkan pengeluaran membengkak ketika workflow automasi coding seperti alur CI/CD, auto-refactoring, audit kode, dan pembuatan unit test dijalankan secara berulang dalam skala tim engineering. Latensi jaringan eksternal serta pembatasan rate limit kerap memicu bottleneck pada proses pengembangan perangkat lunak.

Solusi komprehensif untuk mengatasi persoalan privasi, latensi, dan efisiensi biaya adalah membangun infrastruktur AI Agent mandiri (self-hosted). Memanfaatkan Large Language Model (LLM) terbuka khusus pemrograman seperti Qwen 2.5 Coder, DeepSeek-Coder, atau Llama 3.1 yang dijalankan di mesin lokal memastikan seluruh pemrosesan data berlangsung dalam perimeter jaringan internal. Data kode tidak pernah keluar dari lingkungan lokal.

Arsitektur Sistem AI Agent Lokal

Sistem AI Agent lokal yang andal dan modular membutuhkan pemisahan peran secara tegas antara inferensi model, penyedia API orchestrator, dan klien eksekusi. Arsitektur sistem dibagi menjadi tiga komponen utama:

  • Ollama (Inference Engine): Mesin inferensi berbasis C/C++ yang mengelola unduhan, kuantisasi, dan eksekusi model LLM open-weights pada GPU atau CPU lokal. Ollama menyediakan REST API internal pada port 11434 untuk menangani permintaan komputasi model.
  • FastAPI (Orchestration & Application Layer): Framework Python berkinerja tinggi yang berfungsi sebagai middleware dan pengatur alur kerja. FastAPI mengelola autentikasi, validasi skema data via Pydantic v2, penyusunan prompt terstruktur, penanganan exception, serta pemrosesan permintaan asynchronous secara efisien.
  • Agentic Client / Tools (Execution Layer): Skrip CLI atau ekstensi IDE yang mengonsumsi REST API FastAPI. Komponen ini mengeksekusi aksi konkret pada sistem operasi lokal, seperti membaca struktur direktori, memarsing abstraksi kode (AST), menulis berkas program, dan menjalankan pengujian unit secara otomatis.

Panduan Langkah-demi-Langkah Integrasi Ollama dan FastAPI

1. Persyaratan Sistem dan Dependensi Hardware

Sebelum memulai konfigurasi, pastikan lingkungan kerja memenuhi spesifikasi minimal berikut:

  • Sistem Operasi: Linux (Ubuntu 22.04 LTS atau lebih baru), macOS (M-Series Apple Silicon disarankan), atau Windows via WSL2.
  • Hardware: RAM minimal 16 GB (disarankan 32 GB). GPU NVIDIA dengan VRAM minimal 8 GB (RTX 3060/4060 atau lebih tinggi) untuk efisiensi inferensi. Pada Apple Silicon, Unified Memory digunakan secara otomatis.
  • Perangkat Lunak: Python 3.10+, pip, curl, git, dan NVIDIA Container Toolkit (opsional jika menggunakan Docker).

2. Setup dan Pengujian Model LLM dengan Ollama

Pasang Ollama di mesin lokal sesuai petunjuk resmi. Setelah terpasang, unduh model LLM khusus pemrograman qwen2.5-coder:7b melalui terminal:

ollama pull qwen2.5-coder:7b

Jalankan pengujian awal melalui antarmuka perintah baris (CLI) Ollama:

ollama run qwen2.5-coder:7b "Buat fungsi Python untuk memvalidasi format email menggunakan regex"

Verifikasi ketersediaan REST API Ollama pada port 11434 dengan mengirimkan permintaan HTTP menggunakan curl:

curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5-coder:7b",
  "prompt": "def calculate_factorial(n):",
  "stream": false
}'

3. Konfigurasi Lingkungan Virtual Python

Buat direktori proyek baru dan inisialisasi lingkungan virtual Python untuk mengisolasi dependensi:

mkdir ai-agent-lokal && cd ai-agent-lokal
python3 -m venv venv
source venv/bin/activate

Pasang pustaka utama yang dibutuhkan untuk membangun backend API asynchronous:

pip install fastapi uvicorn httpx pydantic

4. Pengembangan Server API Orchestrator dengan FastAPI

Buat berkas main.py yang berfungsi sebagai server backend. Kode ini menjembatani permintaan klien ke service Ollama, mengelola validasi input, dan memformat output secara konsisten.

import httpx
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, Field

app = FastAPI(
    title="Local AI Agent Service",
    description="API Orchestrator AI Agent lokal berbasis Ollama dan FastAPI",
    version="1.0.0"
)

OLLAMA_API_URL = "http://localhost:11434/api/generate"
DEFAULT_MODEL = "qwen2.5-coder:7b"

class CodeGenerationRequest(BaseModel):
    task: str = Field(..., description="Deskripsi tugas otomatisasi kode")
    code_context: str = Field("", description="Kode sumber pendukung atau konteks proyek")
    language: str = Field("python", description="Bahasa pemrograman target")

class RefactorRequest(BaseModel):
    code: str = Field(..., description="Kode sumber yang akan direfaktor")
    instruction: str = Field(..., description="Instruksi spesifik refactoring")

class UnitTestRequest(BaseModel):
    code: str = Field(..., description="Kode sumber yang akan dibuatkan pengujian unit")
    framework: str = Field("pytest", description="Framework pengujian yang digunakan")

async def call_ollama(prompt: str) -> str:
    payload = {
        "model": DEFAULT_MODEL,
        "prompt": prompt,
        "stream": False,
        "options": {
            "temperature": 0.2,
            "num_ctx": 4096
        }
    }
    
    async with httpx.AsyncClient(timeout=120.0) as client:
        try:
            response = await client.post(OLLAMA_API_URL, json=payload)
            response.raise_for_status()
            data = response.json()
            return data.get("response", "")
        except httpx.HTTPStatusError as exc:
            raise HTTPException(
                status_code=exc.response.status_code,
                detail=f"Ollama API Error: {exc.response.text}"
            )
        except httpx.RequestError as exc:
            raise HTTPException(
                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
                detail=f"Gagal menghubungi service Ollama: {str(exc)}"
            )

@app.post("/api/v1/generate", status_code=status.HTTP_200_OK)
async def generate_code(payload: CodeGenerationRequest):
    prompt = f"""[INST] Anda adalah senior software engineer berpengalaman.
Tugas: {payload.task}
Bahasa Pemrograman: {payload.language}

Konteks Kode Terkait:
{payload.code_context}

Instruksi Tambahan:
- Berikan hanya kode yang bersih, modular, efisien, dan siap pakai.
- Jangan sertakan teks pembuka, penutup, atau penjelasan non-teknis. [/INST]"""
    
    result = await call_ollama(prompt)
    return {"status": "success", "result": result}

@app.post("/api/v1/refactor", status_code=status.HTTP_200_OK)
async def refactor_code(payload: RefactorRequest):
    prompt = f"""[INST] Lakukan refactoring pada kode berikut berdasarkan instruksi yang diberikan.

Instruksi: {payload.instruction}

Kode Asli:
```
{payload.code}
```

Persyaratan:
1. Perbaiki struktur kode agar lebih efisien dan mudah dipelihara.
2. Terapkan penanganan exception dan type hinting yang tepat.
3. Kembalikan hasil refactoring beserta poin ringkas perubahan dalam komentar kode. [/INST]"""
    
    result = await call_ollama(prompt)
    return {"status": "success", "result": result}

@app.post("/api/v1/test", status_code=status.HTTP_200_OK)
async def generate_unit_tests(payload: UnitTestRequest):
    prompt = f"""[INST] Buat pengujian unit komprehensif menggunakan framework {payload.framework} untuk kode berikut:

```
{payload.code}
```

Pastikan mencakup edge cases dan penanganan error. Kembalikan hanya kode pengujian. [/INST]"""
    
    result = await call_ollama(prompt)
    return {"status": "success", "result": result}

Jalankan server FastAPI menggunakan Uvicorn:

uvicorn main:app --reload --host 0.0.0.0 --port 8000

Dokumentasi OpenAPI interaktif kini aktif dan dapat diuji melalui peramban pada alamat http://localhost:8000/docs.

5. Membangun Executable Agent CLI Tool

Untuk mengotomatisasi interaksi dengan berkas lokal, buat skrip CLI bernama agent_cli.py. Skrip ini bertugas mengirimkan instruksi ke server FastAPI dan menuliskan kode hasil ke sistem berkas lokal.

import sys
import argparse
import httpx
from pathlib import Path

FASTAPI_BASE_URL = "http://localhost:8000/api/v1"

def generate_file(task: str, output_path: str, language: str = "python"):
    print(f"[*] Menjalankan tugas automasi: '{task}'...")
    payload = {
        "task": task,
        "code_context": "",
        "language": language
    }
    
    try:
        response = httpx.post(f"{FASTAPI_BASE_URL}/generate", json=payload, timeout=120.0)
        response.raise_for_status()
        data = response.json()
        result_code = data.get("result", "")
        
        output_file = Path(output_path)
        output_file.parent.mkdir(parents=True, exist_ok=True)
        output_file.write_text(result_code, encoding="utf-8")
        
        print(f"[+] Berhasil membuat file: {output_path}")
    except httpx.HTTPError as err:
        print(f"[-] Terjadi kesalahan komunikasi API: {err}")
    except Exception as err:
        print(f"[-] Terjadi kesalahan sistem: {err}")

def main():
    parser = argparse.ArgumentParser(description="CLI Client untuk AI Agent Lokal")
    parser.add_argument("--task", required=True, help="Deskripsi tugas yang dieksekusi")
    parser.add_argument("--output", required=True, help="Path berkas output")
    parser.add_argument("--lang", default="python", help="Bahasa pemrograman target")
    
    args = parser.parse_args()
    generate_file(args.task, args.output, args.lang)

if __name__ == "__main__":
    main()

Uji eksekusi agen CLI melalui terminal untuk membuat modul baru secara otomatis:

python agent_cli.py --task "Buat modul CRUD REST API FastAPI untuk pengelolaan entitas Produk dengan Pydantic v2 dan SQLAlchemy" --output "./app/crud_product.py"

Optimasi Performa dan Best Practices

1. Manajemen Memori GPU dan Kuantisasi Model

Penggunaan resource memori (RAM dan VRAM) dapat dioptimalkan tanpa mengorbankan kualitas keluaran kode melalui beberapa teknik:

  • Kuantisasi GGUF (Q4_K_M vs Q5_K_M): Gunakan model berformat GGUF dengan tingkat kuantisasi 4-bit (Q4_K_M) untuk keseimbangan optimal antara konsumsi VRAM dan pemahaman logika sintaksis. Model 7B pada Q4_K_M hanya membutuhkan sekitar 4.5 GB VRAM.
  • Pengaturan Context Window (num_ctx): Konfigurasikan parameter num_ctx pada Ollama secara presisi. Jendela konteks sebesar 4096 hingga 8192 token mencukupi sebagian besar tugas automasi file tanpa memicu kondisi Out of Memory (OOM).
  • GPU Offloading: Verifikasi bahwa seluruh layer model dimuat ke dalam VRAM GPU dengan memeriksa alokasi resource melalui perintah nvidia-smi saat proses inferensi berjalan.

2. Prompt Engineering dan Enforcement Output Terstruktur

Untuk memastikan AI Agent menghasilkan kode yang dapat dieksekusi langsung oleh mesin tanpa karakter pembungkus markdown tambahan, terapkan instruksi sistem yang ketat:

SYSTEM_PROMPT = """Anda adalah mesin pembentuk kode otomatis.
Aturan Wajib:
1. Kembalikan keluaran HANYA berupa JSON valid sesuai skema yang ditentukan.
2. Dilarang menambahkan teks narasi, kata pengantar, atau penutup.
3. Skema JSON: {"filename": "string", "code": "string", "test_code": "string"}"""

3. Penanganan Error dan Fallback Mechanism

Dalam skala produksi, integrasikan mekanisme penanganan kegagalan seperti pemanggilan ulang (retry pattern) dengan eksponensial backoff apabila HTTP status 503 atau 500 terdeteksi. Gunakan model fallback berukuran lebih kecil (misalnya model 1.5B atau 3B) jika kapasitas VRAM terlampaui.

Kesimpulan

Membangun AI Agent lokal menggabungkan kekuatan Ollama sebagai engine inferensi yang efisien dengan FastAPI sebagai layer orchestrator yang fleksibel. Pendekatan self-hosted ini memberikan kendali penuh atas privasi kode sumber perusahaan, menghilangkan biaya berulang API cloud, dan mengurangi latensi inferensi. Dengan mengimplementasikan teknik kuantisasi, pembatasan jendela konteks, dan penanganan error yang baik, infrastruktur AI Agent lokal dapat menjadi solusi automasi software engineering yang aman, cepat, dan handal.

📖 Artikel Terkait