ตัวแทน LLM ผู้เชี่ยวชาญ:ทำให้เวิร์กโฟลว์ที่ซับซ้อนเป็นอัตโนมัติด้วย LangGraph &CrewAI – คู่มือโอเพ่นซอร์ส

เคยรู้สึกว่าเครื่องมือ AI ของคุณค่อนข้าง...ก็เฉยๆ บ้างไหม? เหมือนพวกเขาแค่นั่งอยู่ที่นั่นรอคำสั่งต่อไปของคุณเหรอ? ลองนึกภาพว่าพวกเขาสามารถริเริ่ม ทำลายปัญหาใหญ่ๆ และแม้แต่ทำงานร่วมกันเพื่อทำสิ่งต่างๆ ให้สำเร็จได้

นั่นคือสิ่งที่ตัวแทน LLM นำมาไว้บนโต๊ะ พวกเขากำลังเปลี่ยนแปลงวิธีที่เราทำให้งานที่ซับซ้อนเป็นอัตโนมัติ และสามารถช่วยทำให้แนวคิด AI ของเราเป็นจริงได้ในรูปแบบใหม่

ในบทความนี้ เราจะสำรวจว่าตัวแทน LLM คืออะไร ทำงานอย่างไร และคุณสามารถสร้างของคุณเองได้อย่างไรโดยใช้เฟรมเวิร์กโอเพ่นซอร์สที่ยอดเยี่ยม

สิ่งที่เราจะกล่าวถึง:

1. สถานะปัจจุบันของตัวแทน LLM

   • จากแชทบอทไปจนถึงตัวแทนอัตโนมัติ

   • วันนี้ตัวแทนทำอะไรได้บ้าง

   • มีอะไรให้สร้างบ้าง

   • เหตุใดตอนนี้จึงเป็นเวลาที่ดีที่สุดในการเรียนรู้

2. ตัวแทน LLM คืออะไร และเหตุใดจึงเป็นเรื่องใหญ่

   • LLM คืออะไร?

   • แล้วตัวแทน LLM คืออะไร

   • ทำไมเรื่องนี้ถึงสำคัญ?

3. การเพิ่มขึ้นของกรอบการทำงานของเอเจนต์โอเพ่นซอร์ส

   • กรอบงานตัวแทนโอเพ่นซอร์สยอดนิยม

   • เครื่องมือเหล่านี้เปิดใช้งานอะไรได้บ้าง

   • เหตุใดจึงต้องใช้เฟรมเวิร์กแทนที่จะสร้างตั้งแต่ต้น

4. แนวคิดหลักเบื้องหลังการออกแบบตัวแทน

   • ตัวแทนวนซ้ำ

   • องค์ประกอบสำคัญของตัวแทน

   • การทำงานร่วมกันหลายตัวแทน

5. โครงการ:ทำให้กำหนดการรายวันของคุณจากอีเมลเป็นอัตโนมัติ

   • สิ่งที่เรากำลังดำเนินการโดยอัตโนมัติ

   • ขั้นตอนที่ 1:ติดตั้งเครื่องมือที่จำเป็น

   • ขั้นตอนที่ 2:กำหนดงาน

   • ขั้นตอนที่ 3:สร้างเวิร์กโฟลว์ด้วย LangGraph

6. การทำงานร่วมกันหลายตัวแทนกับ CrewAI

   • CrewAI คืออะไร

   • บทบาทตัวอย่างสำหรับงานสรุปอีเมล

   • ตัวอย่างรหัส CrewAI

7. จริงๆ แล้วเกิดอะไรขึ้นระหว่างการประหารชีวิต

8. ตัวแทน LLM ปลอดภัยหรือไม่? สิ่งที่ควรรู้เกี่ยวกับความปลอดภัยและความเป็นส่วนตัว

9. การแก้ไขปัญหาและเคล็ดลับ

10. สำรวจการทำงานอัตโนมัติรายวันเพิ่มเติม

11. อะไรต่อไปในเทคโนโลยีตัวแทน

12. สรุปสุดท้าย

สถานะปัจจุบันของตัวแทน LLM

เจ้าหน้าที่ LLM เป็นหนึ่งในการพัฒนา AI ที่น่าตื่นเต้นที่สุดในขณะนี้ พวกเขากำลังช่วยทำให้งานจริงเป็นอัตโนมัติอยู่แล้ว แต่ก็ยังมีการพัฒนาอยู่เช่นกัน แล้ววันนี้เราอยู่ที่ไหน

จาก Chatbot สู่ตัวแทนอัตโนมัติ

โมเดลภาษาขนาดใหญ่ (LLM) เช่น GPT-4, Claude, Gemini และ LLaMA ได้พัฒนาจากแชทบอทธรรมดาไปสู่กลไกการให้เหตุผลที่มีความสามารถอย่างน่าประหลาดใจ พวกเขาเปลี่ยนจากการตอบคำถามเล็กๆ น้อยๆ และสร้างเรียงความไปจนถึงการใช้เหตุผลที่ซับซ้อน ทำตามคำแนะนำหลายขั้นตอน และการโต้ตอบกับเครื่องมือต่างๆ เช่น การค้นหาเว็บและล่ามโค้ด

แต่สิ่งสำคัญคือ โมเดลเหล่านี้มีปฏิกิริยาโต้ตอบ . พวกเขารออินพุตและให้เอาต์พุต พวกเขาไม่ได้เก็บความทรงจำระหว่างงาน วางแผนล่วงหน้า หรือบรรลุเป้าหมายด้วยตัวเอง นั่นคือสิ่งที่ ตัวแทน LLM เข้ามาสิ พวกเขาเชื่อมช่องว่างนี้ด้วยการเพิ่มโครงสร้าง หน่วยความจำ และความเป็นอิสระ

ตัวแทนสามารถทำอะไรได้บ้างในวันนี้

ขณะนี้ตัวแทน LLM ถูกใช้สำหรับ:

• การสรุปอีเมลหรือเอกสาร

• การวางแผนตารางเวลารายวัน

• การรันสคริปต์ DevOps

• ค้นหา API หรือเครื่องมือเพื่อหาคำตอบ

• การทำงานร่วมกันเป็น "ทีม" ขนาดเล็กเพื่อทำงานที่ซับซ้อนให้สำเร็จ

แต่พวกเขายังไม่สมบูรณ์แบบ ตัวแทนยังคงสามารถ:

• ติดอยู่ในลูป

• เข้าใจผิดเป้าหมาย

• ต้องการคำแนะนำโดยละเอียดและราวกั้น

นั่นเป็นเพราะเทคโนโลยีนี้ยังอยู่ในช่วงเริ่มต้น กรอบงานเริ่มดีขึ้นอย่างรวดเร็ว แต่ความน่าเชื่อถือและหน่วยความจำยังอยู่ในระหว่างดำเนินการ ดังนั้นโปรดจำไว้เสมอเมื่อคุณทำการทดลอง

เหตุใดตอนนี้จึงเป็นเวลาที่ดีที่สุดในการเรียนรู้

ความจริงก็คือ:เรายังเร็วอยู่ แต่ก็ไม่เกินไป เช้า

นี่เป็นเวลาที่เหมาะที่สุดในการเริ่มทดลองกับตัวแทน:

• เครื่องมือมีความสมบูรณ์เพียงพอที่จะสร้างโครงการจริงได้

• ชุมชนมีการเติบโตอย่างรวดเร็ว

• และคุณไม่จำเป็นต้องเป็นผู้เชี่ยวชาญด้าน AI เพียงแค่คุ้นเคยกับ Python

ตัวแทน LLM คืออะไร และเหตุใดจึงเป็นเรื่องใหญ่

ก่อนที่เราจะดำดิ่งสู่โลกที่น่าตื่นเต้นของตัวแทน เรามาพูดคุยเกี่ยวกับพื้นฐานกันอีกสักหน่อย

LLM คืออะไร

LLM หรือโมเดลภาษาขนาดใหญ่ โดยพื้นฐานแล้วคือ AI ที่เรียนรู้จากข้อความจำนวนมหาศาลจากอินเทอร์เน็ต ลองนึกถึงหนังสือ บทความ โค้ด และอื่นๆ อีกมากมาย คุณสามารถจินตนาการว่ามันเป็นเครื่องมือเติมข้อความอัตโนมัติที่ชาญฉลาดอย่างยิ่ง แต่มันทำอะไรได้มากกว่าการจบประโยคของคุณ นอกจากนี้ยังสามารถ:

• ตอบคำถามที่ยุ่งยาก

• สรุปบทความหรือเอกสารขนาดยาว

• เขียนโค้ด อีเมล หรือเรื่องราวเชิงสร้างสรรค์

• แปลภาษาได้ทันที

• แม้แต่ไขปริศนาตรรกะและมีบทสนทนาที่น่าดึงดูด

คุณคงเคยได้ยินเกี่ยวกับ ChatGPT ซึ่งขับเคลื่อนโดยโมเดล GPT ของ OpenAI LLM ยอดนิยมอื่นๆ ที่คุณอาจเจอ ได้แก่ Claude (จาก Anthropic), LLaMA (โดย Meta), Mistral และ Gemini (จาก Google)

โมเดลเหล่านี้ทำงานโดยเพียงแค่คาดเดาคำถัดไปในประโยคตามบริบท แม้ว่าจะฟังดูตรงไปตรงมา แต่เมื่อฝึกฝนด้วยคำศัพท์หลายพันล้านคำ LLM ก็มีพฤติกรรมที่ชาญฉลาดอย่างน่าประหลาดใจ เข้าใจคำสั่งของคุณ ปฏิบัติตามการให้เหตุผลทีละขั้นตอน และสร้างการตอบสนองที่สอดคล้องกันในเกือบทุกหัวข้อที่คุณสามารถจินตนาการได้

ตัวแทน LLM คืออะไร

แม้ว่า LLM จะมีพลังมหาศาล แต่โดยปกติแล้วพวกมันก็แค่โต้ตอบ – พวกเขาตอบสนองเมื่อคุณถามอะไรบางอย่างเท่านั้น ในทางกลับกัน ตัวแทน LLM เชิงรุก .

ตัวแทน LLM สามารถ:

• แบ่งงานใหญ่และซับซ้อนออกเป็นขั้นตอนเล็กๆ ที่จัดการได้

• ตัดสินใจอย่างชาญฉลาดและคิดว่าจะต้องทำอะไรต่อไป

• ใช้ "เครื่องมือ" เช่น การค้นหาเว็บ เครื่องคิดเลข หรือแม้แต่แอปอื่นๆ

• ทำงานไปสู่เป้าหมาย แม้ว่าจะต้องใช้หลายขั้นตอนหรือพยายามก็ตาม

• ร่วมทีมกับตัวแทนคนอื่นๆ เพื่อบรรลุวัตถุประสงค์ร่วมกัน

กล่าวโดยสรุป ตัวแทน LLM สามารถคิด วางแผน ดำเนินการ และปรับตัวได้

ลองนึกถึงตัวแทน LLM เหมือนกับผู้ช่วยใหม่ที่มีประสิทธิภาพสูงสุดของคุณ:คุณตั้งเป้าหมายให้กับมัน และมันจะคิดหาวิธีที่จะบรรลุเป้าหมายทั้งหมดด้วยตัวมันเอง

เหตุใดจึงสำคัญ

การเปลี่ยนแปลงจากการตอบรับเป็นการบรรลุเป้าหมายอย่างแข็งขันจะทำให้เกิดความเป็นไปได้ที่น่าตื่นเต้นมากมาย:

• การทำงานด้าน IT หรือ DevOps ที่น่าเบื่อโดยอัตโนมัติ

• การสร้างรายงานโดยละเอียดจากข้อมูลดิบ

• ช่วยเหลือคุณในโครงการวิจัยหลายขั้นตอน

• อ่านอีเมลรายวันของคุณและเน้นข้อมูลสำคัญ

• ใช้เครื่องมือภายในของคุณเพื่อดำเนินการในโลกแห่งความเป็นจริง

ต่างจากบอทตามกฎรุ่นเก่า ตัวแทน LLM สามารถให้เหตุผล ไตร่ตรอง และเรียนรู้จากความพยายามของพวกเขา ซึ่งทำให้เหมาะกับงานในโลกแห่งความเป็นจริงที่ยุ่งวุ่นวาย ต้องการความยืดหยุ่น และขึ้นอยู่กับบริบทที่เข้าใจมากขึ้น

การเพิ่มขึ้นของกรอบการทำงานของเอเจนต์โอเพ่นซอร์ส

ไม่นานมานี้ หากคุณต้องการสร้างระบบ AI ที่สามารถทำงานอัตโนมัติได้ นั่นหมายถึงการเขียนโค้ดแบบกำหนดเองจำนวนมาก การจัดการหน่วยความจำอย่างอุตสาหะ และพยายามรวมส่วนประกอบหลายสิบชิ้นเข้าด้วยกัน มันเป็นงานที่ซับซ้อน ละเอียดอ่อน และมีความเชี่ยวชาญสูง

แต่เดาอะไรล่ะ? นั่นไม่ใช่กรณีอีกต่อไป

ในปี 2024 เฟรมเวิร์กโอเพ่นซอร์สที่ยอดเยี่ยมมากมายได้เข้ามามีบทบาท เครื่องมือเหล่านี้ทำให้การสร้างตัวแทน LLM ที่ทรงพลังง่ายขึ้นอย่างมาก โดยที่คุณไม่ต้องสร้างวงล้อใหม่ทุกครั้ง

กรอบงานตัวแทนโอเพ่นซอร์สยอดนิยม

เครื่องมือเหล่านี้เปิดใช้งานอะไรบ้าง

เฟรมเวิร์กเหล่านี้ให้องค์ประกอบสำเร็จรูปแก่คุณเพื่อจัดการกับส่วนที่ยุ่งยากกว่าในการสร้างตัวแทน:

• การวางแผน – ให้ตัวแทนตัดสินใจดำเนินการต่อไป

• การใช้เครื่องมือ – เชื่อมต่อตัวแทนกับสิ่งต่างๆ เช่น ระบบไฟล์ เว็บเบราว์เซอร์ API หรือฐานข้อมูลได้อย่างง่ายดาย

• หน่วยความจำ – การจัดเก็บและการดึงข้อมูลในอดีตหรือผลลัพธ์ระดับกลางสำหรับบริบทระยะยาว

• การทำงานร่วมกันหลายตัวแทน – การจัดตั้งทีมตัวแทนที่ทำงานร่วมกันโดยมีเป้าหมายร่วมกัน

เหตุใดจึงต้องใช้กรอบงานแทนที่จะสร้างตั้งแต่ต้น

ในขณะที่คุณ ทำได้ สร้างตัวแทนแบบกำหนดเองตั้งแต่ต้นจนจบ การใช้เฟรมเวิร์กจะช่วยคุณประหยัดเวลาและความพยายามได้มหาศาล ไลบรารีเอเจนต์โอเพ่นซอร์สมาพร้อมกับ:

• การสนับสนุนในตัวสำหรับการจัดการ LLMs

• รูปแบบที่ได้รับการพิสูจน์แล้วสำหรับการวางแผนงาน การติดตามตำแหน่งที่คุณอยู่ และรับคำติชม

• บูรณาการอย่างง่ายดายกับโมเดลยอดนิยม เช่น OpenAI หรือแม้แต่โมเดลที่คุณใช้งานในเครื่อง

• ความยืดหยุ่นในการเติบโตจากตัวแทนที่เป็นประโยชน์เพียงรายเดียวไปจนถึงทั้งทีม

โดยพื้นฐานแล้ว เฟรมเวิร์กเหล่านี้ช่วยให้คุณมุ่งเน้นไปที่สิ่งที่ตัวแทนของคุณควรทำ แทนที่จะจมอยู่กับการสร้างผลงานภายในทั้งหมด นอกจากนี้ การเลือกโอเพ่นซอร์สยังช่วยให้คุณได้รับประโยชน์จากการมีส่วนร่วมของชุมชน ความโปร่งใสในวิธีการทำงาน และอิสระในการปรับแต่งให้ตรงตามความต้องการของคุณ โดยไม่ต้องผูกติดกับผู้จำหน่ายรายเดียว

แนวคิดหลักเบื้องหลังการออกแบบตัวแทน

เพื่อให้เข้าใจวิธีการทำงานของตัวแทน LLM อย่างแท้จริง การคิดว่าตัวแทนเหล่านี้เป็นระบบที่ขับเคลื่อนด้วยเป้าหมายซึ่งวนเวียนอยู่ตลอดเวลาผ่านการสังเกต การใช้เหตุผล และการดำเนินการ การวนซ้ำอย่างต่อเนื่องนี้ช่วยให้พวกเขาสามารถจัดการกับงานที่นอกเหนือไปจากคำถามและคำตอบง่ายๆ ไปสู่ระบบอัตโนมัติอย่างแท้จริง การใช้เครื่องมือ และการปรับตัวได้ทันที

เอเจนต์ลูป

เจ้าหน้าที่ LLM ส่วนใหญ่ทำงานตามแบบจำลองทางจิตที่เรียกว่า Agent Loop วงจรทีละขั้นตอนที่ทำซ้ำจนกว่างานจะเสร็จสิ้น โดยทั่วไปแล้วมันทำงานอย่างไร:

• การรับรู้: เอเจนต์เริ่มต้นด้วยการสังเกตเห็นบางสิ่งในสภาพแวดล้อมหรือรับข้อมูลใหม่ นี่อาจเป็นข้อความแจ้งของคุณ ชิ้นส่วนของข้อมูล หรือสถานะปัจจุบันของระบบ

• แผน: ขึ้นอยู่กับสิ่งที่รับรู้และเป้าหมายโดยรวม ตัวแทนตัดสินใจว่าจะทำอย่างไรต่อไป อาจแบ่งงานออกเป็นเป้าหมายย่อยเล็กๆ หรือค้นหาเครื่องมือที่ดีที่สุดสำหรับงานนั้น

• การกระทำ: ตัวแทนจึงทำหน้าที่ ซึ่งอาจหมายถึงการเรียกใช้ฟังก์ชัน การเรียกใช้ API การค้นหาเว็บ การโต้ตอบกับฐานข้อมูล หรือแม้แต่การขอความช่วยเหลือจากตัวแทนอื่น

• ไตร่ตรอง: หลังจากลงมือ เจ้าหน้าที่จะดูผลลัพธ์ว่าได้ผลไหม? ผลลัพธ์มีประโยชน์หรือไม่? ควรลองใช้แนวทางอื่นหรือไม่? จากข้อมูลนี้ ระบบจะอัปเดตแผนและดำเนินการต่อไปจนกว่างานจะเสร็จสิ้น

การวนซ้ำนี้เป็นสิ่งที่ทำให้ตัวแทนมีความไดนามิกมาก ช่วยให้พวกเขาจัดการกับงานที่เปลี่ยนแปลงตลอดเวลา เรียนรู้จากผลลัพธ์บางส่วน และแก้ไขคุณสมบัติของหลักสูตรซึ่งมีความสำคัญต่อการสร้างผู้ช่วย AI ที่มีประโยชน์อย่างแท้จริง

องค์ประกอบสำคัญของตัวแทน

เพื่อให้ทำงานได้อย่างมีประสิทธิผล ตัวแทนจึงถูกสร้างขึ้นโดยคำนึงถึงส่วนสำคัญหลายประการ:

• เครื่องมือ คือวิธีที่ตัวแทนโต้ตอบกับโลกแห่งความเป็นจริง (หรือดิจิทัล) สิ่งเหล่านี้อาจเป็นอะไรก็ได้ตั้งแต่เครื่องมือค้นหา สภาพแวดล้อมการเรียกใช้โค้ด โปรแกรมอ่านไฟล์ หรือไคลเอ็นต์ API ไปจนถึงเครื่องคำนวณแบบธรรมดาหรือสคริปต์บรรทัดคำสั่ง

• หน่วยความจำ ช่วยให้เจ้าหน้าที่จดจำสิ่งที่พวกเขาได้ทำหรือเห็นในขั้นตอนต่างๆ ซึ่งอาจรวมถึงสิ่งที่คุณเคยพูดไป ผลลัพธ์ชั่วคราว หรือการตัดสินใจที่สำคัญ เฟรมเวิร์กบางตัวมีหน่วยความจำระยะสั้น (สำหรับเซสชันเดียวเท่านั้น) ในขณะที่เฟรมเวิร์กบางตัวรองรับหน่วยความจำระยะยาวที่สามารถขยายหลายเซสชันหรือเป้าหมายได้

• สิ่งแวดล้อม หมายถึงข้อมูลภายนอกหรือบริบทของระบบที่เอเจนต์ดำเนินการภายใน Think API เอกสาร ฐานข้อมูล ไฟล์ หรืออินพุตเซ็นเซอร์ ยิ่งตัวแทนมีข้อมูลและการเข้าถึงสภาพแวดล้อมมากเท่าใด การดำเนินการที่มีความหมายก็จะยิ่งดำเนินการมากขึ้นเท่านั้น

• เป้าหมาย คือเป้าหมายสูงสุดของตัวแทน นั่นคือสิ่งที่ตัวแทนพยายามทำให้สำเร็จ เป้าหมายควรเฉพาะเจาะจงและชัดเจน เช่น "สร้างกำหนดการรายวัน" "สรุปเอกสารนี้" หรือ "แยกงานออกจากอีเมล"

การทำงานร่วมกันหลายตัวแทน

สำหรับระบบขั้นสูง คุณสามารถมีเอเจนต์หลายตัวทำงานร่วมกันเพื่อให้บรรลุเป้าหมายที่ใช้ร่วมกันได้ ตัวแทนแต่ละคนสามารถได้รับบทบาทเฉพาะเจาะจง ที่เน้นถึงความพิเศษเช่นเดียวกับผู้คนที่ทำงานเป็นทีม

ตัวอย่างเช่น:

• ตัวแทนนักวิจัย อาจได้รับมอบหมายให้รวบรวมข้อมูล

• ตัวแทนเขียนโค้ด สามารถเขียนสคริปต์ Python หรือรูทีนอัตโนมัติได้

• ตัวแทนผู้ตรวจสอบ อาจตรวจสอบผลลัพธ์และรับรองว่าทุกอย่างเรียบร้อยดี

เจ้าหน้าที่เหล่านี้สามารถสนทนากัน แบ่งปันข้อมูล และแม้แต่การอภิปรายหรือลงคะแนนเสียงในการตัดสินใจ การทำงานเป็นทีมประเภทนี้ช่วยให้ระบบ AI สามารถรับมือกับงานที่ใหญ่กว่าและซับซ้อนมากขึ้น ในขณะเดียวกันก็รักษาสิ่งต่างๆ ให้เป็นระเบียบและเป็นโมดูล

โครงการ:ทำให้กำหนดการรายวันของคุณจากอีเมลเป็นอัตโนมัติ

สิ่งที่เรากำลังดำเนินการโดยอัตโนมัติ

คิดถึงกิจวัตรยามเช้าโดยทั่วไปของคุณ:

• คุณเปิดกล่องจดหมายของคุณ

• คุณสแกนอีเมลจำนวนมากได้อย่างรวดเร็ว

• คุณพยายามมองเห็นการประชุม งาน และการช่วยเตือนที่สำคัญ

• จากนั้น คุณจึงเขียนรายการสิ่งที่ต้องทำหรือเพิ่มสิ่งต่างๆ ลงในปฏิทินด้วยตนเอง

ลองใช้ตัวแทน LLM เพื่อทำให้กระบวนการนั้นง่ายดาย ตัวแทนของเราจะ:

• อ่านรายการข้อความอีเมลของคุณ

• ดึงรายการที่ต้องคำนึงถึงเวลา เช่น การประชุมหรือกำหนดเวลาออก

• สรุปทุกอย่างให้เป็นกำหนดการรายวันที่ดีและสะอาด

ขั้นตอนที่ 1:ติดตั้งเครื่องมือที่จำเป็น

ในการเริ่มต้น คุณจะต้องมีเครื่องมือหลัก 3 อย่าง ได้แก่ Python, VSCode และคีย์ OpenAI API

1. ติดตั้ง Python 3.9 หรือสูงกว่า

รับ Python 3.9+ เวอร์ชันล่าสุดจากเว็บไซต์อย่างเป็นทางการ:https://www.python.org/downloads/

เมื่อติดตั้งแล้ว ให้ตรวจสอบอีกครั้งโดยเรียกใช้ 05 ในเทอร์มินัลของคุณ

คำสั่งนี้เพียงขอให้ระบบของคุณรายงานเวอร์ชัน Python ที่ติดตั้งอยู่ในปัจจุบัน คุณจะต้องการเห็น Python 3.9.x หรือรุ่นที่สูงกว่าเพื่อให้แน่ใจว่าเข้ากันได้กับโปรเจ็กต์ของเรา

2. ติดตั้ง VSCode (เป็นทางเลือก แต่แนะนำ)

VSCode เป็นตัวแก้ไขโค้ดที่ยอดเยี่ยมและใช้งานง่าย ซึ่งทำงานร่วมกับ Python ได้อย่างสมบูรณ์แบบ คุณสามารถดาวน์โหลดได้ที่นี่:https://code.visualstudio.com/

3. รับคีย์ OpenAI API ของคุณ

ไปที่:https://platform.openai.com

เข้าสู่ระบบหรือสร้างบัญชีใหม่ ไปที่หน้าคีย์ API ของคุณ คลิก "สร้างคีย์ลับใหม่" และอย่าลืมคัดลอกคีย์นั้นไว้ในที่ปลอดภัยเพื่อใช้ในภายหลัง

4. ติดตั้งไลบรารี Python

เปิดเทอร์มินัลหรือพรอมต์คำสั่งของคุณ และติดตั้งแพ็คเกจที่จำเป็นเหล่านี้:

pip install langgraph langchain openai

คำสั่งนี้ใช้ pip ซึ่งเป็นตัวจัดการแพ็คเกจของ Python เพื่อดาวน์โหลดและติดตั้งไลบรารีที่สำคัญสามไลบรารีสำหรับตัวแทนของเรา:

• langgraph:เฟรมเวิร์กหลักที่เราจะใช้เพื่อสร้างเวิร์กโฟลว์ของตัวแทนของเรา

• langchain:ไลบรารีพื้นฐานสำหรับการทำงานกับโมเดลภาษาขนาดใหญ่ที่ใช้สร้าง LangGraph

• openai:ไลบรารี Python อย่างเป็นทางการสำหรับการเชื่อมต่อกับโมเดล AI อันทรงพลังของ OpenAI

หากคุณรู้สึกตื่นเต้นที่จะลองใช้การตั้งค่าหลายตัวแทน (ซึ่งเราจะกล่าวถึงในขั้นตอนที่ 5) ให้ติดตั้ง CrewAI ด้วย:

pip install crewai

คำสั่งนี้จะติดตั้ง CrewAI ซึ่งเป็นเฟรมเวิร์กพิเศษที่ทำให้ง่ายต่อการประสานตัวแทน AI หลายคนที่ทำงานร่วมกันเป็นทีม

<แข็งแกร่ง>5. ตั้งค่าคีย์ OpenAI API ของคุณ

คุณต้องแน่ใจว่าโค้ด Python ของคุณสามารถค้นหาและใช้คีย์ OpenAI API ของคุณได้ โดยทั่วไปจะทำได้โดยการตั้งค่าให้เป็นตัวแปรสภาพแวดล้อม

บน macOS/Linux ให้รันสิ่งนี้ในเทอร์มินัลของคุณ (แทนที่ "your-api-key" ด้วยคีย์จริงของคุณ):

export OPENAI_API_KEY="your-api-key"

คำสั่งนี้ตั้งค่าตัวแปรสภาพแวดล้อมชื่อ OPENAI_API_KEY ตัวแปรสภาพแวดล้อมเป็นวิธีที่ปลอดภัยสำหรับแอปพลิเคชัน (เช่น สคริปต์ Python) ในการเข้าถึงข้อมูลที่ละเอียดอ่อนโดยไม่ต้องฮาร์ดโค้ดลงในโค้ดโดยตรง

บน Windows (โดยใช้ Command Prompt) ให้ทำดังนี้:

set OPENAI_API_KEY="your-api-key"

นี่เป็นคำสั่งที่เทียบเท่ากับ Windows เพื่อตั้งค่า 12 ตัวแปรสภาพแวดล้อม

ตอนนี้โค้ด Python ของคุณก็พร้อมที่จะสื่อสารกับโมเดล OpenAI แล้ว!

ขั้นตอนที่ 2:กำหนดงาน

เราได้พูดคุยเรื่องนี้กันสั้นๆ ในตอนต้นของหัวข้อนี้ แต่ขอย้ำอีกครั้งว่านี่คือสิ่งที่เราต้องการให้ตัวแทนของเราทำ:

• สแกนหาการประชุม กิจกรรม และงานสำคัญ

• จดลงในสมุดบันทึกหรือแอปอย่างรวดเร็ว

• วางแผนจิตใจคร่าวๆ สำหรับวันของคุณ

กิจวัตรนี้ต้องใช้เวลาและพลังงานทางจิต ดังนั้นการมีตัวแทนมาดำเนินการแทนเราจะเป็นประโยชน์อย่างยิ่ง

ขั้นตอนที่ 3:สร้างเวิร์กโฟลว์ด้วย LangGraph

แลงกราฟคืออะไร?

LangGraph เป็นเฟรมเวิร์กสุดเจ๋งที่ช่วยคุณสร้างตัวแทนโดยใช้เวิร์กโฟลว์ "ตามกราฟ" เหมือนกับการวาดผังงาน ขับเคลื่อนโดย LangChain และช่วยให้คุณควบคุมได้มากขึ้นว่าแต่ละขั้นตอนในกระบวนการของตัวแทนของคุณจะเผยออกมาอย่างไร

แต่ละ "โหนด" ในกราฟนี้แสดงถึงจุดตัดสินใจหรือฟังก์ชันที่:

• รับอินพุตบางส่วน ("สถานะปัจจุบัน")

• ให้เหตุผลหรือดำเนินการบางอย่าง (มักเกี่ยวข้องกับ LLM และเครื่องมือของมัน)

• ส่งคืนเอาต์พุตที่อัปเดต ("สถานะใหม่")

คุณวาดการเชื่อมต่อระหว่างโหนดเหล่านี้ จากนั้น LangGraph ก็ดำเนินการเหมือนกับเครื่องสถานะอัตโนมัติที่ชาญฉลาด

เหตุใดจึงต้องใช้ LangGraph

• คุณสามารถควบคุมลำดับการดำเนินการได้อย่างแม่นยำ

• เหมาะอย่างยิ่งสำหรับการสร้างเวิร์กโฟลว์ที่มีหลายขั้นตอนหรือแม้กระทั่งแตกแขนงออกเป็นเส้นทางที่แตกต่างกัน

• มันเล่นได้ดีกับทั้งโมเดลบนคลาวด์ (เช่น OpenAI) และโมเดลที่คุณเรียกใช้ในเครื่อง

เอาล่ะ – ตอนนี้มาเขียนโค้ดกันดีกว่า

1. จำลองการป้อนอีเมล

ในแอปพลิเคชันจริง ตัวแทนของคุณอาจจะเชื่อมต่อกับ Gmail หรือ Outlook เพื่อดึงอีเมลจริงของคุณ สำหรับตัวอย่างนี้ เราจะฮาร์ดโค้ดข้อความตัวอย่างบางส่วนเพื่อให้ทุกอย่างง่ายขึ้น:

Python
emails = """
1. Subject: Standup Call at 10 AM
2. Subject: Client Review due by 5 PM
3. Subject: Lunch with Sarah at noon
4. Subject: AWS Budget Warning – 80% usage
5. Subject: Dentist Appointment - 4 PM
"""

สตริง Python หลายบรรทัดนี้ 20 ทำหน้าที่เป็นตัวแทนของเราสำหรับเนื้อหาอีเมลจริง เรากำลังจัดเตรียมรายการหัวข้ออีเมลที่เรียบง่ายและมีโครงสร้างเพื่อสาธิตวิธีที่ตัวแทนจะประมวลผลข้อความ

2. กำหนดตรรกะของตัวแทน

ตอนนี้ เราจะบอกโมเดล GPT ของ OpenAI ถึงวิธีประมวลผลข้อความอีเมลนี้และแปลงให้เป็นข้อมูลสรุป

from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, List
import operator
# Define the state for our graph
class AgentState(TypedDict):
 emails: str
 result: str
llm = ChatOpenAI(temperature=0, model="gpt-4o") # Using gpt-4o for better performance
def calendar_summary_agent(state: AgentState) -> AgentState:
 emails = state["emails"]
 prompt = f"Summarize today's schedule based on these emails, listing time-sensitive items first and then other important notes. Be concise and use bullet points:\n{emails}"
 summary = llm.invoke(prompt).content
 return {"result": summary, "emails": emails} # Ensure emails is also returned

ต่อไปนี้เป็นสิ่งที่เกิดขึ้น:

• นำเข้า :เรานำส่วนประกอบที่จำเป็นเข้ามา:

  • 35 เพื่อเชื่อมต่อกับ LLM

  • 49 และ 52 จาก 64 เพื่อสร้างขั้นตอนการทำงานของตัวแทนของเรา

  • 71 , 84 และ 92 จาก 102 สำหรับการตรวจสอบประเภทและโครงสร้าง

  • 117 (แม้ว่าจะไม่ได้ใช้ในตัวอย่างนี้ แต่ก็สามารถช่วยในการเปรียบเทียบหรือตรรกะได้)

• สถานะตัวแทน :125 นี้ กำหนดรูปร่างของข้อมูลที่ตัวแทนของเราจะร่วมงานด้วย ประกอบด้วย:

  • 134 :ข้อความอินพุตดิบ

  • 143 :ผลลัพธ์สุดท้าย (สรุปรายวัน)

• llm =ChatOpenAI(...) :เริ่มต้นโมเดลภาษา เรากำลังใช้ GPT-4o กับ 157 เพื่อให้แน่ใจว่าผลลัพธ์ที่สม่ำเสมอและคาดการณ์ได้เหมาะสำหรับงานการสรุปแบบมีโครงสร้าง

• calendar_summary_agent (สถานะ:AgentState) :ฟังก์ชั่นนี้คือ "สมอง" ของตัวแทนของเรา มัน:

  • เข้าสู่สถานะปัจจุบัน ซึ่งรวมถึงรายการอีเมล

  • แยกอีเมลออกจากสถานะนั้น

  • สร้างพรอมต์ที่บอกให้โมเดลสร้างสรุปกำหนดการรายวันโดยกระชับโดยใช้สัญลักษณ์แสดงหัวข้อย่อย โดยจัดลำดับความสำคัญของรายการที่ต้องคำนึงถึงเวลา

  • ส่งข้อความนี้ไปยังโมเดลที่มี 166 ซึ่งส่งคืนการตอบกลับของ LLM ในรูปแบบข้อความธรรมดา

  • ส่งกลับ 171 ใหม่ พจนานุกรมที่มี:

    • 185 :สรุปที่สร้างขึ้น

    • 190 :สงวนไว้ในกรณีที่เราต้องการมันดาวน์สตรีม

builder = StateGraph(AgentState)
builder.add_node("calendar", calendar_summary_agent)
builder.set_entry_point("calendar")
builder.set_finish_point("calendar") # END is implicit if not set explicitly
graph = builder.compile()
# Run the graph using your simulated email data
result = graph.invoke({"emails": emails})
print(result["result"])

from crewai import Agent, Crew, Task, Process
from langchain_openai import ChatOpenAI
import os
# Set your OpenAI API key from environment variables
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY" # Make sure this is set, or defined directly
# Initialize the LLM (using gpt-4o for better performance)
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# Define the agents with specific roles and goals
extractor = Agent(
 role="Email Scanner",
 goal="Find all meetings, reminders, and tasks from the given emails, accurately extracting details like time, date, and subject.",
 backstory="You are an expert at scanning emails for key information. You meticulously extract every relevant detail.",
 verbose=True,
 allow_delegation=False,
 llm=llm
)
prioritizer = Agent(
 role="Schedule Optimizer",
 goal="Sort extracted items by urgency and time, preparing them for a daily agenda.",
 backstory="You are a master of time management, always knowing what needs to be done first. You organize tasks logically.",
 verbose=True,
 allow_delegation=False,
 llm=llm
)
formatter = Agent(
 role="Output Generator",
 goal="Generate a clean, polished, and concise daily agenda in bullet-point format, clearly listing all schedule items.",
 backstory="You are a professional secretary, ensuring all outputs are perfectly formatted and easy to read. You prioritize clarity.",
 verbose=True,
 allow_delegation=False,
 llm=llm
)
# Simulate email input
emails = """
1. Subject: Standup Call at 10 AM
2. Subject: Client Review due by 5 PM
3. Subject: Lunch with Sarah at noon
4. Subject: AWS Budget Warning – 80% usage
5. Subject: Dentist Appointment - 4 PM
"""
# Define the tasks for each agent
extract_task = Task(
 description=f"Extract all relevant events, meetings, and tasks from these emails: {emails}. Focus on precise details.",
 agent=extractor,
 expected_output="A list of extracted items with their details (e.g., '- Standup Call at 10 AM', '- Client Review due by 5 PM')."
)
prioritize_task = Task(
 description="Prioritize the extracted items by time and urgency. Meetings first, then deadlines, then other notes.",
 agent=prioritizer,
 context=[extract_task], # The output of extract_task is the input here
 expected_output="A prioritized list of schedule items."
)
format_task = Task(
 description="Format the prioritized schedule into a clean, easy-to-read daily agenda using bullet points. Ensure concise language.",
 agent=formatter,
 context=[prioritize_task], # The output of prioritize_task is the input here
 expected_output="A well-formatted daily agenda with bullet points."
)
# Instantiate the crew
crew = Crew(
 agents=[extractor, prioritizer, formatter],
 tasks=[extract_task, prioritize_task, format_task],
 process=Process.sequential, # Tasks are executed sequentially
 verbose=2 # Outputs more details during execution
)
# Run the crew
result = crew.kickoff()
print("\n########################")
print("## Final Daily Agenda ##")
print("########################\n")
print(result)