Tutorial Lengkap LocalAI: Menjalankan Model AI Secara Lokal dengan API Kompatibel OpenAI

# LocalAI: Menjalankan Model AI Secara Lokal dengan API Kompatibel OpenAI **Penulis**: Ruby Abdullah, PT RUBYTHALIB DATA KONSULTA **Tanggal**: 7 November 2026 **Kategori**: Tutorial ## Pendahulu...

By Ruby Abdullah · · tutorial
LocalAILLMSelf-Hosted AIOpenAI-CompatibleDocker

LocalAI: Menjalankan Model AI Secara Lokal dengan API Kompatibel OpenAI

Penulis: Ruby Abdullah, PT RUBYTHALIB DATA KONSULTA Tanggal: 7 November 2026 Kategori: Tutorial

Pendahuluan

Ketergantungan pada layanan cloud seperti OpenAI API memiliki berbagai konsekuensi: biaya yang terus bertambah seiring penggunaan, latensi jaringan, risiko privasi data, dan ketergantungan pada ketersediaan server pihak ketiga. Bagi perusahaan yang menangani data sensitif—seperti data keuangan, medis, atau legal—mengirimkan data ke server eksternal bisa menjadi hambatan regulasi yang signifikan.

LocalAI hadir sebagai solusi praktis untuk permasalahan ini. LocalAI adalah proyek open-source yang menyediakan API kompatibel OpenAI yang berjalan sepenuhnya di infrastruktur lokal Anda. Artinya, kode yang sudah Anda tulis menggunakan OpenAI SDK dapat langsung diarahkan ke LocalAI tanpa perubahan apapun—cukup ganti base URL-nya.

LocalAI mendukung berbagai kapabilitas:

  • Text Generation: Menjalankan model LLM seperti LLaMA, Mistral, Phi, Gemma, dan lainnya
  • Embeddings: Menghasilkan vector embeddings untuk semantic search dan RAG
  • Image Generation: Stable Diffusion dan model image generation lainnya
  • Audio: Text-to-speech dan speech-to-text (Whisper)
  • Vision: Model multimodal yang dapat memproses gambar
  • Function Calling: Tool use yang kompatibel dengan format OpenAI

Dalam tutorial ini, kita akan membangun pemahaman komprehensif mulai dari instalasi hingga integrasi Python yang siap produksi. Semua contoh kode dapat langsung dijalankan di environment Anda.

Instalasi dan Setup

Prasyarat

Sebelum memulai, pastikan sistem Anda memenuhi persyaratan berikut:

  • CPU: Minimum 4 core (8 core direkomendasikan)
  • RAM: Minimum 8GB (16GB+ untuk model besar)
  • Storage: Minimal 20GB ruang kosong untuk model
  • OS: Linux, macOS, atau Windows dengan WSL2
  • Docker: Versi 20.10 atau lebih baru
  • GPU (opsional): NVIDIA GPU dengan CUDA untuk akselerasi (sangat direkomendasikan)

Instalasi via Docker (Cara Paling Mudah)

Docker adalah cara termudah dan paling konsisten untuk menjalankan LocalAI. Berikut langkah-langkahnya:

1. Buat direktori kerja dan konfigurasi:
mkdir -p ~/localai/models

cd ~/localai

2. Jalankan LocalAI dengan Docker Compose:

Buat file docker-compose.yml:

version: '3.8'

services:

localai:

image: localai/localai:latest-aio-cpu

# Untuk GPU NVIDIA, gunakan image berikut:

# image: localai/localai:latest-aio-gpu-nvidia-cuda-12

ports:

  • "8080:8080"
volumes:

  • ./models:/build/models
environment:

  • DEBUG=true
  • MODELSPATH=/build/models
  • THREADS=4
  • CONTEXTSIZE=4096
restart: unless-stopped

# Untuk GPU NVIDIA, tambahkan:

# deploy:

# resources:

# reservations:

# devices:

# - driver: nvidia

# count: all

# capabilities: [gpu]

docker compose up -d

3. Verifikasi instalasi:
curl http://localhost:8080/v1/models

Jika berhasil, Anda akan mendapatkan respons JSON berisi daftar model yang tersedia.

Instalasi Manual (Tanpa Docker)

Jika Anda lebih memilih instalasi langsung di sistem:

# Download binary LocalAI

curl -Lo local-ai "https://github.com/mudler/LocalAI/releases/latest/download/local-ai-$(uname -s)-$(uname -m)"

chmod +x local-ai

Pindahkan ke PATH

sudo mv local-ai /usr/local/bin/

Buat direktori model

mkdir -p ~/.local/share/localai/models

Jalankan LocalAI

local-ai --models-path ~/.local/share/localai/models --address :8080

Mengunduh dan Mengkonfigurasi Model

LocalAI menggunakan file konfigurasi YAML untuk mendefinisikan setiap model. Berikut beberapa cara mengunduh model:

Metode 1: Menggunakan Gallery (Paling Mudah)

LocalAI menyediakan gallery model yang dapat diinstal langsung via API:

# Lihat model yang tersedia di gallery

curl http://localhost:8080/models/available | python3 -m json.tool | head -50

Install model dari gallery (contoh: Mistral 7B)

curl http://localhost:8080/models/apply \

-H "Content-Type: application/json" \

-d '{"id": "mistral-openorca"}'

Cek status instalasi

curl http://localhost:8080/models/jobs

Metode 2: Konfigurasi Manual dengan GGUF

Download model dalam format GGUF dari Hugging Face, lalu buat file konfigurasi:

# Download model (contoh: Mistral 7B Q4)

wget -P ~/localai/models \

https://huggingface.co/TheBloke/Mistral-7B-OpenOrca-GGUF/resolve/main/mistral-7b-openorca.Q4KM.gguf

Buat file konfigurasi ~/localai/models/mistral.yaml:

name: mistral

backend: llama

model: mistral-7b-openorca.Q4KM.gguf

parameters:

temperature: 0.7

topp: 0.9

topk: 40

maxnewtokens: 2048

contextsize: 4096

threads: 4

f16: true

mmap: true

Metode 3: Model Embedding

Untuk embedding, kita membutuhkan model khusus seperti all-MiniLM-L6-v2:

# Download model embedding

wget -P ~/localai/models \

https://huggingface.co/mudler/all-MiniLM-L6-v2/resolve/main/ggml-model-q40.bin

Buat konfigurasi ~/localai/models/embedding.yaml:

name: text-embedding-ada-002

backend: bert-embeddings

model: ggml-model-q40.bin

embeddings: true

Verifikasi Setup

# Cek model yang sudah terinstall

curl http://localhost:8080/v1/models

Test dengan quick chat

curl http://localhost:8080/v1/chat/completions \

-H "Content-Type: application/json" \

-d '{

"model": "mistral",

"messages": [{"role": "user", "content": "Halo, siapa kamu?"}],

"maxtokens": 100

}'

Basic Usage

Text Generation

Menggunakan cURL

# Chat completion dasar

curl http://localhost:8080/v1/chat/completions \

-H "Content-Type: application/json" \

-d '{

"model": "mistral",

"messages": [

{

"role": "system",

"content": "Kamu adalah asisten AI yang membantu dan berbicara dalam Bahasa Indonesia."

},

{

"role": "user",

"content": "Jelaskan konsep machine learning dalam 3 kalimat."

}

],

"temperature": 0.7,

"maxtokens": 500

}'

Streaming Response

# Chat dengan streaming

curl http://localhost:8080/v1/chat/completions \

-H "Content-Type: application/json" \

-d '{

"model": "mistral",

"messages": [{"role": "user", "content": "Tulis puisi pendek tentang teknologi"}],

"stream": true,

"maxtokens": 200

}'

Embeddings

Embeddings adalah representasi numerik (vector) dari teks yang sangat berguna untuk semantic search, clustering, dan RAG (Retrieval-Augmented Generation).

# Generate embedding

curl http://localhost:8080/v1/embeddings \

-H "Content-Type: application/json" \

-d '{

"input": "Kecerdasan buatan mengubah cara kita bekerja",

"model": "text-embedding-ada-002"

}'

Integrasi dengan Python

Setup Environment Python

# Buat virtual environment

python3 -m venv localai-env

source localai-env/bin/activate # Linux/macOS

localai-env\Scripts\activate # Windows

Install dependensi

pip install openai numpy scipy

Client Dasar LocalAI

# localaiclient.py

from openai import OpenAI

Konfigurasi client - hanya perlu mengubah baseurl

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan" # LocalAI tidak memerlukan API key nyata

)

def chat(pesan: str, model: str = "mistral", systemprompt: str = None) -> str:

"""Fungsi chat sederhana dengan LocalAI."""

messages = []

if systemprompt:

messages.append({"role": "system", "content": systemprompt})

messages.append({"role": "user", "content": pesan})

response = client.chat.completions.create(

model=model,

messages=messages,

temperature=0.7,

maxtokens=1024

)

return response.choices[0].message.content

Test

if name == "main":

hasil = chat(

"Apa keuntungan menggunakan LocalAI dibanding OpenAI API?",

systemprompt="Kamu adalah pakar AI yang berbicara dalam Bahasa Indonesia."

)

print(hasil)

Chat dengan Riwayat Percakapan

# conversation.py

from openai import OpenAI

from typing import List, Dict

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

class LocalAIChat:

"""Kelas untuk mengelola percakapan multi-turn dengan LocalAI."""

def init(self, model: str = "mistral", systemprompt: str = None):

self.model = model

self.riwayat: List[Dict] = []

if systemprompt:

self.riwayat.append({

"role": "system",

"content": systemprompt

})

def kirimpesan(self, pesan: str, temperature: float = 0.7) -> str:

"""Kirim pesan dan simpan riwayat percakapan."""

self.riwayat.append({"role": "user", "content": pesan})

response = client.chat.completions.create(

model=self.model,

messages=self.riwayat,

temperature=temperature,

maxtokens=2048

)

jawaban = response.choices[0].message.content

self.riwayat.append({"role": "assistant", "content": jawaban})

return jawaban

def reset(self):

"""Reset riwayat percakapan (pertahankan system prompt)."""

if self.riwayat and self.riwayat[0]["role"] == "system":

self.riwayat = [self.riwayat[0]]

else:

self.riwayat = []

def tampilkanriwayat(self):

"""Tampilkan seluruh riwayat percakapan."""

for pesan in self.riwayat:

role = pesan["role"].upper()

content = pesan["content"][:100] + "..." if len(pesan["content"]) > 100 else pesan["content"]

print(f"[{role}]: {content}")

Contoh penggunaan

if name == "main":

chat = LocalAIChat(

model="mistral",

systemprompt="Kamu adalah konsultan bisnis berpengalaman yang berbicara dalam Bahasa Indonesia."

)

# Percakapan multi-turn

print(chat.kirimpesan("Apa strategi terbaik untuk memulai startup teknologi di Indonesia?"))

print("\n---\n")

print(chat.kirimpesan("Bagaimana dengan pendanaan awal? Apa opsi yang tersedia?"))

print("\n---\n")

print(chat.kirimpesan("Berikan contoh konkret startup Indonesia yang berhasil."))

Streaming Response dengan Python

# streaming.py

from openai import OpenAI

import sys

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

def chatstream(pesan: str, model: str = "mistral"):

"""Chat dengan output streaming real-time."""

stream = client.chat.completions.create(

model=model,

messages=[{"role": "user", "content": pesan}],

stream=True,

maxtokens=1024

)

fullresponse = ""

for chunk in stream:

if chunk.choices[0].delta.content is not None:

token = chunk.choices[0].delta.content

print(token, end="", flush=True)

fullresponse += token

print() # Newline setelah selesai

return fullresponse

if name == "main":

pertanyaan = sys.argv[1] if len(sys.argv) > 1 else "Jelaskan cara kerja neural network"

print(f"Pertanyaan: {pertanyaan}\n")

print("Jawaban: ", end="")

chatstream(pertanyaan)

Embeddings dengan Python

# embeddings.py

from openai import OpenAI

import numpy as np

from typing import List

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

def buatembedding(teks: str, model: str = "text-embedding-ada-002") -> List[float]:

"""Buat embedding untuk satu teks."""

response = client.embeddings.create(

input=teks,

model=model

)

return response.data[0].embedding

def cosinesimilarity(vec1: List[float], vec2: List[float]) -> float:

"""Hitung cosine similarity antara dua vector."""

v1, v2 = np.array(vec1), np.array(vec2)

return float(np.dot(v1, v2) / (np.linalg.norm(v1) np.linalg.norm(v2)))

def cariteksrelevan(query: str, dokumen: List[str], topk: int = 3) -> List[tuple]:

"""Cari dokumen paling relevan berdasarkan semantic similarity."""

queryembedding = buatembedding(query)

hasil = []

for i, dok in enumerate(dokumen):

dokembedding = buatembedding(dok)

similarity = cosinesimilarity(queryembedding, dokembedding)

hasil.append((similarity, i, dok))

# Sort berdasarkan similarity tertinggi

hasil.sort(key=lambda x: x[0], reverse=True)

return hasil[:topk]

Contoh penggunaan: Simple Semantic Search

if name == "main":

# Koleksi dokumen

dokumen = [

"Machine learning adalah cabang AI yang memungkinkan sistem belajar dari data.",

"Docker adalah platform untuk containerisasi aplikasi.",

"Python adalah bahasa pemrograman yang populer untuk data science.",

"Neural network meniru struktur otak manusia untuk memproses informasi.",

"Kubernetes digunakan untuk orkestrasi container di skala besar.",

"Deep learning menggunakan banyak lapisan neural network.",

"FastAPI adalah framework Python untuk membangun REST API.",

]

query = "Bagaimana AI bisa belajar secara otomatis?"

print(f"Query: {query}\n")

hasil = cariteksrelevan(query, dokumen, topk=3)

print("Dokumen paling relevan:")

for rank, (similarity, idx, teks) in enumerate(hasil, 1):

print(f"{rank}. [Similarity: {similarity:.4f}] {teks}")

Advanced Usage

Function Calling (Tool Use)

Function calling memungkinkan model untuk memanggil fungsi yang Anda definisikan. Ini sangat berguna untuk membangun agen AI.

# functioncalling.py

from openai import OpenAI

import json

from datetime import datetime

import random

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

Definisi tools/functions

tools = [

{

"type": "function",

"function": {

"name": "cekcuaca",

"description": "Mendapatkan informasi cuaca saat ini untuk kota tertentu",

"parameters": {

"type": "object",

"properties": {

"kota": {

"type": "string",

"description": "Nama kota, contoh: Jakarta, Surabaya, Bandung"

},

"satuan": {

"type": "string",

"enum": ["celsius", "fahrenheit"],

"description": "Satuan suhu"

}

},

"required": ["kota"]

}

}

},

{

"type": "function",

"function": {

"name": "konversimatauang",

"description": "Mengkonversi nilai dari satu mata uang ke mata uang lain",

"parameters": {

"type": "object",

"properties": {

"jumlah": {

"type": "number",

"description": "Jumlah yang akan dikonversi"

},

"dari": {

"type": "string",

"description": "Kode mata uang asal (contoh: USD, EUR)"

},

"ke": {

"type": "string",

"description": "Kode mata uang tujuan (contoh: IDR, SGD)"

}

},

"required": ["jumlah", "dari", "ke"]

}

}

}

]

Implementasi fungsi aktual

def cekcuaca(kota: str, satuan: str = "celsius") -> dict:

"""Simulasi data cuaca (dalam produksi, gunakan Weather API)."""

# Simulasi data - gunakan API nyata di produksi

suhubase = {"Jakarta": 32, "Bandung": 24, "Surabaya": 34, "Bali": 30}

suhu = suhubase.get(kota, 28) + random.randint(-2, 2)

if satuan == "fahrenheit":

suhu = (suhu 9/5) + 32

return {

"kota": kota,

"suhu": suhu,

"satuan": satuan,

"kondisi": random.choice(["Cerah", "Berawan", "Hujan Ringan"]),

"kelembaban": f"{random.randint(60, 85)}%",

"waktu": datetime.now().strftime("%Y-%m-%d %H:%M")

}

def konversimatauang(jumlah: float, dari: str, ke: str) -> dict:

"""Simulasi konversi mata uang (gunakan API nyata di produksi)."""

# Rate simulasi - gunakan Forex API di produksi

ratestoidr = {"USD": 15800, "EUR": 17200, "SGD": 11700, "JPY": 105, "IDR": 1}

if dari == "IDR":

hasil = jumlah / ratestoidr.get(ke, 1)

elif ke == "IDR":

hasil = jumlah ratestoidr.get(dari, 1)

else:

idr = jumlah ratestoidr.get(dari, 1)

hasil = idr / ratestoidr.get(ke, 1)

return {

"jumlahasal": jumlah,

"matauangasal": dari,

"hasil": round(hasil, 2),

"matauangtujuan": ke,

"waktu": datetime.now().strftime("%Y-%m-%d %H:%M")

}

def jalankantool(namafungsi: str, argumen: dict) -> str:

"""Eksekusi fungsi berdasarkan nama dan argumen."""

if namafungsi == "cekcuaca":

hasil = cekcuaca(argumen)

elif namafungsi == "konversimatauang":

hasil = konversimatauang(argumen)

else:

hasil = {"error": f"Fungsi {namafungsi} tidak ditemukan"}

return json.dumps(hasil, ensureascii=False)

def chatdengantools(pertanyaan: str) -> str:

"""Chat yang bisa menggunakan tools/functions."""

messages = [{"role": "user", "content": pertanyaan}]

# Panggilan pertama - minta model memilih tool

response = client.chat.completions.create(

model="mistral",

messages=messages,

tools=tools,

toolchoice="auto"

)

pesanrespons = response.choices[0].message

# Cek apakah model ingin memanggil tool

if pesanrespons.toolcalls:

messages.append(pesanrespons)

# Eksekusi setiap tool call

for toolcall in pesanrespons.toolcalls:

namafungsi = toolcall.function.name

argumen = json.loads(toolcall.function.arguments)

print(f" → Memanggil tool: {namafungsi}({argumen})")

hasiltool = jalankantool(namafungsi, argumen)

messages.append({

"role": "tool",

"toolcallid": toolcall.id,

"content": hasiltool

})

# Panggilan kedua - model merangkum hasil

responsefinal = client.chat.completions.create(

model="mistral",

messages=messages

)

return responsefinal.choices[0].message.content

return pesanrespons.content

if name == "main":

pertanyaanlist = [

"Berapa suhu di Jakarta sekarang?",

"Konversi 100 USD ke Rupiah",

"Bagaimana cuaca di Bali dan berapa 500 EUR dalam IDR?"

]

for pertanyaan in pertanyaanlist:

print(f"\nPertanyaan: {pertanyaan}")

jawaban = chatdengantools(pertanyaan)

print(f"Jawaban: {jawaban}")

print("-" 60)

Vision (Analisis Gambar)

LocalAI mendukung model multimodal yang dapat menganalisis gambar:

# vision.py

from openai import OpenAI

import base64

from pathlib import Path

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

def encodegambar(pathgambar: str) -> str:

"""Encode gambar ke base64."""

with open(pathgambar, "rb") as f:

return base64.b64encode(f.read()).decode("utf-8")

def analisisgambar(pathgambar: str, pertanyaan: str, model: str = "llava") -> str:

"""

Analisis gambar menggunakan model vision LocalAI.

Model yang kompatibel: llava, bakllava, atau model vision lainnya

Pastikan model sudah diunduh dan dikonfigurasi di LocalAI.

"""

imagedata = encodegambar(pathgambar)

ext = Path(pathgambar).suffix.lstrip(".")

mime = f"image/{ext}" if ext != "jpg" else "image/jpeg"

response = client.chat.completions.create(

model=model,

messages=[

{

"role": "user",

"content": [

{

"type": "imageurl",

"imageurl": {

"url": f"data:{mime};base64,{imagedata}"

}

},

{

"type": "text",

"text": pertanyaan

}

]

}

],

maxtokens=1024

)

return response.choices[0].message.content

def analisisdariurl(urlgambar: str, pertanyaan: str, model: str = "llava") -> str:

"""Analisis gambar dari URL."""

response = client.chat.completions.create(

model=model,

messages=[

{

"role": "user",

"content": [

{

"type": "imageurl",

"imageurl": {"url": urlgambar}

},

{

"type": "text",

"text": pertanyaan

}

]

}

],

maxtokens=1024

)

return response.choices[0].message.content

Contoh penggunaan

if name == "main":

# Analisis gambar lokal

# hasil = analisisgambar("fotoproduk.jpg", "Deskripsikan isi gambar ini dalam Bahasa Indonesia")

# print(hasil)

# Analisis dari URL

url = "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1e/Stonehenge.jpg/320px-Stonehenge.jpg"

hasil = analisisdariurl(url, "Apa yang terlihat dalam gambar ini? Jelaskan dalam Bahasa Indonesia.")

print(hasil)

Audio: Speech-to-Text (Whisper)

# speechtotext.py

from openai import OpenAI

from pathlib import Path

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

def transkripsiaudio(pathaudio: str, bahasa: str = "id") -> str:

"""

Transkripsi file audio menggunakan Whisper di LocalAI.

Format yang didukung: mp3, mp4, mpeg, mpga, m4a, wav, webm

"""

with open(pathaudio, "rb") as audiofile:

transkripsi = client.audio.transcriptions.create(

model="whisper-1",

file=audiofile,

language=bahasa,

responseformat="text"

)

return transkripsi

def transkripsidengantimestamp(pathaudio: str) -> dict:

"""Transkripsi dengan informasi timestamp per segmen."""

with open(pathaudio, "rb") as audiofile:

transkripsi = client.audio.transcriptions.create(

model="whisper-1",

file=audiofile,

responseformat="verbosejson",

timestampgranularities=["segment"]

)

return transkripsi

Contoh setup model Whisper di LocalAI (whisper.yaml):

"""

name: whisper-1

backend: whisper

model: ggml-large-v3.bin

parameters:

language: id

"""

if name == "main":

# Contoh penggunaan

# hasil = transkripsiaudio("rekamanmeeting.mp3", bahasa="id")

# print(f"Transkripsi: {hasil}")

print("Setup Whisper model terlebih dahulu di LocalAI.")

print("Download model: wget -P ~/localai/models https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3.bin")

Membangun Aplikasi RAG Sederhana

RAG (Retrieval-Augmented Generation) adalah salah satu use case paling populer untuk LocalAI. Berikut implementasi lengkapnya:

# ragsederhana.py

from openai import OpenAI

import numpy as np

from typing import List, Dict

import json

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

class RAGSistem:

"""Sistem RAG sederhana menggunakan LocalAI untuk embedding dan generation."""

def init(self, modelchat: str = "mistral", modelembedding: str = "text-embedding-ada-002"):

self.modelchat = modelchat

self.modelembedding = modelembedding

self.basispengetahuan: List[Dict] = []

def tambahdokumen(self, teks: str, metadata: dict = None):

"""Tambah dokumen ke basis pengetahuan."""

embedding = self.buatembedding(teks)

self.basispengetahuan.append({

"teks": teks,

"embedding": embedding,

"metadata": metadata or {}

})

print(f"Dokumen ditambahkan: {teks[:60]}...")

def buatembedding(self, teks: str) -> List[float]:

"""Buat embedding untuk teks."""

response = client.embeddings.create(input=teks, model=self.modelembedding)

return response.data[0].embedding

def cosinesimilarity(self, v1: List[float], v2: List[float]) -> float:

a, b = np.array(v1), np.array(v2)

return float(np.dot(a, b) / (np.linalg.norm(a) np.linalg.norm(b)))

def carirelevan(self, query: str, topk: int = 3) -> List[Dict]:

"""Cari dokumen paling relevan dengan query."""

queryemb = self.buatembedding(query)

scored = [

{*dok, "score": self.cosinesimilarity(queryemb, dok["embedding"])}

for dok in self.basispengetahuan

]

scored.sort(key=lambda x: x["score"], reverse=True)

return scored[:topk]

def tanya(self, pertanyaan: str, topk: int = 3) -> str:

"""Tanya sistem RAG dengan pertanyaan natural language."""

# Langkah 1: Ambil dokumen relevan

dokumenrelevan = self.carirelevan(pertanyaan, topk)

# Langkah 2: Buat konteks dari dokumen relevan

konteks = "\n\n".join([

f"[Dokumen {i+1} - Relevansi: {dok['score']:.2f}]\n{dok['teks']}"

for i, dok in enumerate(dokumenrelevan)

])

# Langkah 3: Generate jawaban dengan konteks

promptsistem = """Kamu adalah asisten yang menjawab pertanyaan berdasarkan konteks yang diberikan.

Gunakan HANYA informasi dari konteks. Jika informasi tidak ada dalam konteks, katakan dengan jujur.

Jawab dalam Bahasa Indonesia yang jelas dan terstruktur."""

promptuser = f"""Konteks:

{konteks}

Pertanyaan: {pertanyaan}

Berikan jawaban berdasarkan konteks di atas."""

response = client.chat.completions.create(

model=self.modelchat,

messages=[

{"role": "system", "content": promptsistem},

{"role": "user", "content": promptuser}

],

temperature=0.3,

maxtokens=1024

)

return response.choices[0].message.content

Demo sistem RAG

if name == "main":

rag = RAGSistem()

# Isi basis pengetahuan

dokumenperusahaan = [

"PT RUBYTHALIB DATA KONSULTA adalah perusahaan teknologi yang berfokus pada solusi AI dan data analytics.",

"Layanan utama kami meliputi pengembangan sistem AI, pelatihan machine learning, dan konsultasi data strategy.",

"Kantor kami berlokasi di SCBD Jakarta, tepatnya di Indonesia Stock Exchange Building Tower 1.",

"Tim kami terdiri dari data scientist, ML engineer, dan software developer berpengalaman.",

"Kami menggunakan teknologi terkini seperti Python, TensorFlow, PyTorch, dan cloud platforms.",

"Program pelatihan AI kami mencakup machine learning dasar hingga advanced deep learning.",

"Klien kami berasal dari berbagai industri: perbankan, retail, manufaktur, dan pemerintahan.",

]

for dok in dokumenperusahaan:

rag.tambahdokumen(dok)

print("\n" + "="60)

pertanyaanlist = [

"Apa yang dilakukan PT RUBYTHALIB DATA KONSULTA?",

"Di mana lokasi kantor perusahaan?",

"Teknologi apa yang digunakan tim?"

]

for pertanyaan in pertanyaanlist:

print(f"\nPertanyaan: {pertanyaan}")

jawaban = rag.tanya(pertanyaan)

print(f"Jawaban: {jawaban}")

print("-" 60)

Best Practices

1. Manajemen Model yang Efisien

# Gunakan model quantized untuk menghemat memori

Q4KM: keseimbangan baik antara kualitas dan ukuran

Q5KM: lebih akurat, lebih besar

Q80: hampir sama dengan full precision, paling besar

Cek penggunaan memori

docker stats localai

2. Konfigurasi Performance Optimal

# model-optimal.yaml

name: mistral-fast

backend: llama

model: mistral-7b-openorca.Q4KM.gguf

parameters:

temperature: 0.7

topp: 0.9

repeatpenalty: 1.1

contextsize: 2048 # Kurangi jika RAM terbatas

threads: 8 # Sesuaikan dengan jumlah CPU core

f16: true # Gunakan float16 untuk efisiensi

mmap: true # Memory-mapped file untuk loading cepat

gpulayers: 32 # Jumlah layer di GPU (0 jika tidak ada GPU)

3. Error Handling yang Robust

# errorhandling.py

from openai import OpenAI, APIConnectionError, APITimeoutError, RateLimitError

import time

import logging

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(name)

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan",

timeout=60.0, # Timeout 60 detik

maxretries=3 # Retry otomatis

)

def chatdenganretry(pesan: str, maxretry: int = 3) -> str:

"""Chat dengan mekanisme retry dan error handling lengkap."""

for attempt in range(maxretry):

try:

response = client.chat.completions.create(

model="mistral",

messages=[{"role": "user", "content": pesan}],

timeout=30

)

return response.choices[0].message.content

except APIConnectionError:

logger.error(f"Koneksi gagal (percobaan {attempt + 1}/{maxretry})")

if attempt < maxretry - 1:

time.sleep(2 attempt) # Exponential backoff

else:

raise

except APITimeoutError:

logger.error(f"Request timeout (percobaan {attempt + 1}/{maxretry})")

if attempt < maxretry - 1:

time.sleep(5)

else:

raise

except Exception as e:

logger.error(f"Error tidak terduga: {e}")

raise

def cekkesehatanserver() -> bool:

"""Cek apakah LocalAI server berjalan dengan normal."""

try:

models = client.models.list()

logger.info(f"Server aktif, {len(models.data)} model tersedia")

return True

except Exception as e:

logger.error(f"Server tidak tersedia: {e}")

return False

4. Batching untuk Throughput Tinggi

# batching.py

from openai import OpenAI

from concurrent.futures import ThreadPoolExecutor, ascompleted

from typing import List

import time

client = OpenAI(

baseurl="http://localhost:8080/v1",

apikey="tidak-diperlukan"

)

def prosessatu(item: dict) -> dict:

"""Proses satu item."""

try:

response = client.chat.completions.create(

model="mistral",

messages=[{"role": "user", "content": item["pertanyaan"]}],

maxtokens=512,

temperature=0.3

)

return {

"id": item["id"],

"pertanyaan": item["pertanyaan"],

"jawaban": response.choices[0].message.content,

"status": "sukses"

}

except Exception as e:

return {

"id": item["id"],

"pertanyaan": item["pertanyaan"],

"jawaban": None,

"status": f"error: {str(e)}"

}

def prosesbatch(items: List[dict], maxworkers: int = 3) -> List[dict]:

"""

Proses multiple item secara paralel.

maxworkers: sesuaikan dengan kapasitas server LocalAI

"""

hasil = []

with ThreadPoolExecutor(maxworkers=maxworkers) as executor:

Artikel Terkait

RAGFlow: Bikin RAG Engine yang Ngerti Dokumen Beneran, Lengkap dengan Sitasi

RAGFlow: Bikin RAG Engine yang Ngerti Dokumen Beneran, Lengkap dengan Sitasi Halo temen-temen, balik lagi sama aku. Kala...

Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng Apa itu Aisuite? Aisuite adalah library Python open...

Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind

Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind Google Gemma adalah keluarga model bahasa open-sou...

Tutorial Lengkap LlamaFile: Menjalankan LLM sebagai File Eksekutabel Tunggal

LlamaFile: Menjalankan LLM sebagai File Eksekutabel Tunggal Penulis: Ruby Abdullah Kategori: Tutorial Tags: LlamaFile, L...