Jalankan Model Embedding Secara Lokal dengan Ollama: Saya Mengukur Latensi GPU Dingin vs Hangat

Jalankan Model Embedding Secara Lokal dengan Ollama: Saya Mengukur Latensi GPU Dingin vs Hangat

Anda dapat menjalankan model embedding secara lokal dengan Ollama dan berhenti membayar OpenAI sebesar $0,02 per juta token untuk setiap potongan data yang Anda indeks. Imbalannya: Anda memiliki GPU, menangani startup dingin (cold starts), dan operasionalnya. Ollama menyajikannya di port 11434 tanpa kunci API. Berikut adalah alur kerja lengkapnya, mulai dari ollama pull hingga pencarian vektor yang hangat dan siap menjawab kueri.

Poin Utama

• Ollama menyajikan embedding secara lokal di http://localhost:11434 melalui POST /api/embed, tanpa kunci API dan biaya $0 per token.
• Gunakan /api/embed (terkini, array batch); /api/embeddings adalah versi lama dan sering menjadi sumber error 404.
• Model lokal populer: nomic-embed-text (768-dim), mxbai-embed-large (1024), bge-m3 (1024), embeddinggemma (768).
• Sesuaikan dimensi embedding Anda dengan kolom database vektor, dan tetapkan model dengan keep_alive untuk menghindari latensi startup dingin.

Apa yang Anda Butuhkan untuk Menjalankan Embedding Secara Lokal dengan Ollama?

Semua yang Anda butuhkan untuk menjalankan embedding secara lokal terdiri dari tiga bagian: model embedding, server Ollama di port 11434, dan penyimpan vektor untuk menampung outputnya. Ollama mengunduh dan menyajikan model; kode Anda memposting teks ke /api/embed; vektor masuk ke database seperti pgvector, Qdrant, atau Chroma. Tidak ada perjalanan bolak-balik ke cloud, tidak ada tagihan per token.

Dua perintah ini akan memberikan Anda embedding yang berfungsi dalam waktu kurang dari satu menit:

ollama pull nomic-embed-text
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "The quick brown fox"
}'

Itulah ringkasan cepatnya. Sisa tutorial ini akan mengisi pilihan model, penyimpanan, dan dua masalah umum yang sering menjebak semua orang: kebingungan endpoint dan penalti startup dingin.

Langkah 1: Instal Ollama dan Tarik Model Embedding

Instal Ollama, pastikan server mendengarkan di port 11434, lalu tarik model embedding. Ollama berjalan sebagai layanan latar belakang, jadi ollama pull nomic-embed-text mengunduh bobot model dan panggilan /api/embed berikutnya akan menyajikannya. Model embedding sangat kecil dibandingkan model chat, sehingga proses ini cepat.

# macOS / Linux install
curl -fsSL https://ollama.com/install.sh | sh

# Make sure the server is up (background service on :11434)
ollama serve            # only if it isn't already running

# Pull an embedding model and health-check the server
ollama pull nomic-embed-text
curl http://localhost:11434            # should return "Ollama is running"

Bagian menariknya: model embedding seperti nomic-embed-text hanya memiliki 137 juta parameter, sekitar unduhan 274 MB, dibandingkan dengan model chat yang berukuran multi-gigabyte. Model ini dimuat ke VRAM dalam waktu sekitar satu detik. Jika Anda ingin pengaturan LLM lokal lengkap agar model chat dapat berdampingan dengan embedder Anda, panduan kami tentang menyiapkan Ollama untuk LLM lokal mencakup jalur tersebut, serta UI untuk model Ollama lokal Anda jika Anda lebih suka klik daripada menggunakan curl.

Tips pro: server harus berjalan sebelum permintaan apa pun dikirim. Koneksi yang ditolak pada :11434 hampir selalu berarti ollama serve tidak aktif.

Model Embedding Lokal Mana yang Harus Anda Tarik?

Untuk sebagian besar RAG lokal, nomic-embed-text dengan 768 dimensi adalah default yang aman. Ini mengungguli ada-002 lama milik OpenAI dan berjalan di hampir semua perangkat. Pilih bge-m3 atau qwen3-embedding ketika Anda membutuhkan pengambilan multibahasa atau konteks panjang, all-minilm untuk kecepatan pada perangkat keras kecil, dan embeddinggemma sebagai opsi Google yang lebih baru. Tabel di bawah ini mencakup pustaka model embedding Ollama saat ini sebagai pertimbangan penyajian, bukan papan peringkat kualitas.

Dalam thread reddit "model embedding ollama terbaik", konsensus yang berulang adalah nomic-embed-text untuk RAG umum dan bge-m3 ketika Anda bekerja dengan multibahasa, yang sesuai dengan apa yang kami gunakan. Jika Anda ingin pandangan peringkat lintas penyedia dengan skor, itu adalah tugas dari hub kami: model embedding mana yang harus dipilih untuk RAG. Kami sengaja melewatkan angka MTEB di sini; artikel pendamping kami tentang cara kerja skor MTEB untuk RAG menjelaskan mengapa papan peringkat saja dapat menyesatkan Anda.

Langkah 2: Hasilkan Embedding melalui /api/embed

Kirim teks ke POST /api/embed dan Ollama mengembalikan vektor yang dinormalisasi L2, artinya masing-masing memiliki panjang satuan sehingga kesamaan kosinus bekerja secara langsung. Sesuai dengan dokumentasi embedding Ollama, endpoint terkini mengambil bidang input yang menerima string tunggal atau array untuk batching, dan mengembalikan {"embeddings": [[...]]}.

Panggilan HTTP mentah:

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["first chunk", "second chunk", "third chunk"]
}'

Di Python, klien resmi hanya memerlukan satu baris per batch:

import ollama

resp = ollama.embed(
    model="nomic-embed-text",
    input=["first chunk", "second chunk", "third chunk"],
    options={"num_ctx": 8192},  # raise context for long chunks
)
vectors = resp["embeddings"]   # list of 768-float lists, L2-normalized

Batching melalui array input adalah tuas throughput utama Anda. Satu permintaan dengan 64 potongan data jauh lebih unggul daripada 64 permintaan tunggal, karena Anda hanya membayar overhead per panggilan sekali. Perhatikan peningkatan num_ctx: nomic-embed-text secara default menggunakan jendela 2048 token meskipun secara native mendukung 8192, sehingga potongan data panjang akan terpotong secara diam-diam kecuali Anda menaikkannya. Embedding adalah satu tahap dari pipa RAG lengkap yang diberi makan oleh ini; logika pemotongan dan pengambilan berada di sana, bukan di sini.

/api/embed vs /api/embeddings vs /v1/embeddings: Apa Perbedaannya?

/api/embed adalah endpoint terkini; /api/embeddings adalah yang sudah usang di balik sebagian besar postingan "Ollama embeddings tidak berfungsi". Rute lama menggunakan bidang prompt tunggal dan mengembalikan embedding (tanpa s), sedangkan rute terkini menggunakan input, menerima batch, dan mengembalikan embeddings. Rute ketiga, /v1/embeddings, kompatibel dengan OpenAI dan menerima param dimensions.

Mendapatkan 404 atau bentuk respons yang aneh? Anda kemungkinan besar menggunakan /api/embeddings (lama). Beralihlah ke /api/embed dan baca kunci embeddings alih-alih embedding. Satu karakter itu sering menjebak banyak orang yang menyalin tutorial lama.

Rute /v1/embeddings penting untuk satu kasus spesifik: migrasi dari OpenAI. Karena menerima param dimensions, Anda dapat memotong model yang mampu Matryoshka ke ukuran target, yang merupakan solusi untuk ketidakcocokan dimensi 1536 yang kami bahas selanjutnya.

Langkah 3: Simpan dan Cari Vektor Anda (pgvector, Qdrant, atau Chroma)

Simpan vektor 768-float dalam database yang melakukan pencarian nearest-neighbor, lalu kueri dengan jarak kosinus. Dalam pembangunan RAG kami, kami menggunakan default Postgres plus pgvector untuk tim yang sudah menggunakan Postgres, karena ini menjaga embedding Anda berdekatan dengan data relasional Anda. Aktifkan ekstensi, deklarasikan kolom VECTOR(768) yang cocok dengan dimensi model Anda, sisipkan, dan kueri dengan operator kosinus <=>.

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE chunks (
  id     bigserial PRIMARY KEY,
  body   text,
  embedding vector(768)          -- must match nomic-embed-text
);

-- Insert a row (embedding comes from ollama.embed)
INSERT INTO chunks (body, embedding) VALUES ('first chunk', '[0.01, -0.02, ...]');

-- Top-5 nearest chunks by cosine distance
SELECT body, 1 - (embedding <=> '[0.01, -0.02, ...]') AS score
FROM chunks
ORDER BY embedding <=> '[0.01, -0.02, ...]'
LIMIT 5;

Qdrant dan Chroma bekerja dengan cara yang sama secara konseptual: buat koleksi dengan ukuran vektor tetap yang cocok dengan model Anda, lalu upsert dan cari. Aturan ini berlaku di mana saja: memilih database vektor kurang penting daripada mendapatkan dimensi yang benar, karena Qdrant, Chroma, dan pgvector semuanya menolak vektor yang ukurannya tidak cocok dengan koleksi. Lihat perbandingan Qdrant vs Chroma vs pgvector kami jika Anda masih memutuskan.

Jebakan migrasi: tidak ada model Ollama yang secara native berdimensi 1536, sehingga kolom pgvector VECTOR(1536) yang ada akan menolaknya. Tiga solusi: (1) pilih model yang dimensinya cocok dengan kolom Anda, (2) gunakan /v1/embeddings dengan param dimensions pada model Matryoshka seperti qwen3-embedding atau embeddinggemma untuk memotong ke 1536, atau (3) deklarasikan ulang kolom ke dimensi native model, seperti VECTOR(768).

Kami Mengukur nomic-embed-text di RTX 4090: Startup Dingin vs GPU Hangat

Kami telah mengukurnya. Di mesin kami (Ubuntu 22.04, RTX 4090 24 GB, Ollama 0.5.x, nomic-embed-text pada 768-dim), /api/embed pertama setelah periode idle memakan waktu sekitar 1,3 detik sementara bobot dimuat ke VRAM. Setelah hangat, kami melihat p50 mendekati 9 ms dan p95 mendekati 22 ms per embedding. Dengan batch 64, kami mempertahankan sekitar 600 embedding/detik.

Inilah jebakan yang menjawab pertanyaan "mengapa embedding Ollama lambat atau time-out." Secara default, Ollama membongkar model dari VRAM setelah sekitar 5 menit idle. Jadi, permintaan berikutnya Anda membayar ulang startup dingin ~1,3 detik tersebut, yang terasa seperti lonjakan acak dalam produksi. Solusinya adalah keep_alive:

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "keep me warm",
  "keep_alive": -1
}'

Mengatur keep_alive: -1 menempelkan model di VRAM tanpa batas waktu, sehingga setiap permintaan tetap berada di jalur hangat. Dalam keadaan hangat, nomic-embed-text di RTX 4090 mempertahankan p95 mendekati 22 ms. Biarkan idle selama 5 menit dan permintaan berikutnya Anda akan membayar ulang startup dingin ~1,3 detik. Untuk layanan yang sensitif terhadap latensi, tempelkan model tersebut.

Apakah Self-Hosting Embedding Layak? Biaya vs API

Embedding lokal berharga sekitar $0 per juta token di margin, ditambah listrik, dibandingkan dengan sekitar $0,02 per juta token untuk OpenAI text-embedding-3-small. Namun jawaban yang jujur adalah: self-hosting hanya menang di atas ambang batas volume token. Di bawah beberapa ratus juta token per bulan, Anda membayar dengan waktu operasional dan GPU idle, bukan dolar yang dihemat. Kenyamanan API menang untuk volume rendah.

Self-hosting embedding hanya mengungguli API di atas sekitar beberapa ratus juta token per bulan. Di bawah itu, Anda membayar dengan waktu operasional, bukan dolar yang dihemat. Di mana lokal kurang cocok: volume kueri rendah, tidak ada GPU, atau tim tanpa kapasitas ops untuk menjaga kesehatan server. Dalam kasus tersebut, API terkelola adalah panggilan pragmatis, dan perbandingan API embedding Voyage, OpenAI, dan Cohere adalah hal berikutnya untuk dibaca. Tidak yakin apakah Anda ingin memiliki GPU dan ops sama sekali? Banyak tim menjaga embedding tetap lokal untuk privasi tetapi membawa bantuan untuk setup dan pemeliharaan hari kedua, yang merupakan jenis pembangunan yang ditangani oleh layanan integrasi AI kami. Jika Anda ingin membandingkan runtime, lihat alat lain untuk menjalankan model secara lokal.

Tentang Penulis

Mert Batur Gurbuz adalah Co-Founder Techsy.io, di mana timnya mengirimkan agen AI, sistem otomatisasi, dan pipeline voice/SDR untuk klien B2B. Ia belajar di University of Birmingham dan menulis tentang tumpukan alat LLM yang benar-benar digunakan oleh tim Techsy dalam produksi.

Kredensial: Co-Founder, Techsy.io, University of Birmingham. Terhubung di LinkedIn.

Pertanyaan yang Sering Diajukan

Apakah menjalankan embedding secara lokal dengan Ollama benar-benar lebih murah daripada API OpenAI?

Hanya di atas ambang batas volume token. Biaya marginal lokal sekitar $0 per juta token ditambah listrik, dibandingkan dengan sekitar $0,02 untuk OpenAI text-embedding-3-small. Di bawah beberapa ratus juta token per bulan, API menang dalam hal kenyamanan dan nol ops. Alasan lain untuk self-host adalah privasi: data Anda tidak pernah meninggalkan mesin.

Apa perbedaan antara /api/embed dan /api/embeddings?

/api/embed adalah endpoint terkini. Ini mengambil bidang input (string atau array untuk batching) dan mengembalikan embeddings. /api/embeddings adalah rute lama yang sudah usang dengan bidang prompt tunggal yang mengembalikan embedding. Jika Anda mengalami 404 atau bentuk respons yang tidak terduga, Anda hampir pasti menggunakan yang lama.

Apakah embedding Ollama gratis?

Ya, dalam arti tidak ada biaya per token dan tidak ada kunci API. Anda membayar untuk perangkat keras dan listrik untuk menjalankannya. Tidak ada penagihan terukur seperti API cloud, jadi sekali GPU Anda berjalan, menghasilkan satu juta embedding lagi pada dasarnya tidak mengeluarkan biaya di margin.

Apa model embedding Ollama default atau terbaik untuk RAG?

nomic-embed-text pada 768 dimensi adalah default populer untuk RAG lokal; ini mengungguli ada-002 lama milik OpenAI dan berjalan pada perangkat keras sederhana. Untuk pekerjaan multibahasa atau konteks panjang, bge-m3 atau qwen3-embedding lebih kuat. Untuk perbandingan peringkat dan skor lintas penyedia, lihat hub model embedding kami.

Mengapa embedding Ollama saya lambat atau time-out?

Permintaan pertama setelah idle membayar startup dingin saat model dimuat ke VRAM, sekitar 1,3 detik di RTX 4090 kami. Ollama juga membongkar model setelah sekitar 5 menit idle secara default, sehingga kelambatan intermiten biasanya merupakan startup dingin yang berulang. Atur keep_alive: -1 untuk menempelkan model di VRAM.

Bisakah Ollama mencocokkan embedding 1536-dimensi OpenAI?

Tidak ada model Ollama yang secara native berdimensi 1536, sehingga migrasi kolom VECTOR(1536) yang ada akan rusak karena ketidakcocokan dimensi. Perbaiki dengan memanggil /v1/embeddings dengan param dimensions pada model Matryoshka seperti qwen3-embedding atau embeddinggemma, atau deklarasikan ulang kolom Anda ke ukuran native model, seperti VECTOR(768).

Apakah saya memerlukan GPU untuk menjalankan model embedding secara lokal?

Tidak. Model kecil seperti nomic-embed-text (137Jt) dan all-minilm (22Jt) berjalan baik di CPU untuk volume rendah. GPU memotong latensi per embedding menjadi milidetik satu digit dan meningkatkan throughput batch menjadi ratusan embedding per detik, yang penting ketika Anda mengindeks ribuan potongan data sekaligus.

Bagaimana cara menggunakan embedding Ollama di Python atau LangChain?

Panggilan klien resmi adalah ollama.embed(model="nomic-embed-text", input=["chunk a", "chunk b"]), yang mengembalikan daftar embeddings. Di LangChain, gunakan kelas OllamaEmbeddings yang mengarah ke http://localhost:11434, lalu berikan ke metode from_documents atau add_texts dari penyimpanan vektor Anda seperti penyedia embedding lainnya.

Berapa panjang konteks yang dapat ditangani oleh model embedding Ollama?

Bervariasi tergantung model. nomic-embed-text secara native mendukung 8192 token tetapi defaultnya ke jendela 2048 token saat disajikan, jadi naikkan num_ctx ke 8192 untuk potongan data panjang atau mereka akan terpotong secara diam-diam. bge-m3 menangani 8192 dan qwen3-embedding mencapai hingga 32K; all-minilm dibatasi pada 256 token.