ઓપન-વેઇટ લાર્જ લેંગ્વેજ મોડલ્સ (Open-weight large language models) એ એન્જિનિયરિંગ ટીમો AI ઇન્ફ્રાસ્ટ્રક્ચર વિશે કેવી રીતે વિચારે છે તે બદલી નાખ્યું છે. ક્લોઝ્ડ APIs થી વિપરીત, જ્યાં પ્રોવાઈડર હાર્ડવેર, મોડલ વેઇટ્સ અને રિલીઝ શેડ્યૂલ પર નિયંત્રણ રાખે છે, ત્યાં ઓપન-વેઇટ મોડલ્સ તે નિર્ણયો તમને પાછા સોંપે છે. તમે નક્કી કરો છો કે મોડલ ક્યાં રહેશે, તેને કેવી રીતે ટ્યુન કરવામાં આવશે, અને ક્યારે—જો ક્યારેય—તમે નવા ચેકપોઇન્ટ પર અપડેટ કરશો. માલિકીનું આ સ્તર શક્તિશાળી છે, પરંતુ તેનો અર્થ એ પણ છે કે ઇન્ટિગ્રેશનનું કામ સીધું તમારા ખભા પર આવે છે.

જો તમે OpenAI ના GPT-4 અથવા Anthropic ના Claude જેવા મેનેજ્ડ API માંથી આવતા હોવ, તો સારા સમાચાર એ છે કે ઘણા ઓપન-વેઇટ હોસ્ટિંગ પ્રોવાઈડર્સ અને ઇન્ફરન્સ એન્જિન્સ હવે એક જ ભાષા બોલે છે: HTTP POST, JSON પેલોડ્સ અને બેરર ટોકન ઓથેન્ટિકેશન (bearer token authentication). મિકેનિક્સ પરિચિત લાગે છે, પરંતુ વિગતો વધુ મહત્વની છે કારણ કે તમે, પ્રોવાઈડર નહીં, વિશ્વસનીયતા, ખર્ચ નિયંત્રણ અને બિહેવિયર શેપિંગ માટે જવાબદાર છો.

API કોલના પાયાના નિયમો

તેના મૂળમાં, ઇન્ટિગ્રેશન એ એક POST રિક્વેસ્ટ છે. તમે Authorization હેડરમાં સ્ટાન્ડર્ડ બેરર ટોકન સાથે ઓથેન્ટિકેટ કરો છો. બોડી એક JSON ઓબ્જેક્ટ છે, અને તેનું સૌથી મહત્વનું ફિલ્ડ messages એરે છે. તે એરે પરિચિત ચેટ ફોર્મેટને અનુસરે છે: સિસ્ટમ, યુઝર અને આસિસ્ટન્ટ રોલ્સનું વૈકલ્પિક ક્રમ.

અહીં વ્યવહારમાં એક ન્યૂનતમ રિક્વેસ્ટ સ્ટ્રક્ચર કેવું દેખાય છે:

  • Authorization હેડરને Bearer <your-token> પર સેટ કરો.
  • ઓછામાં ઓછો model આઈડેન્ટિફાયર અને messages લિસ્ટ ધરાવતો JSON પેલોડ મોકલો.
  • જો તમે ડિટરમિનિસ્ટિક અથવા ક્રિએટિવ કંટ્રોલ ઈચ્છતા હોવ તો max_tokens અને temperature શામેલ કરો.

રિસ્પોન્સ choices એરે અને usage ઓબ્જેક્ટ સાથે પાછો આવે છે. તે usage બ્લોકને અવગણશો નહીં. તેમાં prompt_tokens, completion_tokens અને ટોટલ (કુલ) હોય છે. જો તમે સેલ્ફ-હોસ્ટિંગ કરી રહ્યા હોવ, તો આ તમારા માટે સંકેત છે કે કોઈ ચોક્કસ યુઝર ઇન્ટરેક્શન મોંઘું છે કે નહીં. જો તમે થર્ડ-પાર્ટી ઇન્ફરન્સ પ્રોવાઈડરને ચૂકવણી કરી રહ્યા હોવ, તો આ તમારો બિલિંગ ડેટા છે. ગમે તે હોય, પહેલા દિવસથી જ તેને લોગ કરો.

સ્ટ્રીમિંગ અને તમારે તેનો ઉપયોગ શા માટે કરવો જોઈએ

ટેક્સ્ટનો એક ટુકડો દેખાય તે પહેલાં ત્રણ સેકન્ડ સુધી લોડિંગ સ્પિનરને જોવાનું કોઈને પસંદ નથી. સ્ટ્રીમિંગ તેને ઠીક કરે છે. મોડલને આખી કમ્પ્લીશન પૂરી કરવા માટે રાહ જોવાને બદલે, સર્વર જેમ જેમ ટોકન્સ જનરેટ થાય તેમ તેમ તેને એમિટ (emit) કરે છે. તમારો ક્લાયન્ટ Server-Sent Events અથવા ચંક્ડ (chunked) HTTP રિસ્પોન્સ મેળવે છે અને શબ્દો આવે તેવા જ તેને રેન્ડર કરી શકે છે.

તમારા JSON પેલોડમાં stream: true ફ્લેગ સેટ કરીને સ્ટ્રીમિંગ સક્ષમ કરો. ક્લાયન્ટ સાઇડ પર, તમે સામાન્ય રીતે સ્ટ્રીમને લાઇન બાય લાઇન પાર્સ કરશો, data: પ્રીફિક્સ પર નજર રાખીને. જો કનેક્શન સ્ટ્રીમની વચ્ચે તૂટી જાય, તો ફરીથી કનેક્ટ થવા અથવા નોન-સ્ટ્રીમિંગ રીટ્રાય (non-streaming retry) પર જવા માટે તૈયાર રહો. તમારા ચેટ એપની અનુભવવામાં આવતી લેટન્સી (perceived latency) નોંધપાત્ર રીતે ઘટી જાય છે, અને વપરાશકર્તાઓને લાગે છે કે સિસ્ટમ તેમની સાથે વિચારી રહી છે, નહીં કે તેમની રિક્વેસ્ટને બેચ-પ્રોસેસ કરી રહી છે.

વાસ્તવિક વર્કફ્લો માટે ફંક્શન કોલિંગ

જે મોડલ ફક્ત સાદા ટેક્સ્ટ પરત કરે છે તે ઉપયોગી છે, પરંતુ જે મોડલ ટૂલ્સનો ઉપયોગ કરી શકે છે તે ઘણું વધારે ઉપયોગી છે. ફંક્શન કોલિંગ તમને ઉપલબ્ધ કામગીરીઓનું વર્ણન કરતી JSON સ્કીમા (JSON schema) વ્યાખ્યાયિત કરવા દે છે—ધારો કે, search_orders અથવા update_profile—અને મોડલ નક્કી કરે છે કે તેનો ઉપયોગ ક્યારે કરવો. વપરાશકર્તાને ફોલો-અપ પ્રશ્ન પૂછવાને બદલે, તે વાતચીતમાંથી કાઢવામાં આવેલા આર્ગ્યુમેન્ટ્સ સાથે સ્ટ્રક્ચર્ડ ફંક્શન કોલ એમિટ કરે છે.

ઉદાહરણ તરીકે, જો કોઈ વપરાશકર્તા પૂછે છે, “મારો છેલ્લો ઓર્ડર શું હતો?”, તો તમારી સ્કીમા limit પેરામીટર સાથે get_recent_orders ફંક્શન વ્યાખ્યાયિત કરી શકે છે. મોડલ એક ટૂલ કોલ પરત કરે છે, તમારું બેકએન્ડ તમારા ડેટાબેઝ સામે ક્વેરી ચલાવે છે, અને તમે પરિણામને ફંક્શન રિસ્પોન્સ મેસેજ તરીકે મોડલમાં પાછું મોકલો છો. મોડલ પછી કુદરતી ભાષામાં જવાબ તૈયાર કરે છે.

આ અમલમાં લાવવા માટે:

  • તમારા પેલોડમાં tools અથવા functions એરે સપ્લાય કરો.
  • દરેક ટૂલને name, description, અને parameters સ્કીમા સાથે વ્યાખ્યાયિત કરો.
  • ટૂલ-કોલ્સ ફિનિશ રીઝન અથવા સમાન સંકેત માટે રિસ્પોન્સનું નિરીક્ષણ કરો.
  • તમારા બેકએન્ડમાં કડક વેલિડેશન સાથે ફંક્શન ચલાવો. ક્યારેય કાચા (raw) મોડલ આઉટપુટ પર વિશ્વાસ ન કરો કે તે અનસેનિટાઇઝ્ડ (unsanitized) રીતે તમારા ડેટાબેઝ સુધી પહોંચે.
  • મેસેજ હિસ્ટ્રીમાં ફંક્શનનું પરિણામ ઉમેરો અને ફોલો-અપ રિક્વેસ્ટ મોકલો જેથી મોડલ અંતિમ જવાબ આપી શકે.

આ પેટર્ન જનરેટિવ ટેક્સ્ટ અને ડિટરમિનિસ્ટિક સિસ્ટમ્સ વચ્ચેના અંતરને ઘટાડે છે. તમારું AI દરેક બ્રાન્ચને હાર્ડ-કોડ કર્યા વિના કેલેન્ડર વાંચી શકે છે, API ક્વેરી કરી શકે છે અથવા વેબહૂક્સ (webhooks) ટ્રિગર કરી શકે છે.

પ્રોડક્શન માટે હાર્ડનિંગ

પ્રોડક્શનમાં ઓપન-વેઇટ મોડલ્સ ચલાવવાથી તમે કોઈપણ ડિસ્ટ્રિબ્યુટેડ સિસ્ટમ જેવી જ નિષ્ફળતાના મોડ્સ (failure modes) નો સામનો કરો છો, વત્તા કેટલાક અનન્ય ones પણ. મોડલ ઇન્ફરન્સ કમ્પ્યુટ-ઇન્ટેન્સિવ છે, અને એન્ડપોઇન્ટ્સ લોડ હેઠળ નબળા પડી શકે છે. તમારું એપ્લિકેશન સ્થિર રાખવા માટે અહીં કેટલીક રીતો છે.

એરર્સ અને રીટ્રાય્સ

  • 429 Too Many Requests: આ એક રેટ-લિમિટ (rate-limit) સંકેત છે. જિટર (jitter) સાથે એક્સપોનેન્શિયલ બેકઓફ (exponential backoff) લાગુ કરો. ટૂંકા વિલંબથી શરૂઆત કરો, વારંવાર 429 આવવા પર તેને બમણો કરો, અને તેને થોડી સેકન્ડો સુધી મર્યાદિત રાખો જેથી તમે સર્વર પર વધુ પડતો ભાર ન નાખો.
  • 5xx Server Errors: આ સામાન્ય રીતે ક્ષણિક (transient) હોય છે, ખાસ કરીને જો તમે GPU વર્કર્સના પુલ (pool) ને રૂટ કરી રહ્યા હોવ. તેને ફરીથી પ્રયાસ (retry) કરો, પરંતુ પ્રયાસોની સંખ્યા પર કડક મર્યાદા રાખો—ત્રણ એ સામાન્ય ડિફોલ્ટ છે.
  • 4xx Client Errors: આને આંધળું રિટ્રાય (retry) કરશો નહીં. 400 નો અર્થ છે કે તમારો પેલોડ (payload) ખોટી રીતે રચાયેલ છે, 401 નો અર્થ છે કે તમારું ટોકન ખોટું છે, અને 404 નો અર્થ છે કે તે એન્ડપોઈન્ટ પર મોડેલ ID અસ્તિત્વ ધરાવતું નથી. લૂપિંગ કરવાને બદલે રિક્વેસ્ટને સુધારો.

ટાઈમઆઉટ અને હેંગ થતી પ્રક્રિયાઓ (Timeouts and Hanging Processes)

જ્યારે ક્યુ (queues) ભરાઈ જાય અથવા જ્યારે વર્કર જનરેશન દરમિયાન ક્રેશ થાય ત્યારે ઇન્ફરન્સ (Inference) ધીમું પડી શકે છે. હંમેશા રિક્વેસ્ટ ટાઈમઆઉટ સેટ કરો. જો તમારા HTTP ક્લાયન્ટનું ડિફોલ્ટ ઇન્ફિનિટી (infinity) હોય, તો તેને બદલો. સ્ટાન્ડર્ડ કમ્પ્લીશન માટે 30 થી 60 સેકન્ડ એ વ્યાજબી શરૂઆતનું બિંદુ છે, હેલ્થ ચેક માટે તેનાથી ઓછું. જો ટાઈમઆઉટ થાય, તો તેને નિષ્ફળતા તરીકે ગણો, તેને લોગ કરો, અને નક્કી કરો કે વપરાશકર્તાને ગ્રેસફુલ એરર (graceful error) બતાવવી કે ફોલબેક મોડેલ (fallback model) પર રિટ્રાય કરવું.

બજેટ નિયંત્રણ (Budget Control)

ટોકન કાઉન્ટ સીધા જ પૈસા અથવા GPU કલાકોમાં રૂપાંતરિત થાય છે. દરેક રિક્વેસ્ટ માટે પ્રોમ્પ્ટ અને કમ્પ્લીશન બંને ટોકન્સ લોગ કરો. તેમને યુઝર દીઠ, ફીચર દીઠ અને મોડેલ વર્ઝન દીઠ ટ્રેક કરો. ઓપન-વેઇટ મોડેલ્સ તમને ચેકપોઈન્ટ્સ બદલવાની મંજૂરી આપે છે, પરંતુ દરેક ચેકપોઈન્ટની પોતાની ખર્ચ પ્રોફાઇલ અને કોન્ટેક્સ્ટ-વિન્ડો સાઈઝ હોય છે. લોગ્સ વગર, તમને ખબર નહીં પડે કે તમારા પ્રોડક્ટનો કયો ભાગ કમ્પ્યુટ પાવરનો વધુ ઉપયોગ કરી રહ્યો છે.

સિસ્ટમ મેસેજ દ્વારા બિહેવિયર શેપિંગ (Behavior Shaping with System Messages)

સિસ્ટમ મેસેજ એ તમારા નિયંત્રણની પ્રથમ લાઇન છે. તેનો ઉપયોગ ટોન સેટ કરવા, મર્યાદાઓ લાગુ કરવા અને સ્થિર કોન્ટેક્સ્ટ (static context) ઉમેરવા માટે કરો જે દરેક યુઝર કન્વર્સેશનનું પાલન કરવું જોઈએ. ઓપન-વેઇટ મોડેલ્સ તેમના ફાઇન-ટ્યુનિંગ અને સિસ્ટમ પ્રોમ્પ્ટ્સના આધારે અલગ રીતે વર્તે છે, તેથી આ ફિલ્ડને વેરિએબલ તરીકે ગણો જેનું તમે A/B ટેસ્ટિંગ કરી શકો. અસ્પષ્ટ સિસ્ટમ પ્રોમ્પ્ટ અસ્પષ્ટ જવાબો આપે છે. ચોક્કસ પ્રોમ્પ્ટ મોડેલને સાચા માર્ગ પર રાખે છે—દાખલા તરીકે, આસિસ્ટન્ટને જણાવવું કે તે ફક્ત બિલિંગ અને રિટર્ન હેન્ડલ કરે છે, અને બાકીની બધી બાબતો માટે નમ્રતાથી ના પાડવી જોઈએ.

ઇન્ફ્રાસ્ટ્રક્ચરની સ્વતંત્રતા અને ડેટા સાર્વભૌમત્વ (Infrastructure Freedom and Data Sovereignty)

ઓપન-વેઇટ મોડેલ્સના સૌથી શાંત ફાયદાઓમાંનો એક કસ્ટડી (custody) છે. તમારા પ્રોમ્પ્ટ્સ અને કમ્પ્લીશન્સને તમારા એન્વાયરમેન્ટમાંથી બહાર જવાની જરૂર નથી. જો તમે મોડેલ ઓન-પ્રેમિસિસ અથવા વર્ચ્યુઅલ પ્રાઇવેટ ક્લાઉડની અંદર ચલાવો છો, તો તમે તૃતીય-પક્ષ ડેટા પ્રોસેસિંગ કરારોને દૂર કરો છો અને ટ્રેનિંગ-ડેટા વિવાદો સામેનું જોખમ ઘટાડો છો. હેલ્થકેર, ફાઇનાન્સ અને એવા કોઈપણ ડોમેન માટે આ મહત્વપૂર્ણ છે જ્યાં ડેટા લીક એ કમ્પ્લાયન્સ ઇવેન્ટ (compliance event) છે.

ભલે તમે એક્સટર્નલ ઇન્ફરન્સ હોસ્ટનો ઉપયોગ કરો છો, ઓપન વેઇટ્સ તમને પોર્ટેબિલિટી આપે છે. જો હોસ્ટ કિંમત અથવા શરતો બદલે છે, તો તમે તે જ મોડેલ ફાઇલો અન્ય પ્રોવાઇડર પર ખસેડી શકો છો અથવા તેને ઇન-હાઉસ લાવી શકો છો. તમે કોઈ સિંગલ API માં ફસાયેલા નથી કારણ કે વેઇટ્સ ધરાવતી માત્ર એક જ કંપની છે.

એક વ્યવહારુ શરૂઆત (A Practical Starting Point)

જો તમે આજે ઇન્ટિગ્રેશન કરી રહ્યા છો, તો એક સિંગલ મોડેલ અને એક સિંગલ એન્ડપોઈન્ટથી શરૂઆત કરો. તમારા HTTP ક્લાયન્ટને એક નાના એબ્સ્ટ્રેક્શન લેયરમાં રેપ (wrap) કરો જે ઓથેન્ટિકેશન, રિટ્રાય અને ટોકન લોગિંગ હેન્ડલ કરે. ત્યારબાદ સ્ટ્રીમિંગ ઉમેરો, કારણ કે યુઝર એક્સપિરિયન્સમાં તેનો તરત જ ફાયદો મળે છે. પછી હાઇ-વેલ્યુ વર્કફ્લો માટે એક ફંક્શન કોલ રજૂ કરો—સ્ટેટસ લુકઅપ, કન્ટેન્ટ મોડરેશન અથવા ફોર્મ ફિલિંગ. રોલઆઉટને વ્યાપક બનાવતા પહેલા એક અઠવાડિયા માટે લેટન્સી (latency), એરર રેટ્સ અને ટોકન ખર્ચનું મોનિટરિંગ કરો.

ઓપન-વેઇટ મોડેલ્સ ફુલ્લી મેનેજ્ડ API કરતા વધુ સેટઅપ માંગે છે, પરંતુ તેઓ પારદર્શિતા, લવચીકતા અને નિયંત્રણ સાથે તે પ્રયત્નનું વળતર આપે છે. ઇન્ટિગ્રેશન કાળજીપૂર્વક બનાવો, બધું ઇન્સ્ટ્રુમેન્ટ કરો, અને તમારી પાસે એક એવું AI લેયર હશે જે બરાબર તે રીતે વર્તશે જે રીતે તમારા એપ્લિકેશનને જરૂર છે.

સ્ત્રોત અને વધુ વાંચન