Ollama vs vLLM: ఏ LLM server ఎంచుకోవాలి?

Ollama vs vLLM, ఒక పేరాలో

Ollama అనేది server‌తో కూడిన model manager. ఇది quantized weights‌ను download చేసి, load చేసి, 127.0.0.1:11434లో సమాధానాలు ఇస్తుంది. యంత్రంలో CPU మాత్రమే ఉన్నా ఇది పనిచేస్తుంది. vLLM అనేది throughput engine. ఇది ఒకేసారి నడుస్తున్న అనేక requests‌తో GPU వినియోగాన్ని గరిష్ఠంగా ఉంచుతుంది. GPU లేని యంత్రంలో ఇది సరైన సాధనం కాదు. నిర్ణయం ఇంతే. ఒక వ్యక్తి local assistant‌తో మాట్లాడితే అది Ollama పని. ఒక application ఒక team‌కు సేవలందిస్తే అది vLLM పని.

రెండూ OpenAI-compatible HTTP API‌ను అందిస్తాయి. అందువల్ల base URL‌ను మార్చడం ద్వారా client code‌ను ఒకదాని నుంచి మరొకదానికి మార్చవచ్చు. తేడా APIలో లేదు. మొదటి request tokensను ఇంకా generate చేస్తుండగా రెండో request వచ్చినప్పుడు ఏమి జరుగుతుందనేదే తేడా.

Ollama అంటే ఏమిటి

Ollama ఒక సౌకర్య పొర. ఒకే ఇన్‌స్టాలేషన్ కమాండ్‌తో ఇది మీకు మోడల్ రిజిస్ట్రీ (ollama pull llama3.1:8b), వెయిట్ల స్థానిక స్టోర్, చాట్ ప్రాంప్ట్, systemd సేవ, మరియు HTTP API అందిస్తుంది. ఇది అందించే మోడళ్లు GGUF ఫైళ్లు. సాధారణంగా వీటిని 4-bit క్వాంటైజేషన్ చేస్తారు. అందుకే 7B లేదా 8B మోడల్ డిస్క్‌లో 16 GB బదులుగా సుమారు 5 GB స్థలాన్ని మాత్రమే ఉపయోగిస్తుంది. CPU ఇన్ఫరెన్స్ సాధ్యమవడానికి క్వాంటైజేషన్ ప్రధాన కారణం.

దీని రన్నర్ llama.cpp పై ఆధారపడి ఉంటుంది. సాధారణ హార్డ్‌వేర్‌పై GGUF క్వాంటైజేషన్‌ను ఆచరణాత్మకం చేసిన C++ ఇన్ఫరెన్స్ లైబ్రరీ llama.cpp. అప్పటి నుంచి కొన్ని కొత్త మోడల్ కుటుంబాల కోసం Ollama తన స్వంత ఇంజిన్‌ను కూడా జోడించింది. అయినప్పటికీ, ఇది అందించే చాలా అంశాల వెనుక ఇప్పటికీ llama.cpp ప్రాథమిక పొరగా ఉంది. కాబట్టి Ollama మరియు llama.cppలను పోల్చినప్పుడు, వాస్తవానికి సౌకర్య పొరను అది చుట్టుముట్టే సాఫ్ట్‌వేర్‌తోనే ఎక్కువగా పోలుస్తున్నారు.

ఈ రూపకల్పన ఒక వినియోగదారును లక్ష్యంగా చేసుకుంది. July 2026 నాటికి OLLAMA_NUM_PARALLEL యొక్క డిఫాల్ట్ విలువ 1. అంటే ఒక మోడల్ ఒకేసారి ఒక అభ్యర్థనను మాత్రమే ప్రాసెస్ చేస్తుంది. మిగతా అభ్యర్థనలు డిఫాల్ట్‌గా 512 ఎంట్రీలను కలిగి ఉన్న క్యూ (OLLAMA_MAX_QUEUE)లో వేచి ఉంటాయి. మీరు parallel సెట్టింగ్‌ను పెంచవచ్చు. దాని వల్ల కలిగే వనరుల వ్యయాన్ని కింది విభాగం వివరిస్తుంది. మీరు ఇంతకు ముందు Ollamaను అమలు చేయకపోతే, VPSలో Ollamaను హోస్ట్ చేసి port 11434ను మూసి ఉంచడంతో ప్రారంభించండి. ఎందుకంటే APIలో ఎలాంటి authentication లేదు.

vLLM వాస్తవంగా ఏమిటి

vLLM అనేది inference server మాత్రమే. ఇది model libraryని నిర్వహించదు. ఇందులో chat prompt ఉండదు. అభ్యర్థన వచ్చిన సమయంలో ఇది మీ కోసం modelను download చేయదు. ప్రారంభ సమయంలో మీరు Hugging Face repositoryని పేర్కొంటారు. ఇది ఆ ఒక్క modelను load చేసి, processను ఆపే వరకు అందిస్తుంది.

ఈ పరిమితి వల్ల మీకు లభించేది throughput. దీన్ని రెండు విధానాలు నిర్వహిస్తాయి. PagedAttention KV cacheను (key-value cache; ప్రతి active request కోసం model నిర్వహించే ప్రతి-token attention state) fixed-size blocksలో నిల్వ చేస్తుంది. ఇది operating system memoryని pagesగా నిర్వహించే విధానాన్ని పోలి ఉంటుంది. ఇక requestకు worst-case పరిమాణంతో కూడిన ఒక పెద్ద contiguous reservation అవసరం ఉండదు. అందువల్ల ఇంతకుముందు reserve చేసి ఉపయోగించకుండా ఉన్న memory, మరిన్ని concurrent requestsకు అందుబాటులోకి వస్తుంది. Continuous batching వల్ల కొత్త request, ప్రస్తుత batch పూర్తయ్యే వరకు వేచి ఉండకుండా, తదుపరి decoding stepలో running batchలో చేరుతుంది. ఒక sequence పూర్తయిన వెంటనే అది batch నుంచి తొలగిపోతుంది. దాని slotను మరో requestతో నింపుతారు.

ఆచరణలో ఫలితం ఇలా ఉంటుంది: ఒకే GPUలో concurrent users సంఖ్యను 1 నుంచి 30కు పెంచితే, మొత్తం tokens per second గణనీయంగా పెరుగుతుంది. అదే సమయంలో ప్రతి user వేగం మీరు ఊహించినంతగా తగ్గదు. Ollama defaultలో users సంఖ్యను 1 నుంచి 30కు పెంచితే, 29 మంది వేచి ఉండాల్సి వస్తుంది.

నిరంతర బ్యాచింగ్‌నే మొత్తం తేడా

ఒకే హార్డ్‌వేర్‌పై ప్రతి server‌కు ఒకే సమయంలో ఐదు requests వస్తున్నాయని ఊహించండి.

Ollama default settings‌తో request one పూర్తయ్యే వరకు దాన్ని నడిపి, తర్వాత request twoను, అలాగే కొనసాగిస్తుంది. ఐదవ caller నాలుగు పూర్తి generations కోసం వేచి ఉండాలి. మొత్తం throughput సుమారుగా ఒక generation వేగంతోనే ఉంటుంది. Processor ఒకేసారి ఒక sequence‌పైనే పనిచేస్తుంది.

vLLM ఐదు sequences‌నూ అదే forward pass‌లో decode చేస్తుంది. ఐదు sequences‌కు ఒక token‌ను generate చేయడానికి అయ్యే ఖర్చు, ఒక sequence‌కు ఒక token‌ను generate చేయడంకంటే కొద్దిగా మాత్రమే ఎక్కువ. దీనికి కారణం ఖరీదైన పని model weights‌ను memory నుంచి చదవడం, మరియు ఆ read మొత్తం batch‌కు భాగస్వామ్యం అవుతుంది. CPU inference‌ను నెమ్మదిగా చేసే అదే memory-bandwidth వాస్తవం ఇది. Arithmetic కోసం కాకుండా weights‌ను తరలించడం కోసం మీరు ఖర్చు చేస్తారు.

మీరు OLLAMA_NUM_PARALLEL=4 సెట్ చేసి ఈ ప్రయోజనంలో కొంత పొందవచ్చు. దీనికి memory ఖర్చవుతుంది. ప్రతి parallel slot‌కు దాని స్వంత KV cache అవసరం. Ollama context window‌ను slots మధ్య విభజిస్తుంది. అందువల్ల 8192 tokens‌కు configure చేసిన model‌పై నాలుగు parallel requests నడిపితే, ప్రతి request‌కు 2048 tokens context మాత్రమే మిగులుతుంది. vLLM యొక్క paged cache ఈ trade-off‌ను నివారిస్తుంది. Request వాస్తవంగా పెరుగుతున్న కొద్దీ blocks‌ను request‌కు కేటాయించడమే దీనికి కారణం.

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

ఇన్‌స్టాల్ స్క్రిప్ట్ ఒక ollama system userను సృష్టిస్తుంది, binaryని ఇన్‌స్టాల్ చేస్తుంది, అలాగే 127.0.0.1:11434కు bind చేసిన ollama.serviceను నమోదు చేస్తుంది. --verbose ముద్రించే eval rate line ఆ సిస్టమ్‌లోని వాస్తవ tokens per second విలువ. ప్రచురించిన ఏ విలువకన్నా దీనినే నమ్మండి.

Concurrency పెంచడానికి systemd drop-inను ఉపయోగించండి. అప్‌గ్రేడ్ సమయంలో ఈ మార్పు overwrite కాకుండా ఇది సహాయపడుతుంది:

sudo systemctl edit ollama.service

[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_KEEP_ALIVE=30m"

sudo systemctl restart ollama
ollama ps

ollama ps లో ప్రస్తుతం loadedగా ఉన్నది కనిపిస్తుంది. దాని PROCESSOR column వాస్తవాన్ని తెలియజేస్తుంది. 100% CPU అంటే GPU ఉపయోగించబడటం లేదు. Ollama slowగా ఉందని వచ్చిన చాలా నివేదికలకు ఇదే సరైన వివరణ.

vLLMతో ఇన్‌స్టాల్ చేసి సర్వ్ చేయడం

vLLMకు Linux మరియు Python 3.10 నుంచి 3.13 వరకు అవసరం. దీన్ని ప్రత్యేక virtual environmentలో ఇన్‌స్టాల్ చేయండి, ఎందుకంటే ఇది నిర్దిష్ట PyTorch buildను ఇన్‌స్టాల్ చేస్తుంది:

uv venv --python 3.12 --seed
source .venv/bin/activate
uv pip install vllm --torch-backend=auto

తర్వాత ఒక modelను సర్వ్ చేయండి. ఇక్కడి పేరు short tag కాదు; ఇది Hugging Face repository id:

vllm serve Qwen/Qwen2.5-1.5B-Instruct

మొదటిసారి startup నెమ్మదిగా ఉంటుంది. ముందుగా weightsను download చేసి, ఆ తర్వాత ఎన్ని KV cache blocks సరిపోతాయో నిర్ణయించడానికి GPUను profile చేస్తుంది. ఇది port 8000పై listening చేస్తుంది. Client code రాయడానికి ముందు దీన్ని తనిఖీ చేయండి:

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?"}]}'

ఆ machineలో Docker ఇప్పటికే ఉంటే, official imageను ఉపయోగించడం ద్వారా CUDA dependency పనిని తప్పించుకోవచ్చు:

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 అవసరం; ఇది అలంకార flag కాదు. PyTorch processes మధ్య tensorsను shared memory ద్వారా పంపుతుంది. Tensor-parallel inferenceకు default Docker shared-memory allocation చాలా తక్కువగా ఉంటుంది.

Productionలో అత్యంత ముఖ్యమైన flags ఇవి: --max-model-len (మీరు వినియోగించడానికి సిద్ధంగా ఉన్న context window), --gpu-memory-utilization (vLLM ఉపయోగించగల GPU card సామర్థ్యంలోని fraction; July 2026 నాటికి defaultగా 0.92), ఒక modelను అనేక GPUsపై విభజించడానికి --tensor-parallel-size, అలాగే --api-key.

vLLMలో ప్రామాణీకరణ ఒక flagతో ఉంటుంది, Ollamaలో ఉండదు

మీరు bearer token ఇస్తే vLLM దాన్ని తప్పనిసరిగా తనిఖీ చేస్తుంది:

vllm serve Qwen/Qwen2.5-1.5B-Instruct --api-key token-abc123

అదే విలువను VLLM_API_KEY environment variable నుంచి కూడా పొందవచ్చు. ఈ token లేకుండా పంపిన requestకు HTTP 401 వస్తుంది. అయినప్పటికీ port 8000ను public interfaceపై అందుబాటులో ఉంచడానికి ఇది కారణం కాదు. vLLMలో rate limiting లేదు. సాధారణ HTTPలో పంపే tokenను మార్గమధ్య network trafficలో చదవవచ్చు. అయితే serverకు request పంపుతున్న caller అనే భావన vLLMలో ఉంది.

Ollamaలో అలాంటిదేమీ లేదు. key లేదు, login లేదు, allow-list లేదు. 11434ను చేరుకోగల ఏ process అయినా modelsను run చేయగలదు, pull చేయగలదు లేదా delete చేయగలదు. దాన్ని loopbackపై మాత్రమే ఉంచి, మీరు స్వయంగా నిర్వహించే WireGuard VPN ద్వారా చేరుకోండి. లేదా TLS (transport layer security)ను ముగించే authenticating reverse proxy ద్వారా చేరుకోండి.

హార్డ్‌వేర్: ప్రతిదానికి అవసరమైనవి

Ollama CPUపై పనిచేస్తుంది. 4-bit quantized modelకు ప్రతి billion parametersకు సుమారు అర gigabyte RAM అవసరం. దీనికి runtime overheadగా సుమారు 1 gigabyte, context కోసం అదనపు మెమరీ కూడా అవసరం. అందువల్ల 3B modelకు సుమారు 4 GB ఖాళీ మెమరీ, 8B modelకు సుమారు 8 GB అవసరం. Shared vCPUపై వేగం సెకనుకు single digit నుంచి తక్కువ double digit tokens వరకు ఉంటుంది. ఇది memory bandwidth పరిమితి. Misconfiguration కాదు. ఏ flagతోనూ దీన్ని సరిచేయలేరు.

vLLM GPU ఉందని ఊహిస్తుంది. దీని default path unquantized weightsను 16-bit precisionతో అందిస్తుంది. దీనికి ప్రతి billion parametersకు సుమారు 2 GB అవసరం. అందువల్ల 8B modelకు weightsకే సుమారు 16 GB video memory అవసరం. మీరు vLLMను అమలు చేయడానికి ఎంచుకున్న concurrency కోసం అవసరమైన KV cache దీనికి అదనం. 24 GB cardలో cacheకు ఉపయోగించగల స్థలం మిగులుతుంది. 16 GB cardలో అది సరిపోదు. కాబట్టి చిన్న modelను ఎంచుకోవాలి లేదా quantized checkpointతో --quantization అందించాలి. CPU backend ఉంది. కానీ standard wheels దాని కోసం build చేయబడలేదు. అంతేకాక, vLLMను అమలు చేయడానికి ఉన్న ప్రధాన కారణాన్నే అది తొలగిస్తుంది.

కాబట్టి hardware ప్రశ్నకు ఇచ్చే సమాధానం చాలా సందర్భాల్లో software ప్రశ్నకు కూడా సమాధానం ఇస్తుంది. GPU లేకపోతే Ollamaను ఉపయోగించండి. Requests serialise అవుతున్నందుకు అద్దెకు తీసుకున్న GPU 5 percent utilisation వద్ద ఉంటే vLLMను ఉపయోగించండి.

మీ workload కోసం ఏది

• ఒక వ్యక్తి, CPU VPS, ముసాయిదా తయారీ మరియు సారాంశ రచన: Ollama. వేగం ఆమోదయోగ్యంగా ఉంటుంది. మరేదీ ఇంత సరళంగా ఉండదు.
• కోడింగ్ సహాయకం లేదా మీ tools‌ను local model‌కు అనుసంధానించే MCP server, దాన్ని మీరు మాత్రమే ఉపయోగిస్తే: Ollama. ఒకేసారి ఒక అభ్యర్థనే వాస్తవ workload.
• ఈ వారం ఐదు models‌ను పోల్చితే: Ollama. tag చేసిన models‌ను pull చేసి delete చేయడం దాని ప్రధాన బలం. vLLMలో ప్రతి model‌కు process restart అవసరం.
• వాస్తవ users ఉన్న internal app, chat product లేదా retrieval pipeline: vLLM. ఇక్కడ batching వల్ల GPU ఖర్చు సమర్థవంతంగా ఉపయోగపడుతుంది.
• రాత్రివేళ లక్ష documents‌కు scoring చేసే batch job: అధిక --max-num-seqsతో vLLM. ముఖ్యమైన ఏకైక ప్రమాణం throughput. ప్రతి document‌కు latency ముఖ్యం కాదు.
• ఒకేసారి పలువురు self-hosted AI agents model‌ను ఉపయోగించే agent platform: vLLM. Agent traffic అకస్మాత్తుగా పెరుగుతుంది. దాని స్వభావం parallel‌గా ఉంటుంది.

వైఫల్య పరిస్థితులు, మీరు చూసే సందేశాలతో

vLLM KV cache లోపంతో ప్రారంభం కావడానికి నిరాకరిస్తుంది. సందేశంలో రెండు సంఖ్యలు ఉంటాయి:

ValueError: The model's max seq len (32768) is larger than the maximum number of tokens that can be stored in KV cache (8192). Try increasing gpu_memory_utilization or decreasing max_model_len when initializing the engine.

weights లోడ్ చేసిన తర్వాత మిగిలిన memory కంటే model ప్రకటించే context window పెద్దదిగా ఉంది. --max-model-len 8192 తో దాన్ని తగ్గించండి. card ను మరే ఇతర ప్రక్రియ ఉపయోగించకపోతే --gpu-memory-utilization ను పెంచండి. utilisation ను సుమారు 0.95 కంటే ఎక్కువగా పెంచితే, startup లోపం బదులుగా తరువాత load సమయంలో CUDA out-of-memory crash వచ్చే అవకాశం ఉంటుంది. ఈ రెండింటిలో అదే తీవ్రమైనది.

Ollama generation మధ్యలో Killed ను ముద్రిస్తుంది. model కు system లో ఉన్న RAM కంటే ఎక్కువ RAM అవసరమైనందున Linux out-of-memory killer ఆ process ను ఆపింది. sudo dmesg | grep -i oom తో నిర్ధారించండి. పరిష్కారం చిన్నది లేదా ఎక్కువగా quantized చేసిన model ను ఉపయోగించడం. ఇది setting తో పరిష్కరించబడదు.

Ollama ఒంటరిగా సరిగ్గా సమాధానమిస్తుంది, కానీ load సమయంలో నిలిచిపోతుంది. ఎక్కడా error కనిపించదు. callers సంఖ్య పెరిగేకొద్దీ requests ఎక్కువ సమయం తీసుకుంటాయి, ఎందుకంటే OLLAMA_NUM_PARALLEL=1 వాటిని serialise చేస్తుంది. దీన్ని పెంచి, ప్రతి request కు లభించే చిన్న context ను అంగీకరించండి. లేదా workload ను vLLM కు తరలించండి.

vLLM ప్రతి call కు 401 ను తిరిగి ఇస్తుంది. మీరు దీన్ని --api-key తో ప్రారంభించారు, కానీ client Authorization header ను పంపడం లేదు. చాలా OpenAI client libraries key గా మీరు పంపిన విలువనే పంపిస్తాయి. అందువల్ల flag ను తొలగించకుండా, ఆ విలువను client లో సెట్ చేయండి.

vLLM model కనుగొనబడలేదని చెబుతుంది. Ollama అవసరమైనప్పుడు model ను pull చేస్తుంది. vLLM అలా చేయదు. request body లోని model field, మీరు ప్రారంభించిన repository id తో సరిపోవాలి. లేదా మీరు --served-model-name సెట్ చేసి ఉంటే, దాని విలువతో సరిపోవాలి. curl http://localhost:8000/v1/models తో ఖచ్చితమైన string ను నిర్ధారించండి.

రెండింటినీ అమలు చేయడం సముచితమైన పరిష్కారం

ఇవి పరస్పర విరుద్ధ ఎంపికలు కావు. సాధారణ నిర్మాణంలో, అప్లికేషన్‌కు సేవలందించడానికి GPU instanceలో vLLM అమలవుతుంది. దాని పక్కన ఉన్న సాధారణ VPSలో స్థానిక scripts, cron jobs, కొత్త model releasesను పరీక్షించడం కోసం Ollama అమలవుతుంది. రెండు endpoints కూడా OpenAI-compatibleగా ఉంటాయి. అందువల్ల ఒకే client libraryతో, base URLను మార్చడం ద్వారా రెండింటినీ ఉపయోగించవచ్చు. ఇక్కడ ఇంజిన్ ఎంపిక కంటే ఖర్చు నియంత్రణకు ఎక్కువ ప్రాధాన్యం ఉంటుంది. కారణం, idle GPUకి మరియు busy GPUకి ఒకే విధంగా billing జరుగుతుంది. అలాగే agent మరియు inference ఖర్చులను ఊహించగలిగేలా ఉంచడం అనేది serverను ఎంచుకోవడం నుండి వేరైన ప్రత్యేక విధానం.

FAQ

Ollama కంటే vLLM వేగంగా ఉంటుందా?

అదే GPUపై ఒక అభ్యర్థనకు వేగంలో తేడా తక్కువగా ఉంటుంది. కారణం, రెండూ ఒకే గణనను నిర్వహిస్తాయి. ఒకేసారి అనేక అభ్యర్థనలు వచ్చినప్పుడు vLLM చాలా వేగంగా ఉంటుంది. continuous batching ప్రతి క్రియాశీల క్రమాన్ని ఒకే forward passలో decode చేస్తుంది. Ollama యొక్క డిఫాల్ట్ విధానం వాటిని ఒక్కొక్కటిగా అమలు చేస్తుంది. CPU మాత్రమే ఉన్న యంత్రంలో ఈ ప్రశ్న వర్తించదు. Ollama అక్కడ పనిచేస్తుంది. vLLM ఆచరణాత్మకంగా పనిచేయదు.

vLLM GPU లేకుండా పనిచేయగలదా?

ఆచరణాత్మకంగా కాదు. సాధారణ wheels NVIDIA లేదా AMD GPUs కోసం రూపొందించబడ్డాయి. batch చేసిన అభ్యర్థనలతో acceleratorను నిరంతరం ఉపయోగించడమే vLLM ఉద్దేశం. CPUపై అది సాధ్యం కాదు. అభివృద్ధి పనుల కోసం CPU backend ఉంది. నిజమైన CPU inference కోసం Ollama లేదా llama.cppను నేరుగా ఉపయోగించండి.

Ollama మరియు llama.cpp మధ్య తేడా ఏమిటి?

llama.cpp inference library. GGUF దాని quantized weight format. Ollama యొక్క runner llama.cppపై నిర్మించబడింది. llama.cppలో మీరు స్వయంగా నిర్వహించాల్సిన భాగాలను ఇది జోడిస్తుంది: model registry, automatic download, resident server, systemd unit మరియు OpenAI-compatible endpoint. కొన్ని కొత్త model families కోసం Ollama తన స్వంత engineను జోడించింది. అందువల్ల అంతర్గతంగా ఈ రెండూ ఇక ఒకేలా లేవు.

8B model కోసం vLLMకు ఎంత GPU memory అవసరం?

16-bit precisionలో weightsకే సుమారు 16 GB అవసరం. ఇది ప్రతి billion parametersకు సుమారు 2 GB. దీనికి అదనంగా KV cache కోసం కూడా స్థలం అవసరం. 24 GB card సౌకర్యవంతంగా ఉంటుంది. 16 GB card కోసం quantized checkpoint లేదా చిన్న model అవసరం. vLLM cardలో --gpu-memory-utilization ద్వారా నిర్ణయించబడిన కొంత భాగాన్ని ఉపయోగిస్తుంది. July 2026 నాటికి దీని default విలువ 0.92.

వీటి మధ్య మారడానికి నా application codeను మార్చాలా?

సాధారణంగా base URL, API key మరియు model name మాత్రమే మార్చాలి. Ollama తన OpenAI-compatible surfaceను http://127.0.0.1:11434/v1 వద్ద అందిస్తుంది. ఇది keyను పట్టించుకోదు. vLLM http://localhost:8000/v1ను అందిస్తుంది. మీరు keyను సెట్ చేస్తే అది దాన్ని అమలు చేస్తుంది. Model names రూపంలో భిన్నంగా ఉంటాయి: Ollama కోసం llama3.1:8b, vLLM కోసం Qwen/Qwen2.5-1.5B-Instruct వంటి పూర్తి repository id.