AI ಏಜೆಂಟ್‌ಗಳು ಜನರೇಟಿವ್ AIದಲ್ಲಿ ಒಮ್ಮೆಯಾಗಿ ಉದ್ಭವಿಸಿರುವ ಅತ್ಯಂತ ರೋಚಕ ಅಭಿವೃದ್ಧಿಯಾಗಿ LLM ಗಳನ್ನು ಸಹಾಯಕ ವೀಕ್ಷಣೆಯಿಂದ ಕಾರ್ಯಗಳನ್ನು ನಡೆಸಲು ಸಾಮರ್ಥ್ಯವಿರುವ ಏಜೆಂಟ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. AI ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಅದರಲ್ಲಿ LLM ಗಳಿಗೆ ಸಾಧನಗಳು ಮತ್ತು ಸ್ಥಿತಿಯ ನಿರ್ವಹಣೆಗೆ ಪ್ರವೇಶ ನೀಡಲಾಗುತ್ತದೆ. ಈ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ದೃಷ್ಟಿಗೊಳ್ಳುವಿಕೆಯನ್ನು ಹೆಚ್ಚಿಸಿವೆ, LLM ಗಳು ಯೋಜಿಸಿರುವ ಕ್ರಿಯೆಯನ್ನು ಬಳಕೆದಾರರು ಮತ್ತು ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರು ತಪಾಸಣೆ ಮಾಡುವ ಮೂಲಕ ಅನುಭವ ನಿರ್ವಹಣ ಅನ್ನು ಸುಧಾರಿಸುತ್ತವೆ.
ಈ ಪಾಠದಲ್ಲಿ ಕೆಳಗಿನ ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:
- ಏನು AI ಏಜೆಂಟ್ ಎಂಬುದು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು - ಏನು ನಿಜವಾಗಿಯೂ AI ಏಜೆಂಟ್?
- ಐದು ವಿಭಿನ್ನ AI ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳನ್ನು ಅನಾವರಣ ಮಾಡುವುದು - ಅವುಗಳನ್ನು ಏನು ವೈಶಿಷ್ಟ್ಯವಾಗಿಸುತ್ತದೆ?
- ಈ AI ಏಜೆಂಟ್‌ಗಳನ್ನು ವಿಭಿನ್ನ ಬಳಕೆ ಪ್ರಕರಣಗಳಿಗೆ ಅನ್ವಯಿಸುವುದು - ನಾವು ಯಾವಾಗ AI ಏಜೆಂಟ್‌ಗಳನ್ನು ಬಳಸಬೇಕು?
ಈ ಪಾಠವನ್ನು ತೆಗೆದುಕೊಂಡ ನಂತರ, ನೀವು ಸಾಧ್ಯವಾಗುವುದು:
- AI ಏಜೆಂಟ್‌ಗಳು ಏನೆಂದು ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ವಿವರಿಸಿ.
- ಕೆಲವು ಜನಪ್ರಿಯ AI ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ, ಮತ್ತು ಅವುಗಳು ಹೇಗೆ ಭಿನ್ನವಾಗಿವೆ.
- AI ಏಜೆಂಟ್‌ಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ರೀತಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡು ಅವುಗಳೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು.
AI ಏಜೆಂಟ್‌ಗಳು ಜನರೇಟಿವ್ AI ಲೋಕದಲ್ಲಿ ಅತ್ಯಂತ ರೋಚಕ ಕ್ಷೇತ್ರ. ಈ ಉತ್ಸಾಹದೊಂದಿಗೆ ಕೆಲವೊಮ್ಮೆ ಪದಗಳು ಮತ್ತು ಅವುಗಳ ಅನ್ವಯಿಕೆಯಲ್ಲಿ ಗೊಂದಲ ಉಂಟಾಗಬಹುದು. ಸರಳವಾಗಿದ್ದು ಹೆಚ್ಚಿನ AI ಏಜೆಂಟ್‌ಗಳು ಸೂಚಿಸುವ ಸಾಧನಗಳನ್ನು ಸಮಾವೇಶಿಸಿಕೊಳ್ಳಲು ನಾನು ಈ ವ್ಯಾಖ್ಯಾನವನ್ನು ಬಳಸದಿದ್ದೇನೆ:
AI ಏಜೆಂಟ್‌ಗಳು LLM ಗಳಿಗೆ ಸ್ಥಿತಿ ಮತ್ತು ಸಾಧನಗಳು ಗೆ ಪ್ರವೇಶ ಕೊಡುವ ಮೂಲಕ ಕಾರ್ಯಗಳನ್ನು ನಡೆಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತವೆ.
ಈ ಪದಗಳನ್ನು ವಿವರಿಸೋಣ:
ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು - ಈ ಕೋರ್ಸ್‌ನಲ್ಲಿ ಲೇಖನಕ್‍ವೆಂದು ಉಲ್ಲೇಖಿಸುವ ಮಾದರಿಗಳು, ಉದಾಹರಣೆಗೆ GPT-5, GPT-4o, ಮತ್ತು Llama 3.3 ಇತ್ಯಾದಿ.
ಸ್ಥಿತಿ - ಇದು LLM ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿರುವ ಸಂಧರ್ಭವನ್ನು ಸೂಚಿಸುತ್ತದೆ. LLM ಅದೃಷ್ಟ ಹಾದಿಗಳ ಹಿಂದಿನ ಕ್ರಿಯೆಗಳ ಮತ್ತು ಪ್ರಸ್ತುತ ಸನ್ನಿವೇಶದ ಪ್ರಕಾರ ತನ್ನ ಮುಂದಿನ ನಿರ್ಧಾರಗಳನ್ನು ನಡೆಸಲು ಹಕ್ಕು ಪಡೆಯುತ್ತದೆ. AI ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರಿಗೆ ಈ ಸನ್ನಿವೇಶವನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ.
ಸಾಧನಗಳು - ಬಳಕೆದಾರ ಕೇಳಿದ ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಮತ್ತು LLM ಯೋಜಿಸಿದ ಕಾರ್ಯವನ್ನು ನೆರವಾಗಲು LLM ಗೆ ಸಾಧನಗಳಿಗೆ ಪ್ರವೇಶ ಬೇಕಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯ ಸಾಧನದ ಉದಾಹರಣೆಗಳು ಡೇಟಾಬೇಸ್, API, ಹೊರಗಿನ ಅಪ್ಲಿಕೇಶನ್ ಅಥವಾ ಮತ್ತೊಂದು LLM ಆಗಿರಬಹುದು!
ಈ ವ್ಯಾಖ್ಯಾನಗಳು ಮುಂದಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅವು ಹೇಗೆ ಅನುಷ್ಠಾನಗೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ಉತ್ತಮವಾಗಿ ತಿಳಿಯಲು ಸಹಾಯ ಮಾಡಬಹುದು. ವಿವಿಧ AI ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:
LangChain ಏಜೆಂಟ್‌ಗಳು ನಾವು ಮೇಲ್ಮ್ಮನಿಸಿದ ವ್ಯಾಖ್ಯಾನದ ಅನುಷ್ಠಾನವಾಗಿದೆ.
ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸಲು, ಇದು AgentExecutor ಎನ್ನುವ ಸಂಯೋಜಿತ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ನಿರ್ಧರಿಸಿದ agent ಮತ್ತು ಲಭ್ಯವಿರುವ tools ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ.
Agent Executor ಚಾಟ್ ಇತಿಹಾಸವನ್ನು ಸಂಗ್ರಹಿಸಿ ಚಾಟಿನ ಸ_context_ ಅಲ್ಲಿ ಒದಗಿಸುತ್ತದೆ.
LangChain ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಆಮದು ಮಾಡಿಕೊಳ್ಳಬಹುದಾದ ಸಾಧನಗಳ ಕೆಲಟಾಗ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇವು ಸಮುದಾಯ ಮತ್ತು LangChain ತಂಡದಿಂದ ಸೃಷ್ಟಿಸಲಾಗಿದೆ.
ನೀವು ನಂತರ ಈ ಸಾಧನಗಳನ್ನು ನಿರ್ಧರಿಸಿ Agent Executor ಗೆ ಮುಡಿ ಪಾಸು ಮಾಡಬಹುದು.
AI ಏಜೆಂಟ್‌ಗಳ ಬಗ್ಗೆ ಮಾತಾಡುವಾಗ ದೃಶ್ಯತೆ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಅಂಶ. ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರಿಗೆ LLM ಯಾವ ಸಾಧನವನ್ನು ಮತ್ತು ಏಕೆ ಬಳಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳುವುದು ಅಗತ್ಯ. ಇದಕ್ಕಾಗಿ LangChain ತಂಡ LangSmith ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದೆ.
ಮುಂದಿನ AI ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ನಾವು ಚರ್ಚಿಸುವುದು AutoGen. AutoGen ನ ಪ್ರಮುಖ fócus ಸಂಭಾಷಣೆಗಳು. ಏಜೆಂಟ್‌ಗಳು ಸಂಭಾಷಣಾ ಸಾಮರ್ಥ್ಯ ಹೊಂದಿರುತ್ತವೆ ಮತ್ತು ಕಸ್ಟಮೈಸಬಲ ಆಗಿವೆ.
ಸಂಭಾಷಣಾ ಸಾಮರ್ಥ್ಯ - LLM ಗಳು ಕಾರ್ಯ ಪೂರ್ಣಗೊಳಿಸಲು ಮತ್ತೊಬ್ಬ LLM ಜೊತೆ ಸಂಭಾಷಣೆ ಆರಂಭಿಸಿ ಮತ್ತು ಮುಂದುವರಿಸಬಹುದು. ಇದನ್ನು AssistantAgents ಸೃಷ್ಟಿಸುವ ಮೂಲಕ ಮತ್ತು ಅವರಿಗೆ ನಿರ್ದಿಷ್ಟ ವ್ಯವಸ್ಥೆಯ ಸಂದೇಶ ನೀಡುವ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ.
autogen.AssistantAgent( name="Coder", llm_config=llm_config, ) pm = autogen.AssistantAgent( name="Product_manager", system_message="Creative in software product ideas.", llm_config=llm_config, )ಕಸ್ಟಮೈಸಬಲ - ಏಜೆಂಟ್‌ಗಳನ್ನು LLM ಗಿಂತ ಬೇರೆಯವರೆಗೆ ಬಳಕೆದಾರ ಅಥವಾ ಸಾಧನವೆಂದು ವಿವರಣೆ ಮೇಲೆ ರಚಿಸಬಹುದು. ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರಾಗಿ ನೀವು UserProxyAgent ಅನ್ನು ನಿರ್ಧರಿಸಬಹುದು, ಇದು ಕಾರ್ಯ ಪೂರ್ಣಗೊಳಿಸುವುದಕ್ಕಾಗಿ ಬಳಕೆದಾರರಿಂದ ಪ್ರತಿಕ್ರಿಯೆ ಸಂಗ್ರಹಿಸುವುದು. ಈ ಪ್ರತಿಕ್ರಿಯೆ ಕಾರ್ಯ ನಿರ್ವಹಣೆಯನ್ನು ಮುಂದುವರಿಸಲು ಅಥವಾ ನಿಲ್ಲಿಸಲು ಸಹಾಯ ಮಾಡಲಿದೆ.
user_proxy = UserProxyAgent(name="user_proxy")ಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು, ಸಹಾಯಕ ಏಜೆಂಟ್ ಪೈಥಾನ್ ಕೋಡ್ ರಚಿಸದು ಕಾರ್ಯವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು.
ಪ್ರಕ್ರಿಯೆಯ ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
system_message="For weather related tasks, only use the functions you have been provided with. Reply TERMINATE when the task is done."ಈ ವ್ಯವಸ್ಥೆಯ ಸಂದೇಶ ಈ ನಿರ್ದಿಷ್ಟ LLM ಗೆ ಯಾವ ಫಂಕ್ಷನ್ಗಳು ಅದರ ಕಾರ್ಯಕ್ಕೆ ಸಂಬಂಧಿಸಿದವು ಎಂಬುದನ್ನು ನಿರ್ದೇಶಿಸುತ್ತದೆ. AutoGen ನಲ್ಲಿ ನಿಮಗೆ ವಿಭിന്ന ವ್ಯವಸ್ಥೆಯ ಸಂದೇಶಗಳೊಂದಿಗೆ ಹಲವಾರು AssistantAgents ಇರಬಹುದು ಎಂದು ನೆನಪಿಡಿ.
user_proxy.initiate_chat( chatbot, message="I am planning a trip to NYC next week, can you help me pick out what to wear? ", )ಬಳಕೆದಾರ ಪ್ರಾಕ್ಸಿಯಿಂದ (ಮಾನವನು) ಈ ಸಂದೇಶ ಏಜೆಂಟ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ಫಂಕ್ಷನ್‌ಗಳ ಅನ್ವೇಷಣೆ ಮಾಡಬೇಕೆಂದು ಸೂಚಿಸುತ್ತದೆ.
chatbot (to user_proxy):
***** Suggested tool Call: get_weather ***** Arguments: {"location":"New York City, NY","time_periond:"7","temperature_unit":"Celsius"} ******************************************************** --------------------------------------------------------------------------------
>>>>>>>> EXECUTING FUNCTION get_weather... user_proxy (to chatbot): ***** Response from calling function "get_weather" ***** 112.22727272727272 EUR ****************************************************************
ಪ್ರಾಥಮಿಕ ಚಾಟ್ ಪ್ರಕ್ರಿಯೆಯಾದ ಮೇಲೆ, ಏಜೆಂಟ್ ಆ ಲಭ್ಯವಿರುವ ಸಾಧನವನ್ನು ಕರೆಯಲು ಸೂಚಿಸುತ್ತದೆ. ಇಲ್ಲಿ get_weather ಎನ್ನುವ ಫಂಕ್ಷನ್ ಆಗಿದೆ. ನಿಮ್ಮ ವಿನ್ಯಾಸ ಅನುಸಾರ, ಇದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದು ಅಥವಾ ಬಳಕೆದಾರ ನಿದರ್ಶನದ ಅವಲಂಬಿತವಾಗಿರಬಹುದು.
ನೀವು ಆರಂಭಿಸಲು AutoGen ಕೋಡ್ ಮಾದರಿಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಬಹುದು.
Microsoft Agent Framework ಮೈಕ್ರೊಸಾಫ್ಟ್ ನ ಡೆವಲಪರ್‌ಗಳ AI ಏಜೆಂಟ್ ಮತ್ತು ಬಹು ಏಜೆಂಟ್ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಪೈಥಾನ್ ಮತ್ತು .NET ನಲ್ಲಿ ನಿರ್ಮಿಸಲು ಒದಗಿಸುವ ಓಪನ್ ಸೋರ್ಸ್ SDK. ಇದು ಎರಡು ಮುಂಚಿನ ಮೈಕ್ರೊಸಾಫ್ಟ್ ಯೋಜನೆಗಳ, Semantic Kernel ನ ಉದ್ಯಮ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು AutoGen ನ ಬಹು ಏಜೆಂಟ್ ಸಂಚಲನವನ್ನು ಒಂದಾಗಿಸಿದೆ. ನೀವು ಹೊಸ ಏಜೆಂಟ್ ಪ್ರಾಜೆಕ್ಟ್ ಶುರುಮಾಡುತ್ತಿದ್ದರೆ, ಇದು AutoGen ಗೆ ಶಿಫಾರಸು ಮಾಡಲಾದ ಪರಗ್ರಹ.
ಈ ಫ್ರೇಮ್‌ವರ್ಕ್ ಒಂದೇ ಏಜೆಂಟ್ ಚಾಟ್‌ನಿಂದ ಸಂಕೀರ್ಣ ಬಹು ಏಜೆಂಟ್ ಕೆಲಸದಳವರೆಗೆ ವಿಸ್ತರಿಸುತ್ತದೆ, ಮತ್ತು ಮೈಕ್ರೊಸಾಫ್ಟ್ ಫೌಂಡ್ರಿ, ಅಜೂರ್ ಓಪನ್‌ಎಐ ಮತ್ತು ಓಪನ್‌ಎಐ ಜೊತೆಗೆ ನೇರವಾಗಿ ಸಂಯೋಜಿಸುತ್ತದೆ. ಇದು ಓಪನ್‌ಟೆಲಿಮೆಟ್ರಿ ಮೂಲಕ ನಿರ್ಮಿತ ವೀಕ್ಷಣೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಏಜೆಂಟ್‌ಗಳು ಏನು ಮಾಡುತ್ತಿವೆ ಎಂಬುದನ್ನು ನೀವು ಹತ್ತಿರದಿಂದ ಗಮನಿಸಬಹುದು.
ಸ್ಥಿತಿ - ಈ ಫ್ರೇಮ್‌ವರ್ಕ್ ನೀವು ಸಂಭಾಷಣೆಯ ಸ_context_ ಅನ್ನು ಥ್ರೆಡ್‌ಗಳು ಮೂಲಕ ನಿರ್ವಹಿಸುತ್ತದೆ. ಏಜೆಂಟ್ ಸಂದೇಶ ಇತಿಹಾಸ (ಬಳಕೆದಾರ ವಿನಂತಿಗಳು, ಸಾಧನ ಕರೆ ಹಾಗೂ ಅವುಗಳ ಫಲಿತಾಂಶ) ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ, ಹೀಗಾಗಿ ಪ್ರತಿಯೊಂದು ತಿರುಗುಹುಡಿ ಹಿಂದಿನದ ಮೇಲೆ ನಿರ್ಮಾಣವಾಗುತ್ತದೆ. ಥ್ರೆಡ್‌ಗಳನ್ನು ಸಂರಕ್ಷಿಸಬಹುದು, ಇದರಿಂದ ಸಂಭಾಷಣೆಯು ಸ್ಥಗಿತ ಮಾಡಿ ನಂತರ ಮುನ್ನಡೆಸಬಹುದು.
ಸಾಧನಗಳು - ನೀವೆ ಏಜೆಂಟ್‌ಗೆ ಸಾಧನಗಳನ್ನು ಪೈಥಾನ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಪಾಸು ಮಾಡುವ ಮೂಲಕ ನೀಡುತ್ತೀರಿ. ಟೈಪ್-ಅನುಕೂಲಿತ ಪರಾಮಿತಿಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ಕೆಮ್ ಆಗಿ ಪರಿರೂಪಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಮಾದರಿ ಕ್ರಮವನ್ನು ಬಲ್ಲದು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ/ಯಾವಾಗ ಕರೆಯಬೇಕೆಂದು ತಿಳಿದುಕೊಳ್ಳುತ್ತದೆ (ಫಂಕ್ಷನ್ ಕರೆ). ಫ್ರೇಮ್‌ವರ್ಕ್ ಮಾದರಿ ಸ_context_ ಪ್ರೋಟೋಕಾಲ್ (MCP) ಸರ್ವರ್‌ಗಳು ಮತ್ತು ಕೋಡ್ ಇಂಟರ್ಪ್ರೀಟರ್‌ನಂತಹ ಅತಿಥಿ ಸಾಧನಗಳನ್ನು ಸಹ ಬೆಂಬಲಿಸುತ್ತದೆ.
ಇಲ್ಲಿದೆ ಕುಜಕ ತಯಾರಿಸಿದ ಸಾಧನದೊಂದಿಗೆ ಏಜೆಂಟ್ ಉದಾಹರಣೆ:
import asyncio
from typing import Annotated
from pydantic import Field
from agent_framework import Agent
from agent_framework.openai import OpenAIChatClient
def get_weather(
location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
"""Get the weather for a given location."""
return f"The weather in {location} is sunny with a high of 22°C."
async def main():
agent = Agent(
client=OpenAIChatClient(),
instructions="You are a helpful assistant that can answer weather questions.",
tools=[get_weather],
)
response = await agent.run("What's the weather in Amsterdam?")
print(response)
asyncio.run(main())ಮೈಕ್ರೊಸಾಫ್ಟ್ ಫೌಂಡ್ರಿಯಲ್ಲಿ ಅಜೂರ್ ಓಪನ್‌ಎಐ ಸಂಪರ್ಕಿಸಲು, ನಿಮ್ಮ ಎಂಡ್ಪಾಯಿಂಟ್ ಮತ್ತು ವಿವರಗಳನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಪಾಸು ಮಾಡಿ:
from azure.identity.aio import AzureCliCredential
from agent_framework.openai import OpenAIChatClient
client = OpenAIChatClient(
model="my-gpt-5-mini-deployment",
azure_endpoint="https://my-resource.openai.azure.com",
credential=AzureCliCredential(),
)ಫ್ರೇಮ್‌ವರ್ಕ್ ನಿಜವಾಗಿಯೂ ವಿಭಿನ್ನವಾಗಿರುವುದು ಹಲವು ಏಜೆಂಟ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸಂಯೋಜಿಸುವುದರಲ್ಲಿ. ಉದಾಹರಣೆಗೆ, ನೀವು ಏಜೆಂಟ್‌ಗಳನ್ನು ಕ್ರಮವಾಗಿ ಚಲಾಯಿಸಬಹುದು (ಪ್ರತಿ ಒಂದು ಅದರ ಸ_context_ ಮುಂದಿನಗೆ ನೀಡುತ್ತದೆ) ಅಥವಾ ಹಲವಾರು ಏಜೆಂಟ್‌ಗಳಿಗೆ ಸಮಾಂತರವಾಗಿ ಹರಡುವ ಮೂಲಕ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು:
from agent_framework.orchestrations import SequentialBuilder, ConcurrentBuilder
# ಸಂವಾದ ಪ್ರಾಸಂಗಿಕತೆಯನ್ನು ಸರಪಳಿಯಲ್ಲಿ ಹಂಚಿ, ಏಜೆಂಟ್‌ಗಳನ್ನು ಕ್ರಮವಾಗಿ ಚಾಲನೆಮಾಡಿ
sequential = SequentialBuilder(participants=[researcher, writer, editor]).build()
# ಏಜೆಂಟ್‌ಗಳಿಗೆ ಸಮಾಂತರವಾಗಿ ಹಂಚಿ, ನಂತರ ಅವರ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ
concurrent = ConcurrentBuilder(participants=[analyst_a, analyst_b, analyst_c]).build()ಫ್ರೆಮ್‌వರ್ಕ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಪ್ರಾರಂಭಿಸಲು:
pip install agent-framework-core
# ಐಚ್ಛಿಕ ಏಕೀಕರಣಗಳು
pip install agent-framework-openai # OpenAI ಮತ್ತು Azure OpenAI
pip install agent-framework-foundry # ಮೈಕ್ರೋಸಾಫ್ಟ್ ಫೌಂಡ್ರೀನೀವು Microsoft Agent Framework ಸಂಗ್ರಹಾಲಯ ಮತ್ತು ಅಧಿಕೃತ ಡಾಕ್ಯುಮೆಂಟेशन ನಲ್ಲಿ ಇನ್ನಷ್ಟು ಅನ್ವೇಷಿಸಬಹುದು.
ಮುಂದಿನ ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ನಾವು ಅನ್ವೇಷಿಸುವುದು Taskweaver. ಇದನ್ನು "ಕೋಡ್-ಪ್ರಥಮ" ಏಜೆಂಟ್ ಎಂದು ತಿಳಿದುಕೊಳ್ಳುತ್ತಾರೆ ಏಕೆಂದರೆ ಇದು ಕೇವಲ strings ತಚವಿಲ್ಲದೆ ಪೈಥಾನ್‌ನ DataFrames ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಹುದು. ಇದು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಉತ್ಪಾದನಾ ಕಾರ್ಯಗಳಿಗೆ ಬಹಳ ಉಪಯುಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ ಗ್ರಾಫ್‌ಗಳು ಮತ್ತು ಚಾರ್ಟ್‌ಗಳು ನಿರ್ಮಿಸುವುದು ಅಥವಾ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಗಳನ್ನು ರಚಿಸುವುದು.
ಸಂಭಾಷಣೆಯ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸಲು TaskWeaver Planner ಎಂಬ ಕಲ್ಪನೆಯನ್ನು ಬಳಸುತ್ತದೆ. Planner LLM ಆಗಿದ್ದು ಬಳಕೆದಾರರ ವಿನಂತಿಯನ್ನು ಪಡೆದು ಇದರ ನಿಭಾಯಿಸಲು ಬೇಕಾದ ಕಾರ್ಯಗಳು mapped ಮಾಡುತ್ತದೆ.
ಕಾರ್ಯಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು Planner ಗಳು Plugins ಎಂದುವ ಸಾಧನಗಳ ಸಂಕಲನದ ಪ್ರದಾನ ಆಗಿವೆ. ಇದು ಪೈಥಾನ್ ಕ್ಲಾಸ್‌ಗಳು ಅಥವಾ ಸಾಮಾನ್ಯ ಕೋಡ್ ಇಂಟರ್ಪ್ರೀಟರ್ ಆಗಿರಬಹುದು. ಈ Plugins ಗಳನ್ನು ಇಂಬೆಡ್ಡಿಂಗ್ ಆಗಿ ಸಂಗ್ರಹಿಸುವುದರಿಂದ LLM ಗಾಗಿ ಸರಿಯಾದ Plugin ಅನ್ನು ಹುಡುಕುವುದು ಸುಲಭವಾಗಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ.
ಅನೋಮಲಿ ಡಿಟೆಕ್ಷನ್ ನಂತಹ ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸಲು Plugin ಉದಾಹರಣೆ:
class AnomalyDetectionPlugin(Plugin): def __call__(self, df: pd.DataFrame, time_col_name: str, value_col_name: str):ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸುವುದಕ್ಕೂ ಮೊದಲು ಪರಿಶೀಲನೆ ಮಾಡಲಾಗುತ್ತದೆ. Taskweaver ನಲ್ಲಿ ಮತ್ತೊಂದು ಸ_context_ ನಿರ್ವಹಣೆಯ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ experiences. ಅನುಭವಗಳ ಮೂಲಕ ಸಂಭಾಷಣೆಯ ಸ_context_ YAML ಫೈಲ್ ನಲ್ಲಿ ದೀರ್ಘಕಾಲದ ಸಂರಕ್ಷಣೆ ಸಾಧ್ಯವಾಗಿದೆ. ಇದರ ಮೂಲಕ LLM ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳಲ್ಲಿ ಹಳೆಯ ಸಂಭಾಷಣೆಗಳಿಂದ ಪಾಠ ಕಲಿಯುತ್ತಾ ಸುಧಾರಣೆ ಕಾಣಬಹುದು.
ಕೊನೆಯ ಏಜೆಂಟ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅರಿವಾಗಿರುವುದು JARVIS. JARVIS ವಿಶೇಷತೆ ಎಂದರೆ ಸಂಭಾಷಣೆಯ ಸ್ಥಿತಿ ನಿರ್ವಹಣೆ LLM ಮೂಲಕ ಮತ್ತು ಸರಂಜಾಮುಗಳು ಯಾವುದೇ ಇತರ AI ಮಾದರಿಗಳು. ಪ್ರತಿಯೊಂದು AI ಮಾದರಿ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸುವ ವಿಶಿಷ್ಟ ಮಾದರಿ ಆದಾಗ, ಉದಾಹರಣೆಗೆ ವಸ್ತು ಪತ್ತೆ, ವರ್ಣನ ಭಾಷಾಂತರ ಅಥವಾ ಚಿತ್ರ ಕ್ಯಾಪ್ಷನಿಂಗ್.
ಸಾಮಾನ್ಯ ಉದ್ದೇಶದ ಮಾದರಿ ಆಗಿರುವ LLM ಬಳಕೆದಾರ ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಿ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯ ಮತ್ತು ಯಾವುದೇ ಆರ್ಗ್ಯೂಮೆಂಟ್/ಡೇಟಾವನ್ನು ಗುರುತಿಸುತ್ತದೆ.
[{"task": "object-detection", "id": 0, "dep": [-1], "args": {"image": "e1.jpg" }}]LLM ಆ ವಿನಂತಿಯನ್ನು ವಿಶೇಷ AI ಮಾದರಿಯು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ರೀತಿಯಲ್ಲಿ ಜೇಸನ್ ಮುಂತಾದ ರೂಪವು ನೀಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, AI ಮಾದರಿ ತನ್ನ ನಿರೀಕ್ಷಣೆಯನ್ನು ಮುಕ್ತಾಯಿಸಿದ ನಂತರ LLM ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ.
ಕಾರ್ಯ ಸಂಪೂರ್ಣಗೊಳಿಸಲು ಹಲವು ಮಾದರಿಗಳನ್ನು ಬೇಕಾದರೆ ಅವುಗಳ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು LLM ವ್ಯಾಖ್ಯಾನಿಸಿ ಅವುಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಿ ಬಳಕೆದಾರನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
ಕೆಳಗಿನ ಉದಾಹರಣೆ ಬಳಕೆದಾರ ಚಿತ್ರದಲ್ಲಿ ವಸ್ತುಗಳ ವರ್ಣನೆ ಮತ್ತು ಎಣಿಕೆಯನ್ನು ಕೇಳುವ ಸಂದರ್ಭದಲ್ಲಿ ಕಾರ್ಯಗೊಳ್ಳುವ ವಿಧಾನವನ್ನು ತೋರ್ಪಡಿಸುತ್ತದೆ:
AI ಏಜೆಂಟ್‌ಗಳ ಅಧ್ಯಯನ ಮುಂದುವರಿಸಲು ನೀವು Microsoft Agent Framework ಬಳಸಿಕೊಂಡು ನಿರ್ಮಿಸಬಹುದಾದುದು:
- ಶಿಕ್ಷಣ ಸ್ಟಾರ್‌ಟಪ್ ವಿವಿಧ ವಿಭಾಗಗಳೊಂದಿಗೆ ಬಿಸಿನೆಸ್ ಸಭೆಯನ್ನು ಅನುಕರಿಸುವ ಅಪ್ಲಿಕೇಶನ್.
- LLM ಗಳಿಗೆ ವಿಭಿನ್ನ ವ್ಯಕ್ತಿತ್ವಗಳು ಮತ್ತು ಆದ್ಯತೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮಾರ್ಗದರ್ಶನ ನೀಡುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಸೃಷ್ಟಿಸಿ, ಬಳಕೆದಾರನು ಹೊಸ ಉತ್ಪನ್ನ ಆಲೋಚನೆಯನ್ನು ಪ್ರಸ್ತಾಪಿಸಲು ಸಾಧ್ಯವಾಗಲಿ.
- LLM ಪ್ರತಿ ವಿಭಾಗದಿಂದ ಅನುಸರಿಸಿದ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸಿ ಆಲೋಚನೆಯ ಹಾಗೂ ಉತ್ಪನ್ನ ಅಭಿವೃದ್ದಿಗೆ ನೆರವಾಗಲಿ.
ಈ ಪಾಠ ಮುಗಿಸಿದ ನಂತರ, ನಮ್ಮ ಜನರೇಟಿವ್ AI ಕಲಿಕೆ ಸಂಗ್ರಹ ಈಗಲೇ તપાસಿ ನಿಮ್ಮ ಜನರೇಟಿವ್ AI ಜ್ಞಾನವನ್ನು ಮತ್ತಷ್ಟು ವೃದ್ಧಿಪಡಿಸಿ!
ಅಸ್ವೀಕಾರ: ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ಅಸಡ್ಡೆಗಳು ಇರಬಹುದು. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜು ಪ್ರಾಮಾಣಿಕ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸುವ ಮೂಲಕ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಗಳ ಅಥವಾ ತಪ್ಪು ವ್ಯಾಖ್ಯಾನಗಳ ಬಗ್ಗೆ ನಾವು ಹೊಣೆಗಾರರಲ್ಲ.