Uruchamianie modeli embeddingowych lokalnie z Ollama: zmierzyłem czas zimnego i gorącego startu GPU

Uruchamianie modeli embeddingowych lokalnie z Ollama: zmierzyłem czas zimnego i gorącego startu GPU

Możesz uruchamiać modele embeddingowe lokalnie z Ollama i przestać płacić OpenAI 0,02 USD za milion tokenów za każdy fragment indeksowanych danych. Kompromis? To Ty jesteś właścicielem GPU, zarządzasz zimnymi startami i operacjami. Ollama udostępnia je na porcie 11434 bez klucza API. Oto pełny przepływ pracy, od ollama pull po ciepłe wyszukiwanie wektorowe odpowiadające na zapytania.

Kluczowe wnioski

• Ollama udostępnia embeddingi lokalnie pod adresem http://localhost:11434 przez POST /api/embed, bez klucza API i przy koszcie 0 USD za token.
• Używaj /api/embed (aktualne, tablica wsadowa); /api/embeddings to przestarzały endpoint, będący częstym źródłem błędów 404.
• Popularne modele lokalne: nomic-embed-text (768 wymiarów), mxbai-embed-large (1024), bge-m3 (1024), embeddinggemma (768).
• Dopasuj wymiar embeddingu do kolumny w bazie wektorowej i przypnij model parametrem keep_alive, aby pominąć opóźnienie zimnego startu.

Czego potrzebujesz, aby uruchomić embeddingi lokalnie z Ollama?

Wszystko, czego potrzebujesz do lokalnego uruchomienia embeddingów, to trzy elementy: model embeddingowy, serwer Ollama na porcie 11434 oraz magazyn wektorowy do przechowywania wyników. Ollama pobiera i udostępnia model; Twój kod wysyła tekst do /api/embed; wektory trafiają do bazy danych takiej jak pgvector, Qdrant lub Chroma. Brak podróży do chmury, brak rozliczeń za tokeny.

Dwa polecenia pozwalają uzyskać działający embedding w mniej niż minutę:

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

To cały szybki start. Reszta tego poradnika uzupełnia wybór modelu, magazynu oraz omawia dwie pułapki, które dopadają każdego: nieporozumienia dotyczące endpointów i karę za zimny start.

Krok 1: Instalacja Ollama i pobranie modelu embeddingowego

Zainstaluj Ollama, potwierdź, że serwer nasłuchuje na porcie 11434, a następnie pobierz model embeddingowy. Ollama działa jako usługa w tle, więc ollama pull nomic-embed-text pobiera wagi, a kolejne wywołanie /api/embed je obsługuje. Modele embeddingowe są malutkie w porównaniu do modeli konwersacyjnych, więc proces ten jest szybki.

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

Najlepsza część: model embeddingowy taki jak nomic-embed-text ma tylko 137 milionów parametrów, co oznacza pobieranie około 274 MB, w przeciwieństwie do wielogigabajtowych modeli chat. Ładuje się do pamięci VRAM w około sekundę. Jeśli chcesz pełnej lokalnej konfiguracji LLM, aby model konwersacyjny działał obok Twojego embeddera, nasz przewodnik po konfiguracji Ollama dla lokalnych LLM omawia tę ścieżkę, a interfejs użytkownika dla Twoich lokalnych modeli Ollama jest opcją, jeśli wolisz klikać niż używać curl.

Wskazówka: serwer musi być uruchomiony przed jakimkolwiek żądaniem. Odmowa połączenia na :11434 prawie zawsze oznacza, że ollama serve nie działa.

Jaki lokalny model embeddingowy pobrać?

Dla większości lokalnych zastosowań RAG, nomic-embed-text o 768 wymiarach jest bezpiecznym domyślnym wyborem. Pokonuje starego ada-002 od OpenAI i działa na prawie każdym sprzęcie. Sięgnij po bge-m3 lub qwen3-embedding, gdy potrzebujesz wielojęzycznego pobierania danych lub obsługi długiego kontekstu, all-minilm dla szybkości na słabym sprzęcie, a embeddinggemma jako nowszą opcję od Google. Poniższa tabela obejmuje aktualną bibliotekę modeli embeddingowych Ollama jako decyzję serwisową, a nie ranking jakości.

Na wątkach „najlepszy model embeddingowy ollama reddit” powtarzającym się konsensusem jest nomic-embed-text do ogólnego RAG i bge-m3 w przypadku pracy wielojęzycznej, co zgadza się z tym, co dostarczamy. Jeśli chcesz ranked, cross-provider view z wynikami, to zadanie dla hubu: który model embeddingowy wybrać do RAG. Celowo pomijamy tutaj liczby MTEB; nasz artykuł towarzyszący na temat jak wyniki MTEB działają w RAG wyjaśnia, dlaczego sam ranking może wprowadzać w błąd.

Krok 2: Generowanie embeddingów przez /api/embed

Wyślij tekst do POST /api/embed, a Ollama zwróci wektory znormalizowane L2, co oznacza, że każdy z nich ma długość jednostkową, dzięki czemu podobieństwo kosinusowe działa bezpośrednio. Zgodnie z dokumentacją embeddingów Ollama, aktualny endpoint przyjmuje pole input, które akceptuje pojedynczy ciąg znaków lub tablicę do wsadowego przetwarzania, i zwraca {"embeddings": [[...]]}.

Surowe wywołanie HTTP:

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

W Pythonie oficjalny klient to jedna linijka na 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

Wsadowe przetwarzanie przez tablicę input to główna dźwignia przepustowości. Jedno żądanie z 64 fragmentami przewyższa 64 pojedyncze żądania o szeroką margines, ponieważ ponosisz narzut na wywołanie tylko raz. Zwróć uwagę na zwiększenie num_ctx: nomic-embed-text domyślnie używa okna 2048 tokenów, mimo że natywnie obsługuje 8192, więc długie fragmenty są cicho obcinane, chyba że to zmienisz. Embedding to jeden z etapów pełnego potoku RAG, do którego to prowadzi; logika chunkingu i pobierania danych znajduje się tam, a nie tutaj.

/api/embed vs /api/embeddings vs /v1/embeddings: jaka jest różnica?

/api/embed to aktualny endpoint; /api/embeddings to przestarzały endpoint, stojący za większością postów „Ollama embeddings not working”. Starsza trasa używa pojedynczego pola prompt i zwraca embedding (bez s), podczas gdy obecna trasa używa input, akceptuje batche i zwraca embeddings. Trzecia trasa, /v1/embeddings, jest kompatybilna z OpenAI i akceptuje parametr dimensions.

Otrzymujesz 404 lub dziwny kształt odpowiedzi? Prawdopodobnie korzystasz z /api/embeddings (legacy). Przełącz się na /api/embed i odczytuj klucz embeddings zamiast embedding. Ten pojedynczy znak myli wiele osób kopiujących stare poradniki.

Trasa /v1/embeddings ma znaczenie w jednym konkretnym przypadku: migracji z OpenAI. Ponieważ akceptuje parametr dimensions, możesz obciąć model zdolny do Matryoshki do docelowego rozmiaru, co jest rozwiązaniem niedopasowania 1536 wymiarów, które omawiamy dalej.

Krok 3: Przechowywanie i wyszukiwanie wektorów (pgvector, Qdrant lub Chroma)

Przechowuj wektory 768-float w bazie danych obsługującej wyszukiwanie najbliższych sąsiadów, a następnie wykonuj zapytania z odległością kosinusową. W naszych budowlach RAG domyślnie wybieramy Postgres plus pgvector dla zespołów już korzystających z Postgresa, ponieważ utrzymuje embeddingi obok danych relacyjnych. Włącz rozszerzenie, zadeklaruj kolumnę VECTOR(768) pasującą do wymiaru modelu, wstaw dane i wykonuj zapytania operatorem kosinusowym <=>.

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 i Chroma działają koncepcyjnie tak samo: utwórz kolekcję o stałym rozmiarze wektora pasującym do modelu, a następnie wykonuj upsert i wyszukiwanie. Zasada obowiązuje wszędzie: wybór bazy wektorowej ma mniejsze znaczenie niż prawidłowe dobranie wymiaru, ponieważ Qdrant, Chroma i pgvector odrzucają wektor, którego rozmiar nie pasuje do kolekcji. Zobacz nasze porównanie Qdrant vs Chroma vs pgvector, jeśli nadal się wahasz.

Pułapka migracji: żaden model Ollama nie ma natywnie 1536 wymiarów, więc istniejąca kolumna pgvector VECTOR(1536) je odrzuci. Trzy rozwiązania: (1) wybierz model, którego wymiar pasuje do kolumny, (2) użyj /v1/embeddings z parametrem dimensions na modelu Matryoshka, takim jak qwen3-embedding lub embeddinggemma, aby obciąć do 1536, lub (3) zadeklaruj ponownie kolumnę do natywnego wymiaru modelu, np. VECTOR(768).

Zmierzyliśmy nomic-embed-text na RTX 4090: Zimny start vs Gorący GPU

Zmierzyliśmy to. Na naszej maszynie (Ubuntu 22.04, RTX 4090 24 GB, Ollama 0.5.x, nomic-embed-text 768-wymiarowy), pierwsze /api/embed po okresie bezczynności trwało około 1,3 sekundy, podczas gdy wagi ładowały się do VRAM. Po rozgrzaniu widzieliśmy p50 blisko 9 ms i p95 blisko 22 ms na embedding. Przy batchu 64 utrzymywaliśmy około 600 embeddingów/sek.

Oto haczyk, który odpowiada na pytanie „dlaczego embeddingi Ollama są wolne lub przekraczają limit czasu”. Domyślnie Ollama usuwa model z VRAM po około 5 minutach bezczynności. Twoje kolejne żądanie ponownie ponosi koszt ~1,3 s zimnego startu, co w produkcji wygląda jak losowy skok. Rozwiązaniem jest keep_alive:

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

Ustawienie keep_alive: -1 przypina model w VRAM na czas nieokreślony, dzięki czemu każde żądanie pozostaje na ścieżce „gorącej”. Przy nagrzanym nomic-embed-text na RTX 4090 p95 wynosiło około 22 ms. Pozwól mu bezczynnie stać przez 5 minut, a Twoje kolejne żądanie ponownie zapłaci ~1,3 s za zimny start. Dla usług wrażliwych na opóźnienia, przypnij go.

Czy self-hosting embeddingów się opłaca? Koszt vs API

Lokalne embeddingi kosztują marginalnie około 0 USD za milion tokenów, plus prąd, w porównaniu do około 0,02 USD za milion tokenów dla OpenAI text-embedding-3-small. Ale szczerze mówiąc: self-hosting wygrywa dopiero powyżej pewnego progu objętości tokenów. Poniżej kilkuset milionów tokenów miesięcznie płacisz czasem operacyjnym i bezczynnym GPU, a nie oszczędzasz dolary. Wygoda API triumfuje przy niskiej objętości.

Self-hosting embeddingów pokonuje API dopiero powyżej około kilkuset milionów tokenów miesięcznie. Poniżej tego poziomu płacisz czasem operacyjnym, a nie oszczędzasz pieniądze. Gdzie lokalne rozwiązanie jest złym dopasowaniem: niska liczba zapytań, brak GPU lub zespół bez zdolności operacyjnych do utrzymania serwera. W takich przypadkach zarządzane API jest pragmatycznym wyborem, a porównanie API embeddingowych Voyage, OpenAI i Cohere to kolejny krok do przeczytania. Nie jesteś pewien, czy chcesz w ogóle posiadać GPU i zajmować się operacjami? Wiele zespołów utrzymuje embeddingi lokalnie ze względu na prywatność, ale angażuje pomoc przy konfiguracji i utrzymaniu po wdrożeniu, czym zajmuje się nasza usługa integracji AI. Jeśli chcesz porównać środowiska uruchomieniowe, zobacz inne narzędzia do uruchamiania modeli lokalnie.

O autorze

Mert Batur Gurbuz jest współzałożycielem Techsy.io, gdzie zespół dostarcza agentów AI, systemy automatyzacji oraz pipeline'y voice/SDR dla klientów B2B. Studiuje na University of Birmingham i pisze o stosie narzędzi LLM, z którego zespół Techsy faktycznie korzysta w produkcji.

Poświadczenia: Współzałożyciel, Techsy.io, University of Birmingham. Połącz się na LinkedIn.

Często zadawane pytania

Czy uruchamianie embeddingów lokalnie z Ollama jest naprawdę tańsze niż API OpenAI?

Tylko powyżej pewnego progu objętości tokenów. Lokalny koszt marginalny to około 0 USD za milion tokenów plus prąd, w porównaniu do około 0,02 USD za OpenAI text-embedding-3-small. Poniżej kilkuset milionów tokenów miesięcznie API wygrywa wygodą i zerowym obciążeniem operacyjnym. Innym powodem self-hostingu jest prywatność: Twoje dane nigdy nie opuszczają maszyny.

Jaka jest różnica między /api/embed a /api/embeddings?

/api/embed to aktualny endpoint. Przyjmuje pole input (ciąg znaków lub tablica do batchowania) i zwraca embeddings. /api/embeddings to starsza, przestarzała trasa z pojedynczym polem prompt, która zwraca embedding. Jeśli trafiasz na 404 lub nieoczekiwany kształt odpowiedzi, prawie na pewno korzystasz ze starej wersji.

Czy embeddingi Ollama są darmowe?

Tak, w sensie, że nie ma opłaty za token ani klucza API. Płacisz za sprzęt i prąd potrzebny do jego uruchomienia. Nie ma rozliczeń meterowanych jak w chmurze, więc gdy Twój GPU już działa, wygenerowanie kolejnego miliona embeddingów kosztuje marginalnie praktycznie nic.

Jaki jest domyślny lub najlepszy model embeddingowy Ollama do RAG?

nomic-embed-text o 768 wymiarach to popularny domyślny wybór do lokalnego RAG; jest lepszy niż stary ada-002 od OpenAI i działa na скромnym sprzęcie. Do pracy wielojęzycznej lub z długim kontekstem, bge-m3 lub qwen3-embedding są mocniejsze. Dla ranked, scored comparison across providers, zobacz nasz hub modeli embeddingowych.

Dlaczego moje embeddingi Ollama są wolne lub przekraczają limit czasu?

Pierwsze żądanie po bezczynności płaci za zimny start, podczas gdy model ładuje się do VRAM, co na naszym RTX 4090 trwa około 1,3 sekundy. Ollama domyślnie usuwa model po około 5 minutach bezczynności, więc przerywana wolność to zwykle powtarzający się zimny start. Ustaw keep_alive: -1, aby przypiąć model w VRAM.

Czy Ollama może dopasować 1536-wymiarowe embeddingi OpenAI?

Żaden model Ollama nie ma natywnie 1536 wymiarów, więc migracja istniejącej kolumny VECTOR(1536) kończy się błędem niedopasowania wymiarów. Napraw to, wywołując /v1/embeddings z parametrem dimensions na modelu Matryoshka, takim jak qwen3-embedding lub embeddinggemma, lub zadeklaruj ponownie kolumnę do natywnego rozmiaru modelu, np. VECTOR(768).

Czy potrzebuję GPU, aby uruchamiać modele embeddingowe lokalnie?

Nie. Małe modele, takie jak nomic-embed-text (137M) i all-minilm (22M), działają dobrze na CPU przy niskiej objętości. GPU skraca opóźnienie per-embedding do jednocyfrowych milisekund i zwiększa przepustowość wsadową do setek embeddingów na sekundę, co ma znaczenie, gdy indeksujesz tysiące fragmentów naraz.

Jak używać embeddingów Ollama w Pythonie lub LangChain?

Oficjalne wywołanie klienta to ollama.embed(model="nomic-embed-text", input=["chunk a", "chunk b"]), które zwraca listę embeddings. W LangChain użyj klasy OllamaEmbeddings wskazującej na http://localhost:11434, a następnie przekaż ją do metody from_documents lub add_texts swojego magazynu wektorowego, jak każdego innego dostawcy embeddingów.

Jaką długość kontekstu mogą obsłużyć modele embeddingowe Ollama?

Zależy to od modelu. nomic-embed-text natywnie obsługuje 8192 tokeny, ale domyślnie używa okna 2048 tokenów podczas serwowania, więc zwiększ num_ctx do 8192 dla długich fragmentów, inaczej zostaną one cicho obcięte. bge-m3 obsługuje 8192, a qwen3-embedding sięga do 32K; all-minilm jest ograniczony do 256 tokenów.