Wéi e VPS fir eng KI: API oder Modell um Server

Zwee Besoinen, zwou Servergréissten

Déi meescht Applikatiounen, déi „KI benotzen“ (Assistenten, Agenten, Resuméen, Extraktioun vun Donnéeën, Sich an Dokumenter), ruffen e Modell op, deen säin Editeur iwwer eng API host. De Calcul geschitt bei him; Äre Server preparéiert d’Ufro, waart op d’Äntwert a veraarbecht se. Hie gëtt dann wéi all aner Webapplikatioun dimensionéiert: no senger Sprooch, senger Datebank an der Zuel vu gläichzäitege Benotzer.

Deen anere Fall ass de Modell, deen um Server selwer leeft, mat Ollama, llama.cpp oder enger Python-Bibliothéik. D’Grënn si bekannt: Donnéeën, déi op Ärer Infrastruktur bleiwen, fix Käschten, egal wéivill Ufroen et ginn, eng Hannergrondveraarbechtung vu grousse Volumen, e spezialiséierte Modell. Do muss de ganze Modell an de Späicher passen, an hien ass et, deen d’Gréisst festleet.

Iwwer eng API: d’Applikatioun dimensionéieren, net de Modell

Eng Ufro un e Modell iwwer eng API dauert tëscht enger Sekonn an enger Minutt, virun allem wann d’Äntwert no an no geliwwert gëtt (streaming). An där Zäit rechent Äre Server bal näischt: e waart. Wat zielt, ass seng Fäegkeet, vill Ufroen am Waarden ze halen, ouni déi aner ze blockéieren:

• En asynchrone Server: Node.js, FastAPI mat Uvicorn, oder asynchron Gunicorn-Worker. E synchrone Worker, deen 20 Sekonnen op eng Äntwert waart, ass e Worker, dee fir all aner Besicher blockéiert ass.
• Eng Job-Queue fir laang Veraarbechtungen (Resumé vun engem Dokument, Analyse vun enger Serie Dokumenter): d’Ufro vum Besicher gëtt direkt zeréck, an e Worker schafft am Hannergrond.
• Timeouts, déi um Proxy agestallt sinn: Nginx schneit standardméisseg eng Äntwert of, déi méi wéi 60 Sekonne stomm bleift (proxy_read_timeout).

De Späicher, deen Dir virgesitt, ass dee vun der Applikatioun an hirer Datebank: 4 GB decken eng Python- oder Node.js-Applikatioun mat PostgreSQL beim Start of. Eng üblech Konfiguratioun, eng Next.js-Interface, eng FastAPI-API an eng PostgreSQL-Datebank, déi e Modell iwwer eng API opruffen, passt a 6 bis 8 GB, d’Kompilatioun vun der Interface abegraff.

Embeddings a Vektorsich: de Späicher vun de Vektoren

Eng Applikatioun, déi an Ären Dokumenter sicht (RAG, retrieval-augmented generation), mécht aus all Passage e Vektor, a fënnt dann déi, déi enger Fro am nooste sinn. Zwee Posten, déi Dir dimensionéiere musst:

• De Modell fir d’Embeddings, wann e bei Iech leeft: déi gängeg Modeller weien 100 MB bis 1,5 GB a rechnen ouni Problem um Prozessor. all-MiniLM-L6-v2 zum Beispill brauch manner wéi 100 MB.
• D’Vektoren: mat pgvector brauch e Vektor 4 Bytes pro Dimensioun, plus 8. Eng Millioun Passagen mat 1.536 Dimensioune maachen ongeféier 6 GB Donnéeën, an dozou kënnt den HNSW-Index, deen d’Sich méi séier mécht. Fir séier Siche mussen den Index an d’Vektoren, déi ofgefrot ginn, an de Späicher passen.

Den Typ halfvec vu pgvector späichert all Dimensioun op 2 Bytes amplaz vu 4: den halwe Späicher, fir eng Sichqualitéit, déi ganz no bleift.

E Modell um Server: als éischt de Späicher

E Sproochmodell ass e Fichier mat Gewiichter, dee ganz an de Späicher geluede gëtt, fir ze äntweren. Seng Gréisst hänkt vun der Zuel vun de Parameteren an der Quantiséierung of, der Präzisioun, mat där all Gewiicht gespäichert ass. GGUF, de Format vu llama.cpp an Ollama, bitt Quantiséierunge vun 2 bis 16 Bit un; d’Variant Q4_K_M, ëm 4 Bit, ass de gängege Kompromëss tëscht Gréisst a Qualitéit.

Zu dësem Gewiicht kommen zwee Posten derbäi:

• De Kontext (de KV-Cache): all Token vum aktuelle Gespréich hëlt Späicher. Fir Llama 3.1 8B rechent mat ongeféier 128 KB pro Token bei 16-Bit-Präzisioun, also 1 GB fir e Kontext vun 8.000 Tokens, an esou vill pro Gespréich, dat parallel veraarbecht gëtt.
• De Rescht vum Server: System, Applikatioun, Datebank, wéi bei all Webapplikatioun.

Beispill. Llama 3.1 8B a 4 Bit, zwee gläichzäiteg Gespréicher vun 8.000 Tokens an eng kleng Applikatioun: 5 GB fir de Modell, 2 GB fir de Kontext, 2 GB fir d’Applikatioun an de System, also 9 GB, an ongeféier 12 GB mat 25 % Marge.

Um Prozessor: wat d’Vitesse bestëmmt

Fir all Token ze produzéieren, liest de Modell all seng Gewiichter nach eng Kéier am Späicher. Um Prozessor gëtt d’Vitesse vun der Generatioun also méi vun der Bandbreet vum Späicher begrenzt wéi vun der Zuel vun de Kären: e Modell vu 5 GB, op enger Maschinn, déi 25 GB pro Sekonn liest, kënnt op héchstens ongeféier 5 Tokens pro Sekonn, nach ier de Calcul zielt.

Zwou Phasen ënnerscheede sech:

• D’Liese vun der Fro (prompt processing) ass e rechenintensive Prozess: méi vCPU maache se méi séier, wat bei laangen Dokumenter zielt.
• D’Generatioun vun der Äntwert hänkt virun allem vun der Bandbreet vum Späicher an der Gréisst vum Modell of: e Modell, deen hallef sou grouss ass, äntwert ongeféier duebel sou séier.

An der Praxis produzéiert e Modell mat 7 bis 8 Milliarde Parameteren, a 4 Bit quantiséiert, op e puer vCPU e puer Tokens pro Sekonn. Dat ass komfortabel fir eng Hannergrondveraarbechtung (E-Maile klasséieren, Felder aus engem Dokument extrahéieren, an der Nuecht resuméieren, wat am Dag ukomm ass) a fir en internen Assistent. Interaktiv Notzungen a groussem Moossstab, an déi ganz grouss Modeller (32 Milliarde Parameteren a méi), lafen op enger Grafikkaart (GPU).

D’Miessung entscheet: llama-bench, deen zu llama.cpp gehéiert, weist d’Vitesse vun deenen zwou Phasen op Ärem Server, fir Äre Modell.

llama-bench -m modell-Q4_K_M.gguf -p 512 -n 128

Den Disk: d’Modeller, hir Versiounen, d’Vektoren

E Modell brauch um Disk ongeféier esou vill Plaz wéi am Späicher: 5 GB fir e Modell mat 8 Milliarde Parameteren a 4 Bit. Rechent mat Plaz fir zwee oder dräi Modeller oder Versiounen, d’Vektorindexen, d’Quelldokumenter an d’Datebank. En NVMe-Disk luet e Modell an e puer Sekonnen, wann de Service start, wat bei all Neistart zielt.

Gréisstenuerdnung: 50 GB fir eng Applikatioun, déi e Modell iwwer eng API oprifft, 80 bis 120 GB, soubal e Modell a seng Dokumenter um Server liewen.

Sécher ariichten

Mat Ollama leeft alles no zwee Befeeler:

curl -fsSL https://ollama.com/install.sh | sh
ollama run llama3.1:8b

Ollama lauschtert standardméisseg op 127.0.0.1:11434, dat heescht nëmme vum Server selwer aus. Behaalt dës Astellung: seng API verlaangt keng Authentifikatioun, an eng Instanz, déi um Internet op ass, déngt jidderengem, mat Äre Ressourcen. Är Applikatioun, um selwechte Server, schwätzt lokal mat him; wann en anere Server en ofroe muss, gitt iwwer e Proxy, deen d’Ufroen authentifizéiert, oder iwwer e privat Netzwierk.

Stellt duerno d’Gréisst vum Kontext (num_ctx) op dat an, wat Är Ufroe brauchen: si ass et, déi de benotzte Späicher wuesse léisst, Gespréich fir Gespréich.