Ինչպես կառուցել իրական աշխարհի AI աշխատանքային հոսքեր AutoGen-ով. քայլ առ քայլ ուղեցույց

Այսպիսով, դուք խաղում եք Large Language Models-ի հետ և սկսում եք ինտեգրել Generative AI-ն ձեր հավելվածներում: Դա ապշեցուցիչ է: Բայց եկեք իրական լինենք. LLM-ները միշտ չէ, որ իրենց պահում են այնպես, ինչպես մենք ենք ցանկանում: Նրանք նման են չար մանուկների՝ սեփական խելքով:

Դուք շուտով հասկանում եք, որ պարզ արագ շղթաները պարզապես բավարար չեն: Երբեմն մեզ ավելի շատ բան է պետք: Երբեմն մեզ անհրաժեշտ են բազմաֆունկցիոնալ աշխատանքային հոսքեր: Ահա թե որտեղ է գալիս AutoGen-ը :

Օրինակ բերենք. Պատկերացրեք, որ դուք նշումներ անելու հավելված եք պատրաստում (Ակնհայտ է, որ աշխարհում դրանք բավարար չեն: 😝): Բայց հե՜յ, մենք ուզում ենք ինչ-որ հատուկ բան անել: Մենք ուզում ենք վերցնել պարզ, չմշակված նշումը, որը մեզ տալիս է օգտատերը և այն վերածել ամբողջությամբ վերակառուցված փաստաթղթի, որը լրացվում է ամփոփումով, ընտրովի վերնագրով և առաջադրանքների ավտոմատացված ցուցակով: Եվ մենք ուզում ենք այս ամենը անել առանց քրտինքի, լավ, գոնե ձեր AI գործակալների համար:

Լավ, հիմա ես գիտեմ, թե ինչ եք մտածում. Դրան ես ասում եմ, դու ճիշտ ես։ Նշանակում է… բայց ճիշտ! Բայց մի խաբվեք աշխատանքային գործընթացի պարզությամբ: Այն հմտությունները, որոնք դուք կսովորեք այստեղ, օրինակ՝ արհեստական ինտելեկտի գործակալների հետ վարվելը, աշխատանքային հոսքի վերահսկման իրականացումը և խոսակցությունների պատմությունը կառավարելը, կօգնեն ձեզ բարձրացնել ձեր AI խաղը հաջորդ մակարդակ:

Ուրեմն կապվեք, որովհետև մենք սովորելու ենք, թե ինչպես ստեղծել AI աշխատանքային հոսքեր՝ օգտագործելով AutoGen-ը:

Նախքան սկսելը, նկատի ունեցեք, որ GitHub- ում կարող եք գտնել հղում դեպի բոլոր սկզբնաղբյուրները:

Պատվերով աշխատանքային հոսքերի կառուցում

Սկսենք առաջին օգտագործման դեպքից՝ «Նշման համար ամփոփագրի ստեղծում, որին հաջորդում է պայմանական վերնագիր»: Արդար լինելու համար, մենք իրականում այստեղ գործակալներ օգտագործելու կարիք չունենք: Բայց հե՜յ, մենք պետք է ինչ-որ տեղից սկսենք ճիշտ?

Քայլ 1. Մեր բազայի LLM կոնֆիգուրացիայի ստեղծում

Գործակալական շրջանակները, ինչպիսիք են AutoGen-ը, միշտ պահանջում են մեզնից կարգավորել մոդելի պարամետրերը: Մենք խոսում ենք օգտագործվող մոդելի և հետադարձ մոդելի, ջերմաստիճանի և նույնիսկ այնպիսի պարամետրերի մասին, ինչպիսիք են ժամանակի դադարը և քեշավորումը: AutoGen-ի դեպքում այդ պարամետրը նման է հետևյալին.

 # build the gpt_configuration object base_llm_config = { "config_list": [ { "model": "Llama-3-8B-Instruct", "api_key": os.getenv("OPENAI_API_KEY"), "base_url": os.getenv("OPENAI_API_URL"), } ], "temperature": 0.0, "cache_seed": None, "timeout": 600, }

Ինչպես տեսնում եք, ես բաց կոդով AI-ի հսկայական երկրպագու եմ և երդվում եմ Llama 3-ով: Դուք կարող եք ստիպել AutoGen-ին մատնանշել OpenAI-ի հետ համատեղելի ցանկացած եզրակացության սերվեր ՝ պարզապես կարգավորելով api_key և base_url արժեքները: Այսպիսով, ազատ զգալ օգտագործեք Groq, Together.ai կամ նույնիսկ vLLM՝ ձեր մոդելը տեղայնորեն հյուրընկալելու համար: Ես օգտագործում եմ Inferix-ը :

Դա իսկապես այնքան հեշտ է:

Ինձ հետաքրքիր է! Ձեզ կհետաքրքրի՞ բաց կոդով AI հոստինգի նմանատիպ ուղեցույց: Տեղեկացրեք ինձ մեկնաբանություններում:

Քայլ 2. Մեր գործակալների ստեղծում

AutoGen-ում խոսակցական գործակալների սկզբնավորումը բավականին պարզ է. պարզապես մատակարարեք LLM-ի հիմնական կազմաձևը համակարգի հաղորդագրության հետ միասին, և դուք պատրաստ եք գնալ:

 import autogen def get_note_summarizer(base_llm_config: dict): # A system message to define the role and job of our agent system_message = """You are a helpful AI assistant. The user will provide you a note. Generate a summary describing what the note is about. The summary must follow the provided "RULES". "RULES": - The summary should be not more than 3 short sentences. - Don't use bullet points. - The summary should be short and concise. - Identify and retain any "catchy" or memorable phrases from the original text - Identify and correct all grammatical errors. - Output the summary and nothing else.""" # Create and return our assistant agent return autogen.AssistantAgent( name="Note_Summarizer", # Lets give our agent a nice name llm_config=base_llm_config, # This is where we pass the llm configuration system_message=system_message, ) def get_title_generator(base_llm_config: dict): # A system message to define the role and job of our agent system_message = """You are a helpful AI assistant. The user will provide you a note along with a summary. Generate a title based on the user's input. The title must be witty and easy to read. The title should accurate present what the note is about. The title must strictly be less than 10 words. Make sure you keep the title short. Make sure you print the title and nothing else. """ # Create and return our assistant agent return autogen.AssistantAgent( name="Title_Generator", llm_config=base_llm_config, system_message=system_message, )

Գործակալների ստեղծման ամենակարևոր մասը system_message ն է: Մի պահ նայեք system_message ին, որը ես օգտագործել եմ իմ գործակալները կարգավորելու համար:

Կարևոր է հիշել, որ AI գործակալների աշխատանքը AutoGen-ում զրույցին մասնակցելն է: Այն, թե ինչպես են նրանք մեկնաբանում և առաջ տանում խոսակցությունը, ամբողջովին կախված է այն system_message ից, որով նրանք կազմաձևված են: Սա այն վայրերից մեկն է, որտեղ դուք որոշ ժամանակ կծախսեք ամեն ինչ ճիշտ կարգավորելու համար:

Մեզ ևս մեկ գործակալ է պետք։ Գործակալ, որը պետք է որպես վստահված անձ հանդես գա մեր մարդկանց համար: Գործակալ, որը կարող է սկսել զրույցը «նշմամբ» որպես սկզբնական հուշում:

 def get_user(): # A system message to define the role and job of our agent system_message = "A human admin. Supplies the initial prompt and nothing else." # Create and return our user agent return autogen.UserProxyAgent( name="Admin", system_message=system_message, human_input_mode="NEVER", # We don't want interrupts for human-in-loop scenarios code_execution_config=False, # We definitely don't want AI executing code. default_auto_reply=None, )

Այստեղ ոչ մի շքեղ բան չի կատարվում: Պարզապես նշեք, որ ես default_auto_reply պարամետրը սահմանել եմ None : Դա կարևոր է: Սահմանելով սա ոչ մեկին, համոզվեք, որ խոսակցությունն ավարտվում է, երբ օգտվողի գործակալին հաղորդագրություն է ուղարկվում:

Օպ, ես բոլորովին մոռացել էի ստեղծել այդ գործակալները: Եկեք դա անենք շատ արագ:

 # Create our agents user = get_user() note_summarizer = get_note_summarizer(base_llm_config) title_generator = get_title_generator(base_llm_config)

Քայլ 3. Գործակալի համակարգման կարգավորում՝ օգտագործելով GroupChat

Փազլի վերջին մասը մեր գործակալներին համակարգելու ստիպելն է: Մենք պետք է որոշենք նրանց մասնակցության հաջորդականությունը և որոշենք, թե որ գործակալները պետք է լինեն:

Լավ, դա ավելի քան մեկ կտոր է: Բայց դուք հասկանում եք կետը: 🙈

Հնարավոր լուծումներից մեկը կլինի թույլ տալ, որ AI-ն պարզի Գործակալների մասնակցության հաջորդականությունը: Սա վատ գաղափար չէ։ Իրականում, սա իմ հիմնական տարբերակն է, երբ գործ ունենք բարդ խնդիրների հետ, որտեղ աշխատանքային հոսքի բնույթը դինամիկ է:

Այնուամենայնիվ, այս մոտեցումն ունի իր թերությունները. Իրականությունը կրկին հարվածում է. Այս որոշումների կայացման համար պատասխանատու գործակալը հաճախ մեծ մոդելի կարիք ունի, ինչը հանգեցնում է ավելի մեծ հետաձգումների և ծախսերի: Բացի այդ, վտանգ կա, որ այն կարող է սխալ որոշումներ կայացնել:

Դետերմինիստական աշխատանքային հոսքերի համար, որտեղ մենք ժամանակից շուտ գիտենք քայլերի հաջորդականությունը, ես սիրում եմ բռնել սանձը և ինքս ղեկավարել նավը: Բարեբախտաբար, AutoGen-ն աջակցում է այս օգտագործման դեպքին մի հարմար գործառույթով, որը կոչվում է GroupChat :

 from autogen import GroupChatManager from autogen.agentchat.groupchat import GroupChat from autogen.agentchat.agent import Agent def get_group_chat(agents, generate_title: bool = False): # Define the function which decides the agent selection order def speaker_selection_method(last_speaker: Agent, group_chat: GroupChat): # The admin will always forward the note to the summarizer if last_speaker.name == "Admin": return group_chat.agent_by_name("Note_Summarizer") # Forward the note to the title generator if the user wants a title if last_speaker.name == "Note_Summarizer" and generate_title: return group_chat.agent_by_name("Title_Generator") # Handle the default case - exit return None return GroupChat( agents=agents, messages=[], max_round=3, # There will only be 3 turns in this group chat. The group chat will exit automatically post that. speaker_selection_method=speaker_selection_method, )

Պատկերացրեք GroupChat որպես WhatsApp խումբ, որտեղ բոլոր գործակալները կարող են զրուցել և համագործակցել: Այս կարգավորումը թույլ է տալիս գործակալներին հիմնվել միմյանց աշխատանքի վրա: GroupChat դասը և GroupChatManager կոչվող ուղեկից դասը գործում են խմբի ադմինիստրատորների պես՝ հետևելով յուրաքանչյուր գործակալի ուղարկած բոլոր հաղորդագրություններին՝ ապահովելու համար, որ բոլորը մնան զրույցի պատմության հետ կապված:

Վերոնշյալ կոդի հատվածում մենք ստեղծել ենք GroupChat հատուկ speaker_selection_method ով: speaker_selection_method ը թույլ է տալիս մեզ հստակեցնել մեր հատուկ աշխատանքային հոսքը: Ահա նույնի տեսողական ներկայացումը:

Քանի որ speaker_selection_method , ըստ էության, Python ֆունկցիա է, մենք կարող ենք անել այն, ինչ ուզում ենք դրա հետ: Սա օգնում է մեզ ստեղծել իսկապես հզոր աշխատանքային հոսքեր: Օրինակ, մենք կարող ենք.

• Զուգավորեք գործակալներին՝ միմյանց աշխատանքը ստուգելու համար:
• Ներգրավեք «Troubleshooter» գործակալին, եթե նախորդ գործակալներից որևէ մեկը սխալ է դուրս բերել:
• Գործարկեք վեբ-կեռիկներ արտաքին համակարգերում՝ նրանց տեղեկացնելու կատարված առաջընթացի մասին:

Պատկերացրեք հնարավորությունները։ 😜

Քայլ 4. Ամեն ինչ կարգավորելը և զրույցը սկսելը

Վերջին քայլը GroupChat ի օրինակ ստեղծելն է, այն փաթաթելով GroupChatManager ում և սկսել զրույցը:

 # Create our group chat groupchat = get_group_chat([user, note_summarizer, title_generator], generate_title=True) manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=base_llm_config) # Start the chat user.initiate_chat( manager, clear_history=True, message=note, )

Նշում. օգտատերը զրուցում է GroupChatManager ի հետ , այլ ոչ թե առանձին գործակալների: Պատճառ չունի, թե որ գործակալները կմիանան զրույցին՝ վերջնական պատասխան տալու համար: Վախկոտ, չէ՞:

Արդյունքը նման կլինի հետևյալին.

 Admin (to chat_manager): Note: Convo with editor: - discuss titles and thumbnails - discuss video editing tips tracker - Zeeshan presents the tracker - what trick helps with what - he decidedls if we can experiment with something new - make sure all all videos since how config management works in k8s are backed u - make list of YouTube thumbnail templates - make list of YouTube idea generation limits -------------------------------------------------------------------------------- Next speaker: Note_Summarizer Note_Summarizer (to chat_manager): The note is about a conversation with an editor regarding video production. They discussed titles and thumbnails, as well as a video editing tips tracker presented by Zeeshan, which highlights tricks for specific tasks. Additionally, they ensured that all videos on Kubernetes configuration management are backed up and created lists of YouTube thumbnail templates and idea generation limits. -------------------------------------------------------------------------------- Next speaker: Title_Generator Title_Generator (to chat_manager): "Video Production Chat: Titles, Thumbnails, and Editing Tips" --------------------------------------------------------------------------------

Վերահսկում է խոսակցությունը

Հաջորդը, մենք կանդրադառնանք վերջնական օգտագործման դեպքին՝ վերցնելով տրված «նշում», վերակազմավորելով այն ավելի լավ պարզության համար և այնուհետև ստեղծելով առաջադրանքների ցուցակ օգտագործողի համար:

Ահա թե ինչպես ենք մենք պատրաստվում գնալ դրան.

Մենք կսկսենք բացահայտելով գրառման մեջ ընդգրկված թեմաների ցանկը: Այս ցանկը ողջ գործընթացի շարժիչ ուժն է: Այն սահմանում է վերափոխված գրառման բաժինները և որոշում մեր ստեղծած առաջադրանքների մանրամասնության մակարդակը:

Միայն մեկ փոքր խնդիր կա. Paraphrazer և Task_Creator գործակալը իրականում չեն հետաքրքրվում միմյանց արդյունքի վրա: Նրանք մտածում են միայն Topic_Analyzer ի արդյունքի մասին:

Այսպիսով, մեզ պետք է միջոց, որպեսզի այս գործակալների պատասխանները չխեղաթյուրեն խոսակցությունների պատմությունը, այլապես լիակատար քաոս կլինի: Մենք արդեն վերահսկել ենք աշխատանքային ընթացքը. հիմա, ժամանակն է լինել նաև զրույցի պատմության ղեկավարը: 😎

Քայլ 1. Գործակալների ստեղծում

Առաջին հերթին մենք պետք է ստեղծենք մեր գործակալները: Ես չեմ պատրաստվում ձանձրացնել ձեզ մանրամասներով, ուստի ահա կոդը.

 def get_topic_analyzer(base_llm_config: dict): # A system message to define the role and job of our agent system_message = """You are a helpful AI assistant. The user will provide you a note. Generate a list of topics discussed in that note. The output must obey the following "RULES": "RULES": - Output should only contain the important topics from the note. - There must be atleast one topic in output. - Don't reuse the same text from user's note. - Don't have more than 10 topics in output.""" # Create and return our assistant agent return autogen.AssistantAgent( name="Topic_Analyzer", llm_config=base_llm_config, system_message=system_message, ) def get_paraphrazer(base_llm_config: dict): # A system message to define the role and job of our agent system_message = """You are a helpful AI content editor. The user will provide you a note along with a summary. Rewrite that note and make sure you cover everything in the note. Do not include the title. The output must obey the following "RULES": "RULES": - Output must be in markdown. - Make sure you use each points provided in summary as headers. - Each header must start with `##`. - Headers are not bullet points. - Each header can optionally have a list of bullet points. Don't put bullet points if the header has no content. - Strictly use "-" to start bullet points. - Optionally make an additional header named "Addional Info" to cover points not included in the summary. Use "Addional Info" header for unclassified points. - Identify and correct spelling & grammatical mistakes.""" # Create and return our assistant agent return autogen.AssistantAgent( name="Paraphrazer", llm_config=base_llm_config, system_message=system_message, ) def get_tasks_creator(base_llm_config: dict): # A system message to define the role and job of our agent system_message = """You are a helpful AI personal assistant. The user will provide you a note along with a summary. Identify each task the user has to do as next steps. Make sure to cover all the action items mentioned in the note. The output must obey the following "RULES": "RULES": - Output must be an YAML object with a field named tasks. - Make sure each task object contains fields title and description. - Extract the title based on the tasks the user has to do as next steps. - Description will be in markdown format. Feel free to include additional formatting and numbered lists. - Strictly use "-" or "dashes" to start bullet points in the description field. - Output empty tasks array if no tasks were found. - Identify and correct spelling & grammatical mistakes. - Identify and fix any errors in the YAML object. - Output should strictly be in YAML with no ``` or any additional text.""" # Create and return our assistant agent return autogen.AssistantAgent( name="Task_Creator", llm_config=base_llm_config, system_message=system_message, )

Քայլ 2. Ստեղծեք անհատական GroupChat

Ցավոք սրտի. AutoGen-ը մեզ թույլ չի տալիս ուղղակիորեն վերահսկել խոսակցությունների պատմությունը: Այսպիսով, մենք պետք է առաջ գնանք և ընդլայնենք GroupChat դասը մեր հատուկ ներդրմամբ:

 class CustomGroupChat(GroupChat): def __init__(self, agents): super().__init__(agents, messages=[], max_round=4) # This function get's invoked whenever we want to append a message to the conversation history. def append(self, message: Dict, speaker: Agent): # We want to skip messages from the Paraphrazer and the Task_Creator if speaker.name != "Paraphrazer" and speaker.name != "Task_Creator": super().append(message, speaker) # The `speaker_selection_method` now becomes a function we will override from the base class def select_speaker(self, last_speaker: Agent, selector: AssistantAgent): if last_speaker.name == "Admin": return self.agent_by_name("Topic_Analyzer") if last_speaker.name == "Topic_Analyzer": return self.agent_by_name("Paraphrazer") if last_speaker.name == "Paraphrazer": return self.agent_by_name("Task_Creator") # Return the user agent by default return self.agent_by_name("Admin")

Մենք անտեսում ենք երկու գործառույթ բազային GroupChat դասից.

• append - Սա վերահսկում է, թե ինչ հաղորդագրություններ են ավելացվում խոսակցությունների պատմությանը:
• select_speaker - Սա speaker_selection_method ը նշելու ևս մեկ միջոց է:

Բայց սպասեք, ավելի խորանալով AutoGen-ի կոդի մեջ, ես հասկացա, որ GroupChatManager ը ստիպում է յուրաքանչյուր գործակալին պահպանել խոսակցության պատմությունը նույնպես: Ինձ մի հարցրեք, թե ինչու: Ես իսկապես չգիտեմ!

Այսպիսով, եկեք ընդլայնենք նաև GroupChatManager ը՝ դա շտկելու համար.

 class CustomGroupChatManager(GroupChatManager): def __init__(self, groupchat, llm_config): super().__init__(groupchat=groupchat, llm_config=llm_config) # Don't forget to register your reply functions self.register_reply(Agent, CustomGroupChatManager.run_chat, config=groupchat, reset_config=GroupChat.reset) def run_chat( self, messages: Optional[List[Dict]] = None, sender: Optional[Agent] = None, config: Optional[GroupChat] = None, ) -> Union[str, Dict, None]: """Run a group chat.""" if messages is None: messages = self._oai_messages[sender] message = messages[-1] speaker = sender groupchat = config for i in range(groupchat.max_round): # set the name to speaker's name if the role is not function if message["role"] != "function": message["name"] = speaker.name groupchat.append(message, speaker) if self._is_termination_msg(message): # The conversation is over break # We do not want each agent to maintain their own conversation history history # broadcast the message to all agents except the speaker # for agent in groupchat.agents: # if agent != speaker: # self.send(message, agent, request_reply=False, silent=True) # Pro Tip: Feel free to "send" messages to the user agent if you want to access the messages outside of autogen for agent in groupchat.agents: if agent.name == "Admin": self.send(message, agent, request_reply=False, silent=True) if i == groupchat.max_round - 1: # the last round break try: # select the next speaker speaker = groupchat.select_speaker(speaker, self) # let the speaker speak # We'll now have to pass their entire conversation of messages on generate_reply # Commented OG code: reply = speaker.generate_reply(sender=self) reply = speaker.generate_reply(sender=self, messages=groupchat.messages) except KeyboardInterrupt: # let the admin agent speak if interrupted if groupchat.admin_name in groupchat.agent_names: # admin agent is one of the participants speaker = groupchat.agent_by_name(groupchat.admin_name) # We'll now have to pass their entire conversation of messages on generate_reply # Commented OG code: reply = speaker.generate_reply(sender=self) reply = speaker.generate_reply(sender=self, messages=groupchat.messages) else: # admin agent is not found in the participants raise if reply is None: break # The speaker sends the message without requesting a reply speaker.send(reply, self, request_reply=False) message = self.last_message(speaker) return True, None

Ես մի քանի փոքր փոփոխություններ եմ կատարել սկզբնական իրականացման մեջ: Դուք պետք է կարողանաք հետևել մեկնաբանություններին ավելին իմանալու համար:

Բայց կա մի բան, որը ես իսկապես ուզում եմ ընդգծել. Դուք կարող եք անտեսել GroupChatManager-ի «run_chat» մեթոդը՝ միացնել ձեր աշխատանքային հոսքի շարժիչը, ինչպիսին է Apache Airflow-ը կամ Temporal-ը: Բաշխված համակարգերի մասնագետները հստակ գիտեն, թե որքան հզոր է այս հնարավորությունը:

Քայլ 3. Ամեն ինչ կարգավորելը և զրույցը սկսելը

Մենք այս ամենը կարգավորեցինք նախորդ օրինակի նման և դիտեցինք այս մանկական մռնչյունը: 🐱

 # Create our agents user = get_user() topic_analyzer = get_topic_analyzer(base_llm_config) paraphrazer = get_paraphrazer(base_llm_config) task_creator = get_tasks_creator(base_llm_config) # Create our group chat groupchat = CustomGroupChat(agents=[user, topic_analyzer, paraphrazer, task_creator]) manager = CustomGroupChatManager(groupchat=groupchat, llm_config=base_llm_config) # Start the chat user.initiate_chat( manager, clear_history=True, message=note, ) # Lets print the count of tasks just for fun chat_messages = user.chat_messages.get(manager) if chat_messages is not None: for message in chat_messages: if message.get("name") == "Task_Creator": taskList = yaml.safe_load(message.get("content")) # type: ignore l = len(taskList.get("tasks")) print(f"Got {l} tasks from Task_Creator.")

Արդյունքը նման կլինի հետևյալին.

 Admin (to chat_manager): Note: Convo with editor: - discuss titles and thumbnails - discuss video editing tips tracker - Zeeshan presents the tracker - what trick helps with what - he decidedls if we can experiment with something new - make sure all all videos since how config management works in k8s are backed u - make list of YouTube thumbnail templates - make list of YouTube idea generation limits -------------------------------------------------------------------------------- Topic_Analyzer (to chat_manager): Here is the list of topics discussed in the note: 1. Titles 2. Thumbnails 3. Video editing tips 4. Config management in Kubernetes (k8s) 5. YouTube thumbnail templates 6. YouTube idea generation limits -------------------------------------------------------------------------------- Paraphrazer (to chat_manager): Here is the rewritten note in markdown format: ## Titles - Discuss titles and thumbnails with the editor ## Video Editing Tips Tracker ### Zeeshan presents the tracker - What trick helps with what - He decides if we can experiment with something new ## Config Management in Kubernetes (k8s) - Make sure all videos since how config management works in k8s are backed up ## YouTube Thumbnail Templates - Make a list of YouTube thumbnail templates ## YouTube Idea Generation Limits - Make a list of YouTube idea generation limits ## Additional Info - Discuss video editing tips tracker with Zeeshan - Present the tracker and decide if we can experiment with something new -------------------------------------------------------------------------------- Task_Creator (to chat_manager): tasks: - title: Discuss Titles and Thumbnails description: >- - Discuss titles and thumbnails with the editor This task involves having a conversation with the editor to discuss the titles and thumbnails for the videos. - title: Discuss Video Editing Tips Tracker description: >- - Zeeshan presents the tracker - Discuss what trick helps with what - Decide if we can experiment with something new This task involves discussing the video editing tips tracker presented by Zeeshan, understanding what tricks help with what, and deciding if it's possible to experiment with something new. - title: Back up All Videos Since How Config Management Works in k8s description: >- - Make sure all videos since how config management works in k8s are backed up This task involves ensuring that all videos related to config management in Kubernetes (k8s) are backed up. - title: Create List of YouTube Thumbnail Templates description: >- - Make list of YouTube thumbnail templates This task involves creating a list of YouTube thumbnail templates. - title: Create List of YouTube Idea Generation Limits description: >- - Make list of YouTube idea generation limits This task involves creating a list of YouTube idea generation limits. -------------------------------------------------------------------------------- Got 5 tasks from Task_Creator.

Այո։ Բարի գալուստ AI-ի դար, որը մեզ տալիս է հումանիստներին աշխատանք: (Որտե՞ղ է այդ ամենը սխալվել: 🤷‍♂️)

Եզրակացություն

AI-ի վրա հիմնված Generative հավելվածներ ստեղծելը դժվար է: Բայց դա կարելի է անել ճիշտ գործիքներով: Ամփոփելու համար.

• AI գործակալները բացում են բարդ խնդիրները որպես խոսակցություններ մոդելավորելու այս զարմանալի հնարավորությունը:
• Եթե դա ճիշտ արվի, այն կարող է օգնել մեր AI հավելվածները դարձնել ավելի վճռական և հուսալի :
• Գործիքները, ինչպիսին է AutoGen-ը, մեզ տրամադրում են պարզ աբստրակցիաներով շրջանակ՝ AI գործակալներ ստեղծելու համար:

Որպես հաջորդ քայլեր, դուք կարող եք ստուգել հետևյալ ռեսուրսները՝ ավելի խորը սուզվելու AI գործակալների աշխարհ.

• GitHub ռեպո՝ այն ինքներդ փորձելու համար (Կոդ)
• Խոսակցական օրինաչափությունների իրականացում AutoGen-ի միջոցով (Փաստաթղթեր)