𝗖𝗼𝗻𝘁𝗲𝘅𝘁 𝗪𝗶𝗻𝗱𝗼𝘄𝘀 𝗔𝗿𝗲 𝗚𝗲𝘁𝘁𝗶𝗻𝗴 𝗛𝘂𝗴𝗲
ಜನರು ಪ್ರತಿಯೊಂದಕ್ಕೂ 'ಏಜೆಂಟ್' (agent) ಎಂಬ ಪದವನ್ನು ಬಳಸುತ್ತಿದ್ದಾರೆ.
ಒಂದು ಟೂಲ್ ಅನ್ನು ಕರೆಯುವ ಫಂಕ್ಷನ್ ಏಜೆಂಟ್ ಆಗಿದೆ. ಮೆಮೊರಿ ಹೊಂದಿರುವ ಚಾಟ್ಬಾಟ್ ಏಜೆಂಟ್ ಆಗಿದೆ. ಲೂಪ್ ಹೊಂದಿರುವ ಸ್ಕ್ರಿಪ್ಟ್ ಏಜೆಂಟ್ ಆಗಿದೆ.
ಈ ತಪ್ಪಿನಿಂದಾಗಿ ಕೆಟ್ಟ ಇಂಜಿನಿಯರಿಂಗ್ ಆಗುತ್ತದೆ. ತಂಡಗಳು ಸರಳ ಕೆಲಸಗಳಿಗೆ ಅತಿಯಾದ ಇಂಜಿನಿಯರಿಂಗ್ (over-engineer) ಮಾಡುತ್ತವೆ ಮತ್ತು ಸಂಕೀರ್ಣ ಕೆಲಸಗಳಿಗೆ ಅಲ್ಪ ಇಂಜಿನಿಯರಿಂಗ್ (under-engineer) ಮಾಡುತ್ತವೆ. ಕೇವಲ ಒಂದು ಉತ್ತಮ ಪ್ರಾಂಪ್ಟ್ (prompt) ಅಗತ್ಯವಿರುವ ವರ್ಕ್ಫ್ಲೋಗಳಿಗಾಗಿ, ಏಜೆಂಟ್ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ (agent orchestration) ಮಾಡಲು ತಂಡಗಳು ವಾರಗಟ್ಟಲೆ ಸಮಯ ವ್ಯಯಿಸುವುದನ್ನು ನಾನು ನೋಡುತ್ತಿದ್ದೇನೆ.
ನೈಜ ಏಜೆಂಟ್ನ ಬಗ್ಗೆ ನನ್ನ ವ್ಯಾಖ್ಯಾನ ಇಲ್ಲಿದೆ.
ಏಜೆಂಟ್ ಒಂದು ಉದ್ದೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಅದು ಕೇವಲ ಸೂಚನೆಗಳನ್ನು ಪಾಲಿಸುವುದಿಲ್ಲ. ಮುಂದೆ ಏನು ಮಾಡಬೇಕೆಂದು ಅದು ನಿರ್ಧರಿಸುತ್ತದೆ. ಅದು ವೈಫಲ್ಯಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ. ಯಾವಾಗ ನಿಲ್ಲಿಸಬೇಕೆಂದು ಅದಕ್ಕೆ ತಿಳಿದಿರುತ್ತದೆ.
ಈ ಮಾನದಂಡಗಳನ್ನು ಬಳಸಿ:
- ಮನುಷ್ಯ ಪ್ರತಿಯೊಂದು ಹಂತವನ್ನೂ ಮಾರ್ಗದರ್ಶನ ಮಾಡಬೇಕಿದ್ದರೆ, ಅದು ಚಾಟ್ ಇಂಟರ್ಫೇಸ್ ಆಗಿದೆ.
- ಒಂದು ವೇಳೆ ಸಿಸ್ಟಮ್ ಫೇಲ್ ಆದ ಟೂಲ್ ಕಾಲ್ನಿಂದ ಚೇತರಿಸಿಕೊಂಡರೆ, ಅದು ಏಜೆಂಟ್ ಆಗುವತ್ತ ಸಾಗುತ್ತಿದೆ ಎಂದರ್ಥ.
- ಸಿಸ್ಟಮ್ ಒಂದು ಗುರಿಯನ್ನು ಕಾರ್ಯಗಳಾಗಿ (tasks) ವಿಂಗಡಿಸಿ ಅವುಗಳನ್ನು ನಿಯೋಜಿಸಿದರೆ, ಅದು ನೈಜ ಏಜೆಂಟ್ ಆಗಿದೆ.
ಹೆಚ್ಚಿನ ಯಶಸ್ವಿ ಏಜೆಂಟ್ಗಳು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳಿಗೆ ಸೀಮಿತವಾಗಿರುತ್ತವೆ (narrow). ಅವು ಒಂದು ಕೆಲಸವನ್ನು ಉತ್ತಮವಾಗಿ ಮಾಡುತ್ತವೆ. ಅವು ಗ್ರಾಹಕ ಬೆಂಬಲದ ವರ್ಗೀಕರಣ (customer support triage) ಅಥವಾ ಡಾಕ್ಯುಮೆಂಟ್ ಎಕ್ಸ್ಟ್ರಾಕ್ಷನ್ (document extraction) ಅನ್ನು ನಿಭಾಯಿಸುತ್ತವೆ. ಅವು ಸಾಮಾನ್ಯ ತರ್ಕದ ಇಂಜಿನ್ಗಳಲ್ಲ (general reasoning engines).
ಯಶಸ್ವಿ ತಂಡಗಳು ಈ ಮೂರು ವಿಷಯಗಳ ಮೇಲೆ ಗಮನ ಹರಿಸುತ್ತವೆ:
- ಟೂಲ್ ವಿನ್ಯಾಸ (Tool design): ಇಂಟರ್ಫೇಸ್ ಎಷ್ಟು ಸ್ಪಷ್ಟವಾಗಿದೆ?
- ವೈಫಲ್ಯ ನಿರ್ವಹಣೆ (Failure handling): ಒಂದು ಟೂಲ್ ಏನನ್ನೂ ನೀಡದಿದ್ದಾಗ ಏನಾಗುತ್ತದೆ?
- ಅಬ್ಸರ್ವೇಬಿಲಿಟಿ (Observability): ಏಜೆಂಟ್ ಏಕೆ ನಿರ್ಧಾರ ಕೈಗೊಂಡಿತು ಎಂಬುದನ್ನು ನೀವು ಪತ್ತೆಹಚ್ಚಬಲ್ಲಿರಾ?
ಅ成功的 (Unsuccessful) ತಂಡಗಳು ಕೇವಲ ಒಂದು ಮಾಡೆಲ್ ಬದಲಿಗೆ ಹೊಸ ಮಾಡೆಲ್ ಅನ್ನು ಬಳಸುತ್ತವೆ ಮತ್ತು ಉತ್ತಮ ಫಲಿತಾಂಶಗಳನ್ನು ನಿರೀಕ್ಷಿಸುತ್ತವೆ. ಅವು ಸಿಸ್ಟಮ್ ವಿನ್ಯಾಸವನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತವೆ.
LangChain ಅಥವಾ CrewAI ನಂತಹ ಫ್ರೇಮ್ವರ್ಕ್ಗಳು ಪ್ರತಿ ತಿಂಗಳು ಬದಲಾಗುತ್ತವೆ. ಪ್ಯಾಟರ್ನ್ (pattern) ಗಿಂತ ಫ್ರೇಮ್ವರ್ಕ್ ಹೆಚ್ಚು ಮುಖ್ಯವಲ್ಲ.
ಈ ಪ್ಯಾಟರ್ನ್ಗಳನ್ನು ಬಳಸಿ:
- ಯೋಜಿಸಿ ನಂತರ ಕಾರ್ಯಗತಗೊಳಿಸಿ (Plan then execute): ತರ್ಕದ ಹಂತವನ್ನು (reasoning step) ಕಾರ್ಯಗತಗೊಳಿಸುವ ಹಂತದಿಂದ (execution step) ಪ್ರತ್ಯೇಕಿಸಿ.
- ರಿಟ್ರಿವಲ್ ಅನ್ನು ತರ್ಕದಿಂದ ಪ್ರತ್ಯೇಕಿಸಿ (Separate retrieval from reasoning): ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪಡೆಯುವುದು ಅದನ್ನು ಬಳಸುವುದಕ್ಕಿಂತ ಭಿನ್ನವಾದ ಕೆಲಸವಾಗಿದೆ.
- ಸ್ಪಷ್ಟ ಹ್ಯಾಂಡ್ಆಫ್ಗಳು (Explicit handoffs): ಒಂದು ಏಜೆಂಟ್ ಮತ್ತೊಂದಕ್ಕೆ ಕೆಲಸವನ್ನು ವರ್ಗಾಯಿಸಿದಾಗ ಸ್ಟ್ರಕ್ಚರ್ಡ್ ಲಾಗ್ಗಳನ್ನು (structured logs) ಬಳಸಿ.
ಫ್ರೇಮ್ವರ್ಕ್ ಕೇವಲ ಒಂದು ಮೂಲ ಚೌಕಟ್ಟಿನಂತೆ (scaffolding). ಆರ್ಕಿಟೆಕ್ಚರ್ (architecture) ಎಂಬುದು ನಿಜವಾದ ಕಟ್ಟಡ.
RAG ಒಂದು ಪ್ರಮಾಣಿತ ವಿಧಾನವಾಗಿದೆ, ಆದರೆ ಚಂಕಿಂಗ್ (chunking) ಹೆಚ್ಚಾಗಿ ತಪ್ಪಾಗಿರುತ್ತದೆ. ನೀವು ಡಾಕ್ಯುಮೆಂಟ್ಗಳನ್ನು ಸರಿಯಾಗಿ ವಿಂಗಡಿಸದಿದ್ದರೆ, ಮಾಡೆಲ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದು ಹ್ಯಾಲ್ಯುಸಿನೇಷನ್ಗಳಿಗೆ (hallucinations) ಕಾರಣವಾಗುತ್ತದೆ.
ನಿಮ್ಮ RAG ಫಲಿತಾಂಶಗಳು ಪ್ರಯೋಜನವಿಲ್ಲದಂತಿದ್ದರೆ, ನಿಮ್ಮ ಚಂಕಿಂಗ್ ಮತ್ತು ಮೆಟಾಡ worlds (metadata) ಅನ್ನು ಪರಿಶೀಲಿಸಿ. ಮಾಡೆಲ್ ಅಪರೂಪಕ್ಕೆ ಸಮಸ್ಯೆಯಾಗುತ್ತದೆ.
ಮಾಡೆಲ್ಗಳು ಉತ್ತಮಗೊಳ್ಳುತ್ತವೆ. ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋಗಳು ಬೆಳೆಯುತ್ತವೆ. ಟೋಕನ್ ವೆಚ್ಚಗಳು ಕಡಿಮೆಯಾಗುತ್ತವೆ.
ಇವುಗಳಲ್ಲಿ ಯಾವುದೂ ನೈಜ ಇಂಜಿನಿಯರಿಂಗ್ ಸವಾಲನ್ನು ಪರಿಹರಿಸುವುದಿಲ್ಲ. ನೀವು ಗಮನಿಸುತ್ತಿಲ್ಲದಿದ್ದಾಗಲೂ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಸಿಸ್ಟಮ್ಗಳನ್ನು ನೀವು ನಿರ್ಮಿಸಬೇಕು.
ಗವರ್ನೆನ್ಸ್ (governance), ಅಬ್ಸರ್ವೇಬಿಲಿಟಿ (observability) ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಟೂಲ್ ಬಳಕೆಯ ಮೇಲೆ ಗಮನ ಹರಿಸಿ. ಅತ್ಯುತ್ತಮ ಇಂಜಿನಿಯರ್ಗಳು ಮಾಡೆಲ್ ಸಂಶೋಧಕರಲ್ಲ. ಅವರು ವಿಶ್ವಾಸಾರ್ಹ AI ಅನ್ನು ನಿರ್ಮಿಸುವ ಸಿಸ್ಟಮ್ ಡಿಸೈನರ್ಗಳಾಗಿರುತ್ತಾರೆ.
ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋಗಳು (Context windows) ದೊಡ್ಡದಾಗುತ್ತಿವೆ, ಅದು ಎಲ್ಲವನ್ನೂ ಹೇಗೆ ಬದಲಾಯಿಸುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ
ಲಾರ್ಜ್ ಲ್ಯಾಂಗ್ವೇಜ್ ಮಾಡೆಲ್ಗಳ (LLMs) ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ ಅಪ್ರತಿಮ ವೇಗದಲ್ಲಿ ವಿಸ್ತರಿಸುತ್ತಿದೆ. ನಾವು ಕೆಲವು ಸಾವಿರ ಟೋಕನ್ಗಳನ್ನು ಹೊಂದಿರುವ ಮಾಡೆಲ್ಗಳಿಂದ, ಲಕ್ಷಾಂತರ ಟೋಕನ್ಗಳನ್ನು ನಿರ್ವಹಿಸಬಲ್ಲ ಮಾಡೆಲ್ಗಳವರೆಗೆ ಬಂದಿದ್ದೇವೆ. ಇದು ಕೇವಲ ತಾಂತ್ರಿಕ ಮೈಲಿಗಲ್ಲಲ್ಲ; ನಾವು AI ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ರೀತಿಯಲ್ಲಿನ ಒಂದು ಮೂಲಭೂತ ಬದಲಾವಣೆ (paradigm shift).
ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ ಎಂದರೇನು?
ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋ ಎಂಬುದು ಒಂದು ಮಾಡೆಲ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡುವಾಗ ಏಕಕಾಲದಲ್ಲಿ "ನೋಡಬಲ್ಲ" ಮತ್ತು ಪರಿಗಣಿಸಬಲ್ಲ ಪಠ್ಯದ (ಟೋಕನ್ಗಳ) ಪ್ರಮಾಣವಾಗಿದೆ. ಇದನ್ನು ಮಾಡೆಲ್ನ ಅಲ್ಪಾವಧಿಯ ನೆನಪು (short-term memory) ಎಂದು ಭಾವಿಸಿ.
ವಿಕಾಸ (The Evolution)
- ಆರಂಭಿಕ LLMಗಳು: 2k - 4k ಟೋಕನ್ಗಳು.
- GPT-4: 8k - 32k ಟೋಕನ್ಗಳು.
- Claude 3: 200k ಟೋಕನ್ಗಳು.
- Gemini 1.5 Pro: 1M - 2M ಟೋಕನ್ಗಳು.
ಇದು ಎಲ್ಲವನ್ನೂ ಹೇಗೆ ಬದಲಾಯಿಸುತ್ತದೆ
1. RAG ನ ಅಂತ್ಯವೇ? (ಅಷ್ಟಾಗಿ ಅಲ್ಲ, ಆದರೆ...)
ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ, LLM ಗೆ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್ಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ನೀಡಲು, ನಾವು Retrieval-Augmented Generation (RAG) ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ನಾವು ಡೇಟಾವನ್ನು ಸಣ್ಣ ಭಾಗಗಳಾಗಿ (chunks) ವಿಂಗಡಿಸುತ್ತೇವೆ, ಎಂಬೆಡ್ (embed) ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಸಂಬಂಧಿತ ಭಾಗಗಳನ್ನು ಮಾತ್ರ ಹಿಂಪಡೆಯುತ್ತೇವೆ (retrieve).
ಬೃಹತ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋಗಳೊಂದಿಗೆ, ನೀವು ಇಡೀ ದಾಖಲೆಯನ್ನು (ಅಥವಾ ಹಲವಾರು ಪುಸ್ತಕಗಳನ್ನು ಸಹ) ನೇರವಾಗಿ ಪ್ರಾಂಪ್ಟ್ನಲ್ಲಿ ಹಾಕಬಹುದು.
2. ಇಡೀ ಡೇಟಾಸೆಟ್ಗಳ ಮೇಲೆ ತರ್ಕ ಮಾಡುವುದು (Reasoning Over Entire Datasets)
ಕೇವಲ ಸಣ್ಣ ತುಣುಕುಗಳನ್ನು ನೋಡುವ ಬದಲು, ಮಾಡೆಲ್ ಒಂದು ಬೃಹತ್ ಕೋಡ್ ಬೇಸ್ (codebase) ಅಥವಾ ಉದ್ದವಾದ ಕಾನೂನು ದಾಖಲೆಯ ಆರಂಭ ಮತ್ತು ಅಂತ್ಯದ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ನೋಡಬಲ್ಲದು.
3. 'Needle in a Haystack' ಸವಾಲು
ವಿಂಡೋಗಳು ಬೆಳೆದಂತೆ, ಸವಾಲು "ನಾವು ಎಷ್ಟು ಮಾಹಿತಿ ಅಡಕ ಮಾಡಬಹುದು" ಎಂಬುದರಿಂದ "ಮಾಡೆಲ್ ನಿಜವಾಗಿಯೂ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಬಲ್ಲದೇ?" ಎಂಬುದಕ್ಕೆ ಬದಲಾಗುತ್ತದೆ. ಇದನ್ನು 'Needle in a Haystack' ಪರೀಕ್ಷೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ತೀರ್ಮಾನ
ಬೃಹತ್ ಕಾಂಟೆಕ್ಸ್ಟ್ ವಿಂಡೋಗಳ ಯುಗವು ಇಲ್ಲಿದೆ. ಇದು ನಾವು AI ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನಿರ್ಮಿಸುವ ರೀತಿಯನ್ನು ಮರು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಸಂಕೀರ್ಣವಾದ ರಿಟ್ರಿೀವಲ್ ಪೈಪ್ಲೈನ್ಗಳಿಂದ ಸರಳವಾದ ಮತ್ತು ನೇರವಾದ ಸಂವಹನಗಳತ್ತ ನಮ್ಮನ್ನು ಕೊಂಡೊಯ್ಯುತ್ತದೆ.