મોટાભાગના લોકો LLM ને પ્રોમ્પ્ટ કરી શકે છે. પરંતુ વાસ્તવિક ટ્રાફિકમાં ટકી શકે તેવું પ્રોડક્ટ બનાવવું એ તદ્દન અલગ વાત છે. જો તમે ચેટ વિન્ડોમાં ટાઈપ કરવાથી આગળ વધીને પ્રોડક્શન AI લોન્ચ કરવા માંગતા હોવ, તો તમારે આ સ્ટૅક (stack) ખરેખર કેવી રીતે કામ કરે છે તે સમજવું જરૂરી છે. આ કોઈ જાદુ નથી. તે અલગ-અલગ એન્જિનિયરિંગ સમસ્યાઓની એક પાઇપલાઇન છે, અને દરેક લેયર (layer) ના પોતાના નિષ્ફળતાના પ્રકારો (failure modes) હોય છે.
તમે એક શબ્દ ટાઈપ કરો ત્યારથી લઈને એજન્ટ કોઈ કાર્ય પૂર્ણ કરે ત્યાં સુધી આધુનિક AI સિસ્ટમ કેવી રીતે કામ કરે છે, ચાલો તે સમજીએ.
પાયો: મોડલ્સ કેવી રીતે વિચારે છે
તેના મૂળમાં, એક લાર્જ લેંગ્વેજ મોડલ (large language model) માત્ર એક જ કામ કરે છે: તે આગામી ટોકન (token) ની આગાહી કરે છે. તે ટોકન આગામી શબ્દ, શબ્દનો ભાગ અથવા કોઈ પ્રતીક પણ હોઈ શકે છે. બાકી બધું—કવિતા, કોડ, તર્ક—એ આ એક જ કાર્યને મોટા પાયે કરવાથી ઉદ્ભવતું વર્તન છે.
તમારા પ્રોમ્પ્ટથી મોડલના પ્રતિસાદ સુધીની સફર આ મુજબ છે.
Tokenization એ પ્રથમ પગલું છે. ન્યુરલ નેટવર્ક માટે કાચું લખાણ (raw text) અર્થહીન છે, તેથી મોડલ તમારા શબ્દોને ટુકડાઓમાં વિભાજિત કરે છે અને દરેક ટુકડાને એક નંબર સાથે જોડે છે. "tokenization" શબ્દ ત્રણ અલગ-અલગ ટોકન્સ બની શકે છે. "New York" શબ્દસમૂહ શબ્દભંડોળ (vocabulary) ના આધારે એક અથવા બે હોઈ શકે છે. આ નંબરો મનસ્વી નથી; તેઓ મોડલે તાલીમ દરમિયાન શીખેલા નિશ્ચિત ડિક્શનરીમાંથી આવે છે.
એકવાર શબ્દો નંબરો બની જાય પછી, તેમને અર્થની જરૂર હોય છે. Embeddings તે નંબરોને વેક્ટર્સ (vectors) માં ફેરવે છે—જે ફ્લોટિંગ-પોઈન્ટ મૂલ્યોની લાંબી યાદીઓ છે જે સમાન ખ્યાલોને ગાણિતિક અવકાશમાં એકબીજાની નજીક રાખે છે. "King" અને "Queen" એકબીજાની નજીક હોય છે. "Paris" અને "Berlin" એકસાથે ક્લસ્ટર થાય છે પરંતુ "Python" અથવા "JavaScript" થી અલગ વિસ્તારમાં હોય છે.
પરંતુ માત્ર વેક્ટર્સથી ક્રમ જતો રહે છે. Positional encoding મોડલને જણાવે છે કે વાક્યમાં દરેક ટોકન ક્યાં છે. તેના વગર, "The dog bit the man" અને "The man bit the dog" એકસરખા દેખાશે.
ત્યારબાદ attention mechanism આવે છે. અહીં મોડલ ઇનપુટમાં રહેલા તમામ ટોકન્સ પર નજર નાખે છે અને નક્કી કરે છે કે આગામી ટોકનની આગાહી કરવા માટે કયા ટોકન્સ મહત્વના છે. જ્યારે તમે પૂછો છો, "કંપની ક્યારે સ્થપાઈ હતી, અને અત્યારે તેનું નેતૃત્વ કોણ કરે છે?" ત્યારે મોડલે "founded" ને તારીખ સાથે અને "leads" ને CEO ના નામ સાથે જોડવાની જરૂર પડે છે. Attention આ જોડાણો બનાવે છે.
આ પ્રક્રિયાઓ layers માં ગોઠવાયેલી હોય છે—જેમાં ઘણીવાર ડઝનબંધ લેયર્સ હોય છે—જ્યાં શરૂઆતના લેયર્સ સિન્ટેક્સ (syntax) સંભાળે છે અને પછીના લેયર્સ અમૂર્ત તર્ક (abstract reasoning) બનાવે છે. મધ્યમાં ક્યાંક, feed-forward networks તથ્યલક્ષી જોડાણો સંગ્રહિત કરે છે. અહીં જ મોડલ એવું જ્ઞાન રાખે છે કે પેરિસ ફ્રાન્સની રાજધાની છે, અથવા કોઈ ચોક્કસ API ને JSON પેલોડની જરૂર છે. તે બરાબર ડેટાબેઝ નથી, પરંતુ વજન (weights) નું એક સંકુચિત જાળું છે જે પેટર્નને સક્રિય કરે છે.
અંતે, decoding આંતરિક વેક્ટર પ્રતિનિધિત્વને ફરીથી માનવ-વાંચન યોગ્ય ટોકન્સમાં રૂપાંતરિત કરે છે. મોડલ "જાણે" છે નહીં કે તે અંગ્રેજી લખી રહ્યું છે; તે ફક્ત હજારો સંભવિત આગામી ટોકન્સને રેન્ક કરે છે અને જ્યાં સુધી તે સ્ટોપ કંડિશન (stop condition) પર ન પહોંચે ત્યાં સુધી વારંવાર સૌથી વધુ સંભવિત ટોકન પસંદ કરે છે.
RAG લેયર: મોડલ્સને મેમરી આપવી
એક બેઝ મોડલ સમયમાં સ્થિર (frozen) હોય છે. તેના વજન (weights) કટ-ઓફ તારીખ સુધીના ઇન્ટરનેટને કેપ્ચર કરે છે, અને જ્યાં સુધી તમે તેને તમારા ખાનગી દસ્તાવેજો ન આપો ત્યાં સુધી તે તેને એક્સેસ કરી શકતું નથી. આ તેને મોટાભાગના વ્યવસાયિક કાર્યો માટે નકામું બનાવે છે. Retrieval-Augmented Generation, અથવા RAG, મોડલને એક બાહ્ય લાઇબ્રેરી આપીને આ સમસ્યાનું નિરાકરણ લાવે છે, જેનો ઉપયોગ તે જવાબ આપતા પહેલા કરી શકે છે.
આ સેટઅપ ખ્યાલમાં સરળ છે પરંતુ વ્યવહારમાં જટિલ છે. સૌ પ્રથમ, તમે તમારા દસ્તાવેજો લો છો અને chunking લાગુ કરો છો. તમે સો પાનાની PDF ને સીધી પ્રોમ્પ્ટ વિન્ડોમાં નાખી શકતા નથી. તમે તેને ફકરાઓ, વિભાગો અથવા અર્થપૂર્ણ બ્લોક્સમાં વિભાજિત કરો છો જે મોડલની કોન્ટેક્સ્ટ લિમિટ (context limit) માં સમાઈ શકે તેટલા નાના હોય અને તેમ છતાં તેનો અર્થ જળવાઈ રહે.
દરેક ચંક (chunk) એક embedding model માંથી પસાર થાય છે અને LLM ની અંદરના ટોકન્સની જેમ જ વેક્ટરમાં ફેરવાય છે. આ વેક્ટર્સ vector database માં રહે છે—જે ચોક્કસ લુકઅપને બદલે સામ્યતા શોધવા (similarity search) માટે રચાયેલ એક વિશિષ્ટ સ્ટોર છે. જ્યારે વપરાશકર્તા પ્રશ્ન પૂછે છે, ત્યારે તમે તેમની ક્વેરીને એમ્બેડ કરો છો અને ડેટાબેઝને પૂછો છો: "અર્થની દ્રષ્ટિએ આ વેક્ટરની સૌથી નજીક કયા ચંક્સ છે?"
માત્ર કાચું વેક્ટર સર્ચ ઘણીવાર ચોક્કસ મેચ ચૂકી જાય છે. એક સારું પ્રોડક્શન સિસ્ટમ hybrid search નો ઉપયોગ કરે છે, જે કીવર્ડ મેચિંગને સેમેન્ટિક સામ્યતા (semantic similarity) સાથે જોડે છે. જો કોઈ "SLA-99 compliance" વિશે પૂછે છે, તો તમારે એવો દસ્તાવેજ જોઈએ છે જેમાં તે શબ્દ શબ્દમાં હોય, માત્ર તે જે સમાન લાગે તે જ નહીં.
રિટ્રીવલ (retrieval) પછી, re-ranking ઘોંઘાટ (noise) ને ફિલ્ટર કરે છે. શરૂઆતી સર્ચ વીસ ચંક્સ પરત કરી શકે છે, પરંતુ તેમાંથી માત્ર ટોચના ત્રણ કે ચાર જ ખરેખર મદદરૂપ થાય છે. રી-રેન્કર સુસંગતતાને સ્કોર આપે છે અને LLM સુધી પહોંચતા પહેલા બાકીનાને દૂર કરે છે, જેનાથી ટોકન્સ બચે છે અને Hallucinations (ભ્રમણા) ઘટે છે.
એજન્ટ લેયર: પગલાં લેવા
RAG lets a model read. Agents let it act.
An agent is fundamentally an LLM stuck inside a loop. It observes, reasons, acts, and then observes again. If you ask an agent to book a flight, it does not just describe how booking works. It breaks the task into steps, calls the right functions, reads the responses, and adjusts.
The loop looks like this. Observe: the agent reads the current state—your request, the results of previous tool calls, any errors. Reason: the LLM decides what to do next, often by generating a structured plan or selecting from predefined options. Act: it calls a tool.
Tools are how agents touch the real world. They are defined with JSON schemas that tell the model exactly what parameters an API needs. The LLM does not make arbitrary HTTP requests. It fills in a schema. "Call the weather API with city: London and units: metric." If the tool returns a temperature, the agent feeds