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

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

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

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

สิ่งที่เราจะครอบคลุม:

1. สถานะปัจจุบันของ LLM Agents

   • จาก Chatbots สู่ Autonomous Agents

   • Agents ทำได้อะไรบ้างในวันนี้?

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

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

2. LLM Agents คืออะไร และทำไมจึงสำคัญ?

   • LLM คืออะไร?

   • 那麼 LLM Agent คืออะไร?

   • ทำไมสิ่งนี้จึงสำคัญ?

3. การเพิ่มขึ้นของเฟรมเวิร์ก Agent โอเพนซอร์ส

   • เฟรมเวิร์ก Agent โอเพนซอร์สยอดนิยม

   • เครื่องมือเหล่านี้ช่วยให้อะไรบ้าง?

   • ทำไมต้องใช้เฟรมเวิร์กแทนการสร้างจากศูนย์?

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

   • The Agent Loop

   • องค์ประกอบหลักของ Agent

   • Multi-Agent Collaboration

5. โครงการ: ทำให้ตารางเวลาประจำวันจากอีเมลอัตโนมัติ

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

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

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

   • ขั้นตอน 3: สร้าง Workflow ด้วย LangGraph

6. Multi-Agent Collaboration ด้วย CrewAI

   • CrewAI คืออะไร?

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

   • ตัวอย่างโค้ด CrewAI

7. สิ่งที่เกิดขึ้นจริงระหว่างการดำเนินการ?

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

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

10. สำรวจ Daily Automations เพิ่มเติม

11. อะไรจะเป็นขั้นตอนต่อไปในเทคโนโลยี Agent?

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

สถานะปัจจุบันของ LLM Agents

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

จาก Chatbots สู่ Autonomous Agents

Large Language Models (LLMs) เช่น GPT-4, Claude, Gemini และ LLaMA ได้วิวัฒนาการจาก chatbots แบบง่ายกลายเป็น reasoning engines ที่มีความสามารถน่าประหลาดใจ พวกเขาเปลี่ยนจากการตอบคำถามทั่วไปและสร้างเรียงความ ไปสู่การทำ reasoning ซับซ้อน ปฏิบัติตามคำแนะนำหลายขั้นตอน และโต้ตอบกับเครื่องมืออย่าง web search และ code interpreters

แต่วิธีหนึ่งคือ: โมเดลเหล่านี้เป็น reactive พวกเขารอ input และให้ output พวกเขาไม่เก็บ memory ระหว่างงาน วางแผนล่วงหน้า หรือ追求เป้าหมายด้วยตัวเอง นั่นคือที่ที่ LLM agents เข้ามาเติมช่องว่าง โดยเพิ่มโครงสร้าง memory และ autonomy

Agents ทำได้อะไรบ้างในวันนี้?

ตอนนี้ LLM agents ถูกใช้สำหรับ:

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

• วางแผนตารางเวลาประจำวัน

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

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

• ทำงานร่วมกันใน 「ทีม」 เล็กๆ เพื่อทำภารกิจซับซ้อน

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

• ติดใน loops

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

• ต้องการ prompts และ guardrails ที่ละเอียด

นั่นเป็นเพราะเทคโนโลยีนี้ยังอยู่ในช่วงเริ่มต้น เฟรมเวิร์กกำลดูดีขึ้นเร็ว แต่ reliability และ memory ยังคงเป็นงานที่กำลังดำเนินการ อย่าลืมเรื่องนี้ขณะทดลอง

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

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

นี่คือเวลาที่สมบูรณ์แบบในการเริ่มทดลองกับ agents:

• Tooling พร้อมพอที่จะสร้างโปรเจกต์จริง

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

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

LLM Agents คืออะไร และทำไมจึงสำคัญ?

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

LLM คืออะไร?

LLM หรือ Large Language Model คือ AI ที่เรียนรู้จากปริมาณข้อความมหาศาลจากอินเทอร์เน็ต – คิดถึงหนังสือ บทความ โค้ด และอีกมากมาย คุณสามารถจินตนาการมันได้ว่าเป็น autocomplete engine ระดับซูเปอร์สมาร์ท แต่มันทำได้มากกว่แค่จบประโยคของคุณ มันยังสามารถ:

• ตอบคำถามที่ซับซ้อน

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

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

• แปลภาษาทันที

• แม้แต่แก้ปริศนาตรรกะและนำสนทนาที่น่าสนใจ

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

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

那麼 LLM Agent คืออะไร?

ในขณะที่ LLMs มีพลังมาก พวกเขามักแค่ react – พวกเขาตอบสนอง فقطเมื่อคุณถามสิ่ง gì LLM agent ในทางกลับกัน เป็น proactive

LLM agents สามารถ:

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

• ตัดสินใจฉลาดและคิดว่าจะทำอะไรต่อ

• ใช้ 「tools」 เช่น web search, calculators หรือแม้แต่อื่นๆ apps

• ทำงานเพื่อเป้าหมาย แม้จะใช้หลายขั้นตอนหรือหลายครั้ง

• ร่วมมือกับ agents อื่นๆ เพื่อบรรลุเป้าหมายร่วม

สรุปคือ LLM agents สามารถคิด วางแผน กระทำ และปรับตัวได้

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

ทำไมสิ่งนี้จึงสำคัญ?

การเปลี่ยนแปลงจากแค่ตอบสนองไปสู่การ追求เป้าหมายอย่าง актив เปิดโอกาสน่าตื่นเต้นมาก:

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

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

• ช่วยโปรเจกต์วิจัยหลายขั้นตอน

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

• รันเครื่องมือภายในเพื่อทำการกระทำจริง

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

การเพิ่มขึ้นของเฟรมเวิร์ก Agent โอเพนซอร์ส

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

แตายังไงก็ตาม? นั่นไม่ใช่กรณีแล้ว

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

เฟรมเวิร์ก Agent โอเพนซอร์สยอดนิยม

สิ่งที่เครื่องมือเหล่านี้ช่วยให้ได้

เฟรมเวิร์กเหล่านี้ให้บล็อกสร้างสำเร็จรูปเพื่อจัดการส่วนที่ซับซ้อนของการสร้าง agents:

• Planning – ให้ agents ตัดสินใจขั้นตอนต่อไป

• Tool Use – เชื่อม agents กับระบบไฟล์ web browsers, APIs หรือ databases ได้ง่าย

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

• Multi-Agent Collaboration – ตั้งทีม agents ที่ทำงานร่วมกันเพื่อเป้าหมายร่วม

ทำไมต้องใช้เฟรมเวิร์กแทนการสร้างจากศูนย์?

ในขณะที่คุณ สามารถ สร้าง custom agent จากพื้นฐาน การใช้เฟรมเวิร์กจะประหยัดเวลาและความพยายามมาก โลเพนซอร์ส agent libraries มาพร้อมกับ:

• Built-in support สำหรับการจัดการ LLMs

• Patterns ที่พิสูจน์แล้วสำหรับ task planning, การติดตามสถานที่ และการได้รับ feedback

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

• ความยืดหยุ่นในการขยายจาก agent เดี่ยวที่ช่วยเหลือไปสู่ทีม agents ทั้งหมด

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

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

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

The Agent Loop

LLM agents ส่วนใหญ่ทำงานจาก mental model ที่เรียกว่า Agent Loop วงจรขั้นตอนต่อขั้นตอนที่ซ้ำจนกว่างานจะเสร็จ นี่คือวิธีที่มันทำงานทั่วไป:

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

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

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

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

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

องค์ประกอบหลักของ Agent

เพื่อทำงานได้อย่างมีประสิทธิภาพ Agents สร้างขึ้นรอบส่วนสำคัญหลายอย่าง:

• Tools คือวิธีที่ agent โต้ตอบกับโลกจริง (หรือดิจิทัล) สิ่งเหล่านี้อาจเป็นอะไรก็ได้ ตั้งแต่ search engines, สภาพแวดล้อมรันโค้ด, file readers, หรือ API clients ไปจนถึง calculators หรือสคริปต์บรรทัดคำสั่งง่ายๆ

• Memory ให้ agents จำสิ่งที่พวกเขาทำหรือเห็นข้ามขั้นตอนต่างๆ อาจรวมถึงสิ่งที่คุณพูดก่อนหน้า ผลลัพธ์ชั่วคราว หรือการตัดสินใจสำคัญ บางเฟรมเวิร์กเสนอ short-term memory (แค่สำหรับ session เดียว) ในขณะที่บางตัวรองรับ long-term memory ที่ครอบคลุมหลาย sessions หรือเป้าหมาย

• Environment หมายถึงข้อมูลภายนอกหรือบริบทระบบที่ agent ทำงานภายใน คิดถึง APIs, documents, databases, files หรือ sensor inputs ยิ่ง agent มีข้อมูลและการเข้าถึง environment มากเท่าไหร่ ยิ่งมันสามารถกระทำได้มีความหมายมากขึ้น

• Goal คือเป้าหมายสูงสุดของ agent: สิ่งที่มันพยายามบรรลุ เป้าหมายควรเฉพาะเจาะจงและชัดเจน ตัวอย่าง 「สร้างตารางเวลาประจำวัน」 「สรุปเอกสารนี้」 หรือ 「แยกงานจากอีเมล」

Multi-Agent Collaboration

สำหรับระบบขั้นสูง คุณแม้แต่สามารถมี multiple agents ทำงานร่วมกันเพื่อเป้าหมายร่วม แต่ละ agent สามารถได้รับ role เฉพาะที่เน้นความเชี่ยวชาญของมัน เหมือนคนทำงานในทีม

ตัวอย่าง:

• Agent researcher อาจได้รับมอบหมายให้เก็บข้อมูล

• Agent coder อาจเขียนสคริปต์ Python หรือ automation routines

• Agent reviewer อาจตรวจสอบผลลัพธ์และให้แน่ใจว่าทุกอย่างขึ้นมาตรฐาน

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

โครงการ: ทำให้ตารางเวลาประจำวันจากอีเมลอัตโนมัติ

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

คิดถึงวันตอนเช้าทั่วไปของคุณ:

• คุณเปิด inbox

• คุณสแกนผ่านอีเมลหลายฉบับอย่างรวดเร็ว

• คุณพยายามจับประชุม งาน และการเตือนสำคัญ

• จากนั้น คุณเขียน to-do list หรือเพิ่มสิ่งต่างๆ ไปที่ปฏิทินด้วยตนเอง

มาลองใช้ LLM agent ทำให้กระบวนการนั้นง่ายขึ้น Agent ของเราจะ:

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

• ดึงรายการที่เกี่ยวกับเวลาออกมา เช่น ประชุม หรือ deadline

• สรุปทุกอย่างเป็นตารางเวลาประจำวันที่สะอาดสวยงาม

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

เพื่อเริ่มต้น คุณจะต้องการเครื่องมือหลัก 3 อย่าง: Python, VSCode และ OpenAI API key

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

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

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

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

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

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

3. รับ OpenAI API Key ของคุณ

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

ลงชื่อเข้าใช้หรือสร้างบัญชีใหม่ ไปที่หน้า API Keys คลิก 「Create new secret key」 และคัดลอกคีย์นั้นไว้ที่ปลอดภัยสำหรับใช้ภายหลัง

4. ติดตั้ง Python Libraries

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

pip install langgraph langchain openai

คำสั่งนี้ใช้ pip, package manager ของ Python เพื่อดาวน์โหลดและติดตั้งไลบรารีสำคัญ 3 ตัวสำหรับ agent ของเรา:

• langgraph: เฟรมเวิร์กหลักที่เราจะใช้สร้าง workflow ของ agent

• langchain: ไลบรารีพื้นฐานสำหรับทำงานกับ large language models ซึ่ง LangGraph สร้างขึ้นจาก

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

หากคุณตื่นเต้นลอง multi-agent setups (ซึ่งเราจะครอบคลุมในขั้นตอน 5) ให้ติดตั้ง CrewAI ด้วย:

pip install crewai

คำสั่งนี้ติดตั้ง CrewAI เฟรมเวิร์กเฉพาะที่ทำให้การจัดการ multiple AI agents ทำงานร่วมกันเป็นทีมง่ายขึ้น

5. ตั้งค่า OpenAI API Key ของคุณ

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

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

export OPENAI_API_KEY="your-api-key"

คำสั่งนี้ตั้งค่า environment variable ชื่อ OPENAI_API_KEY Environment variables เป็นวิธีที่ปลอดภัยสำหรับแอปพลิเคชัน (เช่นสคริปต์ Python ของคุณ) เข้าถึงข้อมูล nhạy cảmโดยไม่ต้อง hardcode มันลงในโค้ดโดยตรง

บน Windows (ใช้ Command Prompt) ทำนี้:

set OPENAI_API_KEY="your-api-key"

นี่คือคำสั่ง Windows เทียบเท่าในการตั้งค่า environment variable OPENAI_API_KEY

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

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

เราได้อภิปรายเรื่องนี้สั้นๆ ที่ต้นส่วนนี้ แต่เพื่อซ้ำอีกครั้ง นี่คือสิ่งที่เราจะให้ agent ของเราทำ:

• สแกนหาประชุม เหตุการณ์ และงานสำคัญ

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

• สร้างแผนวันคร่าวๆ ในใจ

กิจวัตรนี้ใช้เวลาและพลังจิตใจ ดังนั้น การมี agent ทำให้เราจะช่วยมาก

ขั้นตอน 3: สร้าง Workflow ด้วย LangGraph

LangGraph คืออะไร?

LangGraph เป็นเฟรมเวิร์กที่น่าสนใจช่วยให้คุณสร้าง agents โดยใช้ workflow แบบ 「graph-based」 แบบอย่างการวาด flowchart มันขับเคลื่อนโดย LangChain และให้คุณควบคุมได้มากขึ้นเกี่ยวกับแต่ละขั้นตอนในกระบวนการของ agent อย่างแน่นอน

แต่ละ 「node」 ในกราฟนี้แทน decision point หรือฟังก์ชันที่:

• รับ input บางอย่าง (「state」 ปัจจุบันของมัน)

• ทำ reasoning หรือกระทำบางอย่าง (มักเกี่ยวกับ LLM และ tools ของมัน)

• คืน output ที่อัปเดตแล้ว (「state」 ใหม่)

คุณวาดการเชื่อมต่อระหว่าง nodes เหล่านี้ และ LangGraph จะ execute มันเหมือน state machine อัจฉริยะ อัตโนมัติ

ทำไมต้องใช้ LangGraph?

• คุณควบคุมลำดับการ execute อย่างแม่นยำ

• มันยอดเยี่ยมสำหรับการสร้าง workflows ที่มีหลายขั้นตอน หรือแม้แตกแยกไปทางต่างๆ

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

ดีแล้ว – มาเขียนโค้ดกัน

1. จำลอง Email Input

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

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
"""

Multiline Python string นี้ emails ทำหน้าที่เป็น stand-in สำหรับเนื้อหาอีเมลจริง เราให้รายการ subjects ของอีเมลที่เรียบง่ายและมีโครงสร้าง เพื่อสาธิตว่า agent จะประมวลผลข้อความอย่างไร

2. กำหนด Logic ของ Agent

ตอนนี้ เราจะบอก GPT model ของ 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

นี่คือสิ่งที่เกิดขึ้น:

• Imports: เรานำเข้า components ที่จำเป็น:

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

  • StateGraph และ END จาก langgraph.graph เพื่อสร้าง workflow ของ agent

  • TypedDict, Annotated และ List จาก typing สำหรับ type checking และโครงสร้าง

  • operator (แม้ไม่ได้ใช้ใน snippet นี้ แต่อาจช่วยกับการเปรียบเทียบหรือ logic)

• AgentState: TypedDict นี้กำหนดรูปทรงของข้อมูลที่ agent ของเราจะทำงาน มันรวมถึง:

  • emails: raw input messages

  • result: output สุดท้าย (สรุปประจำวัน)

• llm = ChatOpenAI(...): เริ่มต้น language model เราใช้ GPT-4o ด้วย temperature=0 เพื่อให้แน่ใจว่า output สอดคล้องและคาดการณ์ได้ เหมาะสำหรับงาน summarization ที่มีโครงสร้าง

• calendar_summary_agent(state: AgentState): ฟังก์ชันนี้คือ 「สมอง」 ของ agent มัน:

  • รับ state ปัจจุบัน ซึ่งรวมรายการอีเมล

  • แยกอีเมลจาก state นั้น

  • สร้าง prompt ที่บอก model ให้สร้างสรุปตารางเวลาประจำวันที่กระชับ ใช้ bullet points ให้นำรายการที่เกี่ยวกับเวลาก่อน

  • ส่ง prompt นี้ไปที่ model ด้วย llm.invoke(prompt).content ซึ่งคืน response ของ LLM เป็น plain text

  • คืน AgentState dictionary ใหม่ที่มี:

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

    • emails: รักษาไว้ในกรณีที่ต้องการ downstream

3. สร้างและรัน Graph

ตอนนี้ เราจะใช้ LangGraph เพื่อแผนที่ flow ของงาน single-agent ของเรา และจากนั้นรันมัน

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"])

นี่คือสิ่งที่เกิดขึ้น:

• builder = StateGraph(AgentState): เราเริ่มต้น StateGraph object ด้วยการส่ง AgentState เรากำลังบอก LangGraph โครงสร้างข้อมูลที่คาดหวังสำหรับ internal state ของมัน

• builder.add_node("calendar", calendar_summary_agent): บรรทัดนี้เพิ่ม 「node」 ที่มีชื่อไปยังกราฟของเรา เราเรียกมันว่า 「calendar」 และเรา link มันกับฟังก์ชัน calendar_summary_agent หมายความว่าฟังก์ชันนั้นจะถูก execute เมื่อ node นี้ active

• builder.set_entry_point("calendar"): ตั้งค่า 「calendar」 เป็นขั้นตอนแรกใน workflow ของเรา เมื่อเราเริ่ม graph การ execute จะเริ่มที่นี่

• builder.set_finish_point("calendar"): บอก LangGraph ว่าเมื่อ node 「calendar」 ทำงานเสร็จ กระบวนการ graph ทั้งหมดก็จบ

• graph = builder.compile(): คำสั่งนี้รับ blueprint กราฟที่เรากำหนดและ 「compile」 มันเป็น workflow ที่ execute ได้

• result = graph.invoke({"emails": emails}): นี่คือที่ที่เวทมนต์เกิดขึ้น! เราบอกกราฟให้เริ่มรัน เราส่ง initial state ที่มีข้อมูล emails กราฟจะประมวลผลข้อมูลนี้ผ่าน nodes จนถึง end point คืน final state

• print(result["result"]): สุดท้าย เราดึงตารางเวลาที่สรุปจาก result (final state ของกราฟของเรา) และพิมพ์ไปที่ console

ตัวอย่าง Output

Your Schedule:
- 10:00 AM – Standup Call
- 12:00 PM – Lunch with Sarah
- 4:00 PM – Dentist Appointment
- Submit client report by 5:00 PM
- AWS Budget Warning – check usage

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

Multi-Agent Collaboration ด้วย CrewAI

CrewAI คืออะไร?

CrewAI เป็นเฟรมเวิร์กโอเพนซอร์สที่น่าตื่นเต้นที่ให้คุณสร้าง ทีม ของ agents ที่ทำงานร่วมกันอย่างราบรื่น เหมือนทีมโปรเจกต์จริง! แต่ละ agent ใน CrewAI setup:

• มี role เฉพาะที่ specialized

• สามารถสื่อสารและแชร์ข้อมูลกับเพื่อนร่วมทีมได้

• ทำงานร่วมกันเพื่อบรรลุเป้าหมายร่วม

แนวทาง multi-agent นี้ super useful เมื่องานของคุณใหญ่เกินหรือซับซ้อนเกินสำหรับ agent เดียว หรือเมื่อการแยกมันออกเป็นส่วนเฉพาะทางทำให้ชัดเจนและมีประสิทธิภาพมากขึ้น

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

ลองจินตนาการงานสรุปอีเมลของเราถูกจัดการโดยทีม agents เล็กๆ:

ตัวอย่างโค้ด CrewAI

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)

นี่คือสิ่งที่เกิดขึ้น:

• Imports: เรานำเข้า key classes จาก CrewAI: Agent, Crew, Task และ Process เรายัง import ChatOpenAI สำหรับ language model และ os เพื่อจัดการ environment variables

• llm = ChatOpenAI(...): เหมือนตัวอย่าง LangGraph นี้ตั้งค่า OpenAI language model ของเรา ให้แน่ใจว่า responses ตรงไปตรงมา (temperature=0) และใช้โมเดล gpt-4o

• Agent Definitions (extractor, prioritizer, formatter):

  • ตัวแปรแต่ละตัวสร้าง Agent instance Agent ถูกกำหนดโดย role (มันทำอะไร) goal เฉพาะที่มันพยายามบรรลุ และ backstory (ชนิดของ personality หรือ expertise ที่ช่วย LLM เข้าใจวัตถุประสงค์ได้ดีขึ้น)

  • verbose=True ช่วยมากสำหรับ debugging เนื่องจากทำให้ agents พิมพ์ 「ความคิด」 ของพวกเขาขณะทำงาน

  • allow_delegation=False หมายความว่า agents เหล่านี้จะไม่ส่งมอบงานที่ได้รับมอบหมายให้ agents อื่นๆ (แม้จะตั้งค่าเป็น True สำหรับ delegation scenarios ที่ซับซ้อนก็ได้)

  • llm=llm เชื่อมแต่ละ agent กับ OpenAI language model ของเรา

• Simulated emails: เราใช้ข้อมูลอีเมลตัวอย่างเดียวกันสำหรับตัวอย่างนี้

• Task Definitions (extract_task, prioritize_task, format_task):

  • แต่ละ Task กำหนดชิ้นงานเฉพาะที่ agent ต้องทำ

  • description บอก agent ชัดเจนว่างานเกี่ยวกับอะไร

  • agent มอบหมายงานนี้ให้ agent ที่เรากำหนด (เช่น extractor สำหรับ extract_task)

  • context=[...] เป็นส่วนสำคัญของ collaboration ของ CrewAI มันบอก task ให้ใช้ output ของ previous task เป็น input ของมัน ตัวอย่าง prioritize_task รับ output ของ extract_task เป็น context

  • expected_output ให้ agent ตัวอย่างว่าผลลัพธ์ควรจะเป็นอย่างไร ช่วย guide LLM

• crew = Crew(...):

  • นี่คือที่ที่เราประกอบทีม! เราสร้าง Crew instance ให้มัน agents และ tasks ของเรา

  • process=Process.sequential บอก crew ให้ execute tasks ตามลำดับทีละอันในลำดับที่กำหนดใน tasks list CrewAI ยังรองรับ processes ขั้นสูงอย่าง hierarchical

  • verbose=2 จะแสดง log รายละเอียดมากของการทำงานภายในและการสื่อสารของ crew

• result = crew.kickoff(): คำสั่งนี้เริ่ม workflow multi-agent ทั้งหมดอย่างเป็นทางการ Agents จะเริ่มทำงานร่วมกัน ส่งข้อมูล และทำงานผ่าน tasks ที่มอบหมายตามลำดับ

• fprint(result): สุดท้าย consolidated output จากความพยายามร่วมมือของ crew ทั้งหมดถูกพิมพ์ไปที่ console

Cleverly CrewAI จัดการการสื่อสารระหว่าง agents ทั้งหมด คิดว่ ai ต้องทำงานอะไรและเมื่อไหร่ และส่ง output อย่างราบรื่นจาก agent หนึ่งไปอีกตัว มันเหมือนมี mini AI assembly line!

สิ่งที่เกิดขึ้นจริงระหว่างการดำเนินการ?

ไม่ว่าคุณจะใช้ LangGraph หรือ CrewAI สิ่งที่เกิดขึ้นจริงเบื้องหลังเมื่อ agent รันคืออะไร? มาแยกกระบวนการ execution:

• ระบบได้รับ input state (ตัวอย่าง อีเมลของคุณ)

• Agent แรกหรือ graph node อ่าน input นี้และใช้ Large Language Model (LLM) เพื่อทำความเข้าใจ

• จากความเข้าใจของมัน Agent ตัดสินใจ action เช่น ดึง key events หรือเรียก tool เฉพาะ

• หากจำเป็น Agent อาจ invoke tools (อย่าง web search หรือ file reader) เพื่อได้ context เพิ่ม หรือทำ external operations

• ผลลัพธ์ของ action นั้นจะถูก ส่งไปยัง agent ถัดไป ในทีม (ถ้าเป็น multi-agent setup) หรือคืนโดยตรงให้คุณ

การ execute ทำงานต่อไปจนกว่า:

• งานเสร็จสมบูรณ์

• Agents ทั้งหมดเสร็จสิ้น roles ที่ได้รับมอบหมาย

• เงื่อนไขหยุดหรือ "END" point ที่กำหนดใน workflow ถูกถึง

คิดถึงสิ่งนี้เป็น workflow engine ซูเปอร์สมาร์ท ที่ทุกขั้นตอนเกี่ยวข้องกับ reasoning การตัดสินใจ และการจำสิ่งที่โต้ตอบก่อนหน้า

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

เท่าที่ LLM agents จะน่าสนใจ พวกเขายกคำถามสำคัญ: คุณเชื่อถือ AI ให้รันส่วนหนึ่งของ workflow หรือโต้ตอบกับข้อมูลของคุณได้จริงไหม? ขึ้นอยู่กับ ถ้าคุณใช้บริการอย่าง OpenAI หรือ Anthropic ข้อมูลของคุณถูกเข้ารหัสระหว่างการส่ง และ (จนถึงตอนนี้) ไม่ได้ถูกใช้สำหรับ training

แตบางข้อมูลอาจยังถูก log ชั่วคราวเพื่อป้องกันการละเมิดสิทธิ์ นั่นปกติสำหรับ testing และ personal projects แตถ้าคุณทำงานกับข้อมูลธุรกิจ nhạy cảm ข้อมูลลูกค้า หรืออะไรที่เป็นส่วนตัว คุณจะต้องระมัดระวัง

ใช้ inputs ที่ anonymized หลีกเลี่ยงการ expose full datasets และพิจารณารัน agents locally ด้วยโมเดลโอเพนซอร์สอย่าง LLaMA หรือ Mistral หากการควบคุมเต็มที่สำคัญกับคุณ

คุณยังสามารถตั้งขอบเขตชัดเจนสำหรับ agents เพื่อไม่ให้พวกเขา overstep คิดเหมือน onboarding intern ใหม่: คุณไม่會ให้พวกเขาเข้าถึงทุกอย่างวันที่หนึ่ง

ให้ agents เฉพาะ tools และไฟล์ที่พวกเขาต้องการ เก็บ logs ของสิ่งที่พวกเขาทำ และ review ผลลัพธ์เสมอก่อนให้พวกเขาทำ real changes

เมื่อเทคโนโลยีนี้เติบโต ฟีเจอร์ความปลอดภัยมากขึ้นกำลังจะมา เช่น sandboxing ที่ดีขึ้น memory limits และ role-based access แต่ตอนนี้ การจัดการ agents เหมือน helpers อันทรงพลังที่ยังต้องการการดูแลจากมนุษย์เป็นเรื่องฉลาด

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

บางครั้ง agents อาจมีควirks นิดหน่อย! นี่คือปัญหาทั่วไปที่คุณอาจเจอและวิธีแก้:

เคล็ดลับที่ใช้ได้: คุณยังสามารถเพิ่ม print() statements หรือ logging messages ภายในฟังก์ชัน agent เพื่อดูสิ่งที่เกิดขึ้นในแต่ละขั้นตอนและ debug state transitions

สำรวจ Daily Automations เพิ่มเติม

เมื่อคุณสร้าง agent-based task หนึ่งแล้ว คุณจะพบว่ามันง่ายมากในการปรับ pattern นั้นสำหรับ automations อื่นๆ นี่คือไอเดียน่าสนใจเพื่อกระตุ้นความคิดสร้างสรรค์:

แต่ละอย่างของเหล่านี้สามารถสร้างได้โดยใช้ principles และ frameworks เหมือนกันที่เราอภิปราย ไม่ว่าจะเป็น LangGraph หรือ CrewAI

อะไรจะเป็นขั้นตอนต่อไปในเทคโนโลยี Agent?

LLM agents กำลังวิวัฒนาการด้วยความเร็วแสง และคลื่นนวัตกรรมถัดไปอยู่ที่นี่แล้ว:

• Smarter memory systems: คาดหวังว่า agents จะมี long-term memory ที่ดีขึ้น ช่วยให้พวกเขาเรียนรู้ตลอดช่วงเวลายาวและจำบทสนทนาและการกระทำอดีต

• Multi-modal agents: Agents จะไม่จัดการแค่ข้อความแล้ว! พวกเขาจะประมวลผลและเข้าใจ images, audio และ video ทำให้พวกเขา versatile มากขึ้น

• Advanced planning frameworks: เทคนิคอย่าง ReAct, Toolformer และ AutoGen กำลังปรับปรุงความสามารถของ agents ในการ reason, plan และลด 「hallucinations」 ที่ทำให้หงุดหงิด

• Edge deployment: จินตนาการ agents รันทั้งหมดออฟไลน์บนคอมพิวเตอร์หรืออุปกรณ์ local โดยใช้โมเดลเบาๆ อย่าง LLaMA 3 หรือ Mistral

ในอนาคตที่ใกล้ชิด คุณจะเห็น agents รวมเข้ากับ:

• DevOps pipelines ของคุณ

• Enterprise workflows ใหญ่ๆ

• Productivity tools ประจำวัน

• Mobile apps และ smart devices

• Games, simulations และ educational platforms

สรุปสุดท้าย

ดีแล้ว มาสรุปสิ่งที่น่าสนใจที่คุณเพิ่งเรียนรู้และทำได้:

• คุณได้เข้าใจมั่นคงว่ LLM agents คืออะไร และทำไมจึงทรงพลัง

• คุณเห็นว่าเฟรมเวิร์กโอเพนซอร์สอย่าง LangGraph และ CrewAI ทำให้การสร้าง agents ง่ายขึ้น

• คุณสร้าง LLM agent จริงด้วย LangGraph เพื่อทำให้งานประจำวันทั่วไปอัตโนมัติ: สรุป inbox!

• คุณสำรวจโลก multi-agent collaboration ด้วย CrewAI เข้าใจว่าทีม AIs ทำงานร่วมกันอย่างไร

• คุณเรียนรู้วิธีนำ principles เหล่านี้ไปขยายเพื่อทำให้งานอื่นๆ อัตโนมัติไม่รู้จบ

ดังนั้น ครั้งหน้าที่คุณพบตัวเองติดอยู่กับสิ่งที่ซ้ำซาก แค่ถามตัวเอง: 「เอ้ย ฉันสร้าง agent สำหรับนั้นได้ไหม?」 คำตอบน่าจะเป็น yes!

สรุปทรัพยากร

นี่คือทรัพยากรบางส่วนที่มีประโยชน์หากคุณต้องการดำดิ่งสู่การสร้าง LLM agents:

เรียนรู้เขียนโค้ดฟรี freeCodeCamp's open source curriculum ช่วยให้มากกว่า 40,000 คนได้งาน developer เริ่มต้น