Ollama dhidi ya vLLM: Utumie seva ipi ya LLM?
Ollama inafaa mtumiaji mmoja na CPU inapohitajika, huku vLLM ikitumia GPU kwa maombi mengi. Chagua kulingana na mzigo, ukitumia amri halisi za zote mbili.
Ollama dhidi ya vLLM, kwa aya moja
Ollama ni meneja wa mifano (model manager) aliye na seva iliyounganishwa: hupakua uzani (weights) zilizopunguzwa ukubwa (quantized), huzipakia, na kujibu kwenye 127.0.0.1:11434, hata kwenye CPU ikiwa ndiyo rasilimali pekee inayopatikana. vLLM ni injini ya utendaji wa juu (throughput engine): huweka GPU katika hali ya kufanya kazi kwa uwezo wake wote kwa kushughulikia maombi mengi kwa wakati mmoja, na ni zana isiyofaa kwenye mashine isiyo na GPU. Hiyo ndiyo msingi wa uamuzi. Mtu mmoja anayezungumza na msaidizi wa ndani (local assistant) ni kazi ya Ollama. Programu inayohudumia timu ni kazi ya vLLM.
Zote mbili hutumia HTTP API inayooana na OpenAI, kwa hivyo msimbo wa mteja (client code) unaweza kuhama kati yao kwa kubadilisha tu base URL. API siyo tofauti iliyopo. Tofauti ni kile kinachotokea wakati ombi la pili linapowasili wakati la kwanza bado linazalisha token.
Ollama ni nini hasa
Ollama ni safu ya urahisi. Inakupa sajili ya modeli (ollama pull llama3.1:8b), hifadhi ya ndani ya weights, chat prompt, huduma ya systemd, na HTTP API, yote kupitia amri moja ya usakinishaji. Modeli nyingi inazohudumia ni faili za GGUF, kwa kawaida zikiwa zimefanyiwa 4-bit quantization, ndiyo maana modeli ya 7B au 8B inachukua takriban 5 GB kwenye diski badala ya 16 GB. Quantization hupunguza kumbukumbu inayohitajika kwa ajili ya CPU inference. Kwenye kompyuta za Apple Silicon Macs, inaweza pia kuendesha modeli za safetensors kupitia injini ya MLX, na tangu toleo la v0.40.0 (Septemba 2026) usanifu unaoungwa mkono huendeshwa kwenye MLX huko moja kwa moja.
Kikimbizaji chake cha GGUF kimejengwa juu ya llama.cpp, maktaba ya C++ ya inference iliyofanya quantization ya GGUF kuwa ya vitendo kwenye vifaa vya kawaida. Kufikia Oktoba 2026, Ollama inasaidia injini mbili, llama.cpp na MLX, na matoleo ya Linux pia yanasaidia MLX inference pamoja na CUDA. Mwongozo wa maendeleo huwezesha backend hiyo kwa cmake -B build . -DOLLAMA_MLX_BACKENDS=cuda_v13, huku kukiwa na mahitaji ya CUDA 13+ na cuDNN 9+. Kwa hivyo, watu wanapolinganisha Ollama na llama.cpp, kwa kiasi kikubwa wanalinganisha safu ya urahisi wa matumizi na kitu inachokifungasha.
Lengo la usanifu wake ni mtumiaji mmoja. Kufikia Oktoba 2026, thamani chaguo-msingi ya OLLAMA_NUM_PARALLEL ni 1, ikimaanisha kuwa modeli moja huchakata ombi moja kwa wakati mmoja na kila kitu kingine husubiri kwenye foleni inayoshikilia maingizo 512 kwa chaguo-msingi (OLLAMA_MAX_QUEUE). Unaweza kuongeza mpangilio wa parallel, na sehemu iliyo hapa chini inaelezea gharama zake. Ikiwa hujawahi kuendesha Ollama hapo awali, anza na hosting Ollama kwenye VPS na kuweka port 11434 ikiwa imefungwa, kwa sababu API ya ndani haihitaji uthibitishaji.
vLLM ni nini hasa
vLLM ni seva ya inference na si kitu kingine. Haidhibiti maktaba ya model, inatoa vllm chat client kwa ajili ya seva inayofanya kazi, na haitapakua model kwa ajili yako wakati wa ombi. Unataja Hugging Face repository wakati wa kuanzisha, inapakia model hiyo moja, na inaihudumia hadi utakapositisha mchakato huo.
Unachopata kwa ufinyu huo ni throughput. Mitambo miwili hufanya kazi hiyo. PagedAttention huhifadhi KV cache (key-value cache, hali ya attention ya kila token ambayo model huweka kwa kila ombi linaloendelea) katika blocks zenye ukubwa maalum, kama vile mfumo wa uendeshaji unavyopanga kumbukumbu (paging). Ombi halihitaji tena nafasi kubwa mfululizo iliyotengwa kwa ajili ya hali mbaya zaidi, hivyo kumbukumbu iliyokuwa imetengwa na kutotumika inapatikana kwa ajili ya maombi mengi zaidi kwa wakati mmoja. Continuous batching inaruhusu ombi jipya kujiunga na batch inayofanya kazi katika hatua inayofuata ya decoding badala ya kusubiri batch ya sasa imalizike. Mlolongo uliokamilika huondoka kwenye batch mara moja na nafasi yake hujazwa tena.
Matokeo ya kivitendo: kwenye GPU moja, kutoka kwa mtumiaji mmoja hadi thelathini huongeza jumla ya tokens kwa sekunde kwa kasi, wakati kasi kwa kila mtumiaji hushuka kidogo sana kuliko unavyotarajia. Chini ya mpangilio chaguo-msingi wa Ollama, kutoka kwa mtumiaji mmoja hadi thelathini huwafanya watu ishirini na tisa kusubiri tu.
Batching endelevu ndiyo tofauti yote
Fikiria maombi matano yakifika kwenye kila seva kwa wakati mmoja, kwenye hardware inayofanana.
Ollama yenye mipangilio chaguomsingi hushughulikia ombi la kwanza hadi likamilike, kisha ombi la pili, na kuendelea hivyo. Mpigaji simu wa tano husubiri generations nne kamili. Throughput ya jumla huwa karibu sawa na kasi ya generation moja, kwa sababu processor hushughulikia sequence moja tu wakati wowote.
vLLM hu-decode yote matano katika forward pass moja. Kutengeneza token moja kwa sequences tano hugharimu kiasi kidogo tu zaidi ya kutengeneza token moja kwa sequence moja, kwa sababu sehemu inayogharimu zaidi ni kusoma model weights kutoka kwenye memory, na usomaji huo hushirikiwa na batch nzima. Hii ni kanuni ileile ya memory bandwidth inayofanya CPU inference iwe polepole: gharama kubwa iko kwenye kuhamisha weights, si kwenye kufanya hesabu.
Unaweza kuweka OLLAMA_NUM_PARALLEL=4 na kupata sehemu ya uwezo huu. Gharama yake ni memory. Kila parallel slot inahitaji KV cache yake, na Ollama huzidisha context allocation badala ya kuigawa: FAQ yake inasema RAM inayohitajika huongezeka kwa mara OLLAMA_NUM_PARALLEL ya OLLAMA_CONTEXT_LENGTH. Kwa hiyo, maombi manne ya wakati mmoja dhidi ya model iliyosanidiwa kwa tokens 8192 huhifadhi tokens 8192 kwa kila ombi, lakini seva lazima iwe na cache ya jumla ya tokens 32768. Hiyo 8192 yenyewe ni chaguo, si thamani iliyowekwa tayari. Kwa hiyo, kuongeza num_ctx na kupanga RAM inayohitajika ndilo hatua linaloamua kama slots nne zinaweza kutoshea kabisa. Paged cache ya vLLM ndiyo huepuka kuhifadhi window nzima mapema kwa kila slot, kwa sababu blocks hutengewa ombi kadiri ombi lenyewe linavyokua. Kwa hali yoyote, kikomo cha idadi ya watu ambao seva moja inaweza kuwahudumia kwa wakati mmoja hutegemea ukubwa wa KV cache, gharama ya prefill na kina cha queue. Hiyo ndiyo sababu seva iliyokuwa ikifanya kazi vizuri kwa mtu mmoja husuasua kwa watu watano.
Sakinisha na uendeshe kwa Ollama
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1:8b
ollama run --verbose llama3.1:8b "Write two sentences about Linux."Script ya usakinishaji huunda mtumiaji wa mfumo wa ollama, husakinisha binary, na kusajili ollama.service iliyofungwa kwenye 127.0.0.1:11434. Mstari wa eval rate unaochapishwa na --verbose unaonyesha tokens per second halisi kwenye mashine hiyo. Uamini zaidi kuliko takwimu yoyote iliyochapishwa. Kipimo kimoja kutoka kwa prompt moja ni mwanzo tu, si namba ya uwezo. Kwa hiyo, kupima tokens per second katika viwango tofauti vya concurrency ndiko kunakoonyesha kama mashine inaweza kuhimili mzigo unaotarajiwa, na kama kukodisha GPU kuna gharama ndogo kuliko kulipia kila token.
Ili kuongeza concurrency, tumia systemd drop-in ili upgrade isifute mabadiliko hayo:
sudo systemctl edit ollama.service[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_KEEP_ALIVE=30m"sudo systemctl restart ollama
ollama psollama ps huonyesha kilichopakiwa, na safu yake ya PROCESSOR huonyesha hali halisi. 100% CPU inamaanisha kuwa hakuna GPU inayotumika. Hilo ndilo jibu la kweli kwa ripoti nyingi kwamba Ollama ni slow. Mstari wa OLLAMA_KEEP_ALIVE=30m katika drop-in hiyo ni muhimu vilevile kwenye mashine isiyotumika sana, kwa sababu chaguo-msingi huondoa model baada ya dakika tano bila request. Kuweka model ikiwa resident kati ya requests ndiko kunakozuia prompt ya kwanza baada ya kipindi cha kutokuwa na shughuli cha hadi nusu saa kulipa tena muda wote wa kupakia model. Ikiwa vipindi vyako vya kutokuwa na shughuli ni virefu zaidi ya hapo, weka value ndefu zaidi.
Kusakinisha na kuhudumia kwa kutumia vLLM
Matoleo ya GPU ya vLLM yanahitaji Linux (macOS kwenye Apple Silicon ina usaidizi wa CPU pekee kupitia wheel iliyojengwa awali katika toleo la 0.32.0, na kasi ya GPU kwenye Mac hizo hutoka kwa vLLM-Metal, plugin tofauti inayodumishwa na jamii na kujengwa juu ya MLX). Kwenye Python, toleo la sasa (0.32.0, Oktoba 2026) linakubali 3.11 hadi 3.14, na mwongozo wa usakinishaji unaorodhesha masafa hayo hayo. Python 3.10 iliondolewa katika 0.32.0, kwa hivyo 3.12, inayotumika hapa chini, ndiyo chaguo salama. Isakinishe kwenye virtual environment yake yenyewe, kwa sababu inavuta build mahususi ya PyTorch:
uv venv --python 3.12 --seed
source .venv/bin/activate
uv pip install vllm --torch-backend=auto
vllm download-kernelsMstari wa mwisho umo kwenye mwongozo wa usakinishaji wa NVIDIA wa vLLM kufikia Oktoba 2026. Inasakinisha kernels zilizokusanywa awali za FlashInfer. Bila hizo, vLLM hupakua na kukusanya kernels wakati wa kuanza, jambo ambalo mwongozo unasema linaweza kuongeza dakika kadhaa kwenye Hopper na GPU mpya zaidi. Iendeshe tena baada ya kila upgrade ya vLLM, kwa sababu FlashInfer hukataa kuingiza (import) kernels zisipolingana.
Kisha hudumia model. Jina ni kitambulisho cha repository ya Hugging Face, si tag fupi:
vllm serve Qwen/Qwen2.5-1.5B-InstructKuanza ni polepole mara ya kwanza, kwa sababu inapakua weights na kisha kuchunguza (profile) GPU ili kuamua ni vizuizi vingapi vya KV cache vinaweza kutoshea. Inasikiliza kwenye port 8000. Iangalie kabla ya kuandika code yoyote ya client:
curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model": "Qwen/Qwen2.5-1.5B-Instruct", "messages": [{"role": "user", "content": "Who won the world series in 2020?"}]}'Ikiwa Docker tayari iko kwenye seva, image rasmi inaepuka kazi ya utegemezi wa CUDA:
docker run --runtime nvidia --gpus all \
-v ~/.cache/huggingface:/root/.cache/huggingface \
--env "HF_TOKEN=$HF_TOKEN" \
-p 8000:8000 \
--ipc=host \
vllm/vllm-openai:latest \
--model Qwen/Qwen3-0.6B--ipc=host inatoa container uwezo wa kufikia shared memory ya host; kuongeza --shm-size ni chaguo jingine. PyTorch hupitisha tensors kati ya processes kupitia shared memory, hasa kwa ajili ya tensor-parallel inference.
Flags ambazo ni muhimu zaidi katika uzalishaji (production) ni --max-model-len (dirisha la muktadha ambalo uko tayari kulipia), --gpu-memory-utilization (sehemu ya kadi ambayo vLLM inaweza kudai, 0.92 kwa chaguo-msingi kufikia Oktoba 2026), --tensor-parallel-size kwa ajili ya kugawanya model moja kwenye GPU kadhaa, na --api-key.
Uthibitishaji ni flag moja kwenye vLLM na haipo kwenye API ya ndani ya Ollama
vLLM inalazimisha bearer token ikiwa utaipa:
vllm serve Qwen/Qwen2.5-1.5B-Instruct --api-key token-abc123Thamani hiyo hiyo inaweza kutoka kwenye variable ya mazingira ya VLLM_API_KEY. Ombi lolote kwenye njia za /v1 bila token hiyo hupata HTTP 401. Hata hivyo, ufunguo huu hauhusu seva nzima. Mwongozo wa usalama wa vLLM, na msimbo wa uthibitishaji katika chanzo cha 0.32.0, unauweka kwenye endpoints zilizo chini ya viambishi awali vya njia vya /v1, /v2, /inference, na /cohere pekee. Maandishi ya usaidizi ya --api-key kwenye ukurasa wa vllm serve yanaorodhesha tatu za kwanza pekee, lakini msimbo hukagua zote nne. Mwongozo na maandishi ya usaidizi yote yanasema kuwa endpoints nyingine, hasa /invocations, ambayo hufichua inference ile ile kama /v1, hazina uthibitishaji. Hiyo ni sababu tosha ya kutochapisha port 8000 kwenye interface ya umma. Mwongozo wa usalama wa vLLM pia huacha suala la rate limiting kwa reverse proxy iliyo mbele yake, na token inayotumwa kupitia HTTP ya kawaida inaweza kusomeka wakati wa usafirishaji, lakini flag hiyo inamaanisha kuwa seva ina dhana ya mpigaji simu.
API ya ndani ya Ollama haihitaji uthibitishaji wowote. Miundo ya wingu (cloud models), uchapishaji wa miundo, na upakuaji wa miundo ya faragha vinahitaji kuingia (sign-in); ufikiaji wa moja kwa moja wa API kwenye ollama.com unahitaji API key. Mchakato wowote unaoweza kufikia 11434 unaweza kuendesha, kuvuta (pull), au kufuta miundo. Iweke kwenye loopback na uifikie kupitia VPN ya WireGuard unayojiendeshea mwenyewe, au kupitia reverse proxy inayothibitisha na kumalizia TLS (transport layer security).
Vifaa: kila moja inahitaji nini
Ollama huendeshwa kwenye CPU. Modeli yenye quantization ya biti 4 hutumia takribani nusu gigabaiti ya RAM kwa kila parameter bilioni moja, pamoja na takribani gigabaiti moja ya overhead ya wakati wa kuendesha na zaidi kwa context. Kwa hiyo, modeli ya 3B inahitaji takribani 4 GB za RAM iliyo huru, na modeli ya 8B inahitaji takribani 8 GB. Kasi kwenye vCPU inayoshirikiwa huwa tokeni chache kwa sekunde hadi tokeni za tarakimu mbili za chini kwa sekunde. Hii husababishwa na bandwidth ya memory, si configuration isiyofaa, na hakuna flag inayoweza kuirekebisha. Ili kuona hesabu hiyo ikitekelezwa kwenye release maalum badala ya kutumia makadirio ya jumla, kuendesha Nemotron 3.5 Lightning kwenye VPS huweka tag sahihi ya kupakua, RAM inayotumiwa baada ya model kupakiwa, na kama CPU pekee ina kasi inayokubalika kwa matumizi ya kawaida.
vLLM hudhani kuwa kuna GPU. Njia yake ya kawaida huhudumia weights zisizo na quantization kwa precision ya biti 16, ambazo hutumia takribani 2 GB kwa kila parameter bilioni moja. Kwa hiyo, modeli ya 8B inahitaji takribani 16 GB za video memory kwa weights pekee, kabla ya kuhesabu KV cache inayokuwezesha concurrency uliyoisakinishia vLLM. Kwenye kadi ya 24 GB, hiyo huacha cache yenye nafasi ya kutosha. Kwenye kadi ya 16 GB, haitoshi. Kwa hiyo, unahitaji kuchagua modeli ndogo, kupitisha --quantization (pamoja na checkpoint yenye quantization, au ili kufanya quantization ya weights zenye precision kamili wakati wa kupakia), au kuhamisha sehemu ya weights kwenye system RAM kwa kutumia --cpu-offload-gb. Njia hii huhifadhi precision yake, lakini huwa polepole kwa sababu weights hizo huhamishwa kwenda kwenye GPU katika kila forward pass. Backend ya CPU ipo, ikiwa na wheels zake tofauti, lakini huondoa sababu ya kutumia vLLM.
Kwa hiyo, mara nyingi swali la hardware huamua jibu la swali la software. Ikiwa hakuna GPU, tumia Ollama. GPU ya kukodisha inayotumika kwa asilimia 5 kwa sababu maombi yanaendeshwa kwa mfuatano inamaanisha utumie vLLM.
Ni ipi inayofaa kwa mzigo wako wa kazi
- Mtu mmoja, CPU VPS, kwa ajili ya kuandaa rasimu na kufupisha: Ollama. Kasi yake inakubalika na hakuna kitu kingine rahisi zaidi.
- Msaidizi wa uandishi wa msimbo, au seva ya MCP inayounganisha zana zako na modeli ya ndani, ambayo wewe pekee ndiye unayeitumia: Ollama. Utekelezaji wa kazi moja kwa wakati mmoja ndio mzigo halisi wa kazi.
- Kulinganisha modeli tano kwa wiki hii: Ollama. Kuvuta na kufuta modeli zilizotambulishwa ndilo jambo ambalo inalifanya vizuri, wakati vLLM inahitaji kuanzisha upya mchakato (process) kwa kila modeli.
- Programu ya ndani, bidhaa ya gumzo, au mfumo wa urejeshaji data wenye watumiaji halisi: vLLM. Hapa ndipo uwezo wa batching unahalalisha gharama ya GPU.
- Kazi ya kundi (batch job) inayochakata mamia ya maelfu ya hati usiku kucha: vLLM, ikiwa na
--max-num-seqsya juu. Kiwango cha utendaji (throughput) ndicho kipimo pekee cha maana na muda wa kusubiri kwa kila hati (per-document latency) si muhimu. - Jukwaa la wakala ambapo mawakala wa AI wanaojiendesha wenyewe wanatumia modeli kwa wakati mmoja: vLLM, kwa sababu trafiki ya mawakala huwa ya ghafla na ya sambamba (parallel) kwa asili yake.
Njia za kushindwa, pamoja na ujumbe utakaouona
vLLM inakataa kuanza na hitilafu ya KV cache. Ujumbe huo unataja namba zote mbili:
ValueError: To serve at least one request with the model's max seq len (32768), (4.00 GiB KV cache is needed, which is larger than the available KV cache memory (1.00 GiB). Based on the available memory, the estimated maximum model length is 8192. Try increasing `gpu_memory_utilization` (which also controls CPU memory on the CPU backend) or decreasing `max_model_len` when initializing the engine. See https://docs.vllm.ai/en/latest/configuration/conserving_memory/ for more details.Modeli inatangaza context window kubwa kuliko kumbukumbu iliyobaki baada ya kupakia weights. Ipunguze kwa kutumia --max-model-len 8192, au ongeza --gpu-memory-utilization ikiwa hakuna kitu kingine kinachotumia kadi hiyo.
Ollama inachapisha Killed wakati wa generation. OOM killer wa Linux amesimamisha mchakato huo kwa sababu modeli ilihitaji RAM nyingi kuliko ile iliyopo kwenye seva. Thibitisha kwa sudo dmesg | grep -i oom. Suluhisho ni kutumia modeli ndogo au iliyofanyiwa quantization zaidi, siyo kubadili mipangilio.
Ollama inajibu vizuri ikiwa peke yake lakini inakwama chini ya mzigo. Hakuna hitilafu inayoonekana popote. Maombi huchukua muda mrefu kadiri idadi ya watumiaji inavyoongezeka, kwa sababu OLLAMA_NUM_PARALLEL=1 inayaweka kwenye foleni ya mfululizo. Majibu marefu yanazidisha foleni, kwa sababu mtumiaji mmoja anayeshikilia nafasi pekee hadi modeli iamue kusimama anawazuia wengine wote walio nyuma yake, kwa hivyo kupunguza jibu kwa num_predict huweka ukomo wa muda ambao zamu moja inaweza kushikilia seva. Ongeza mpangilio wa parallel na ukubali RAM ya ziada inayohitajika na context ya kila nafasi, au hamishia mzigo wa kazi kwenye vLLM.
vLLM inarudisha 401 kwenye kila ombi la /v1. Uliianzisha kwa --api-key na mteja hatumi header ya Authorization. Maktaba nyingi za mteja wa OpenAI hutuma chochote unachopitisha kama key, kwa hivyo iweke hapo badala ya kuondoa flag hiyo.
vLLM inasema modeli haijapatikana. Ollama hupakua inapohitajika, vLLM haifanyi hivyo. Sehemu ya model katika mwili wa ombi lazima ilingane na repository id uliyotumia wakati wa kuanzisha, au thamani ya --served-model-name ikiwa uliweka moja. Thibitisha mfuatano kamili wa herufi kwa curl http://localhost:8000/v1/models.
Kuendesha zote mbili ni jibu linalofaa
Hizi si huduma zinazotengana. Muundo wa kawaida ni kutumia vLLM kwenye instance ya GPU inayohudumia programu, huku Ollama ikiwa kwenye VPS ya kawaida kando yake kwa ajili ya hati za ndani (scripts), cron jobs, na kujaribu matoleo mapya ya model. Endpoint zote mbili zinaoana na OpenAI, kwa hivyo maktaba moja ya mteja na kubadili base-URL kunatosha kuzitumia zote. Udhibiti wa gharama ni muhimu zaidi hapa kuliko injini yoyote kati ya hizo, kwa sababu GPU iliyo wazi hutoza gharama sawa na ile inayofanya kazi, na kudumisha gharama za wakala na inference kuwa zinazotabirika ni taaluma tofauti na kuchagua seva.
FAQ
Je, vLLM ni ya kasi zaidi kuliko Ollama?
Kwa ombi moja kwenye GPU ileile, tofauti ni ndogo, kwa sababu zote hufanya hesabu zilezile. Kwa maombi mengi yanayokuja kwa wakati mmoja, vLLM iko mbele zaidi, kwa sababu continuous batching hufanya decoding ya kila sequence inayotumika katika forward pass moja, wakati Ollama kwa kawaida huyaendesha moja baada ya jingine. Kwenye mashine yenye CPU pekee, zote zina njia za inference zinazotumika, huku vLLM ikitumia CPU wheels tofauti.
Je, vLLM inaweza kufanya kazi bila GPU?
Ndiyo, kupitia CPU backend yake. Wheels za kawaida hulenga NVIDIA au AMD GPUs, na sababu ya kuwepo kwa vLLM, yaani kuweka accelerator ikiwa na shughuli nyingi kwa maombi yaliyopangwa (batched), hupotea kwenye CPU. CPU backend ipo, ikiwa na wheels tofauti kwa x86 na Arm. Kwa inference halisi ya CPU, tumia Ollama au llama.cpp moja kwa moja.
Kuna tofauti gani kati ya Ollama na llama.cpp?
llama.cpp ni maktaba ya inference, na GGUF ni muundo wake wa uzito (weight format) uliopunguzwa ukubwa (quantized). Ollama huitumia kwa inference ya GGUF na huongeza sajili ya modeli, vipakuliwa vilivyo na tag, usimamizi wa modeli, na systemd unit. Ollama pia husafirisha MLX engine inayoendesha modeli za safetensors kwenye Apple Silicon na inasaidia builds za CUDA kwenye Linux, kwa hivyo hizi mbili si sawa kila wakati chini ya mfumo.
vLLM inahitaji kiasi gani cha GPU memory kwa modeli ya 8B?
Katika usahihi wa 16-bit, uzito pekee ni takriban 16 GB, takriban 2 GB kwa kila bilioni ya vigezo (parameters), na KV cache inahitaji nafasi zaidi ya hiyo. Kadi ya 24 GB inatosha vizuri. Kadi ya 16 GB inahitaji modeli iliyopunguzwa ukubwa (quantized), modeli ndogo zaidi, au --cpu-offload-gb ili kuhamisha sehemu ya uzito kwenye system RAM kwa gharama ya kasi. vLLM hutenga sehemu ya kadi iliyowekwa na --gpu-memory-utilization, ambayo kwa kawaida ni 0.92 kufikia Oktoba 2026.
Je, ninahitaji kubadilisha msimbo wa programu yangu ili kubadili kati ya hizi mbili?
Kwa kawaida ni base URL, API key, na jina la modeli pekee. Ollama hutoa huduma yake inayooana na OpenAI kwenye http://127.0.0.1:11434/v1 na hupuuza ufunguo (key), wakati vLLM hutoa http://localhost:8000/v1 na hulazimisha ufunguo kwenye routes zake za /v1 ikiwa utauweka. Majina ya modeli hutofautiana katika umbo: llama3.1:8b kwa Ollama, kitambulisho kamili cha hazina (repository id) kama vile Qwen/Qwen2.5-1.5B-Instruct kwa vLLM.