LocalAI: Menjalankan Model AI Secara Lokal dengan API Kompatibel OpenAI
Penulis: Ruby Abdullah, PT RUBYTHALIB DATA KONSULTA Tanggal: 7 November 2026 Kategori: TutorialPendahuluan
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 base
url
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(
base
url="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(
base
url="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(
base
url="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: