ai-agents-for-beginners

วิธีการออกแบบเอเย่นต์ AI ที่ดี

(คลิกที่ภาพด้านบนเพื่อดูวิดีโอของบทเรียนนี้)

รูปแบบการออกแบบการใช้เครื่องมือ

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

บทนำ

ในบทเรียนนี้ เราจะตอบคำถามดังต่อไปนี้:

เป้าหมายการเรียนรู้

หลังจากทำบทเรียนนี้จบ คุณจะสามารถ:

รูปแบบการออกแบบการใช้เครื่องมือคืออะไร?

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

กรณีการใช้งานที่สามารถนำไปใช้ได้มีอะไรบ้าง?

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

องค์ประกอบ/บล็อกพื้นฐานที่จำเป็นในการใช้งานรูปแบบการออกแบบการใช้เครื่องมือมีอะไรบ้าง?

บล็อกเหล่านี้ช่วยให้อเจนต์ AI สามารถทำงานได้หลากหลาย มาดูองค์ประกอบหลักสำหรับใช้งานรูปแบบการออกแบบการใช้เครื่องมือกัน:

ต่อไปเรามาดูรายละเอียดของการเรียกฟังก์ชัน/เครื่องมือกัน

การเรียกฟังก์ชัน/เครื่องมือ

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

สำหรับนักพัฒนาที่ต้องการใช้งานการเรียกฟังก์ชันสำหรับอเจนต์ จำเป็นต้องมี:

  1. โมเดล LLM ที่รองรับการเรียกฟังก์ชัน
  2. สคีมาที่มีคำอธิบายฟังก์ชัน
  3. โค้ดสำหรับแต่ละฟังก์ชันที่ถูกอธิบายไว้

มาดูตัวอย่างการดึงเวลาปัจจุบันในเมืองหนึ่งเพื่ออธิบาย:

  1. เริ่มต้นใช้งาน LLM ที่รองรับการเรียกฟังก์ชัน:

    ไม่ใช่ทุกรุ่นที่รองรับการเรียกฟังก์ชัน ดังนั้นต้องตรวจสอบว่า LLM ที่ใช้รองรับหรือไม่ Azure OpenAI รองรับการเรียกฟังก์ชัน เริ่มกันด้วยการเริ่มต้นไคลเอ็นต์ OpenAI กับ Azure OpenAI Responses API (จุดเชื่อมต่อที่เสถียร /openai/v1/ — ไม่ต้องใช้ api_version)

     # เริ่มต้นไคลเอนต์ OpenAI สำหรับ Azure OpenAI (API ตอบกลับ, จุดสิ้นสุด v1)
 client = OpenAI(
     base_url=f"{os.environ['AZURE_OPENAI_ENDPOINT'].rstrip('/')}/openai/v1/",
     api_key=os.environ["AZURE_OPENAI_API_KEY"],
 )
 deployment_name = os.environ["AZURE_OPENAI_DEPLOYMENT"]

  2. สร้างสคีมาฟังก์ชัน:

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

     # คำอธิบายฟังก์ชันสำหรับโมเดลเพื่ออ่าน (รูปแบบเครื่องมือแผ่นข้อมูล API การตอบกลับ)
 tools = [
     {
         "type": "function",
         "name": "get_current_time",
         "description": "Get the current time in a given location",
         "parameters": {
             "type": "object",
             "properties": {
                 "location": {
                     "type": "string",
                     "description": "The city name, e.g. San Francisco",
                 },
             },
             "required": ["location"],
         },
     }
 ]

      
 # ข้อความผู้ใช้เริ่มต้น
 messages = [{"role": "user", "content": "What's the current time in San Francisco"}]

 # การเรียก API ครั้งแรก: ขอให้โมเดลใช้ฟังก์ชัน
 response = client.responses.create(
     model=deployment_name,
     input=messages,
     tools=tools,
     tool_choice="auto",
     store=False,
 )

 # Responses API ส่งคืนการเรียกเครื่องมือในรูปแบบ function_call ใน response.output
 # แนบพวกมันไปยังบทสนทนาเพื่อให้โมเดลมีบริบทครบถ้วนในรอบถัดไป
 messages += response.output

 print("Model's response:")
 print(response.output)
  

     Model's response:
 [ResponseFunctionToolCall(arguments='{"location":"San Francisco"}', call_id='call_pOsKdUlqvdyttYB67MOj434b', name='get_current_time', type='function_call')]

  3. โค้ดฟังก์ชันที่จำเป็นสำหรับทำงานนี้:

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

       def get_current_time(location):
     """Get the current time for a given location"""
     print(f"get_current_time called with location: {location}")  
     location_lower = location.lower()
        
     for key, timezone in TIMEZONE_DATA.items():
         if key in location_lower:
             print(f"Timezone found for {key}")  
             current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
             return json.dumps({
                 "location": location,
                 "current_time": current_time
             })
      
     print(f"No timezone data found for {location_lower}")  
     return json.dumps({"location": location, "current_time": "unknown"})

     # จัดการการเรียกฟังก์ชัน
 tool_calls = [item for item in response.output if item.type == "function_call"]
 if tool_calls:
     for tool_call in tool_calls:
         if tool_call.name == "get_current_time":

             function_args = json.loads(tool_call.arguments)

             time_response = get_current_time(
                 location=function_args.get("location")
             )

             # ส่งคืนผลลัพธ์ของเครื่องมือในรูปแบบ item function_call_output
             messages.append({
                 "type": "function_call_output",
                 "call_id": tool_call.call_id,
                 "output": time_response,
             })
 else:
     print("No tool calls were made by the model.")

 # การเรียก API ครั้งที่สอง: รับคำตอบสุดท้ายจากโมเดล
 final_response = client.responses.create(
     model=deployment_name,
     input=messages,
     tools=tools,
     store=False,
 )

 return final_response.output_text

       get_current_time called with location: San Francisco
   Timezone found for san francisco
   The current time in San Francisco is 09:24 AM.

การเรียกฟังก์ชันเป็นหัวใจของรูปแบบการออกแบบเครื่องมือสำหรับอเจนต์ส่วนใหญ่ถ้าไม่ทั้งหมด แต่การทำเองตั้งแต่เริ่มต้นบางครั้งก็มีความท้าทาย ตามที่เราเรียนรู้ใน บทเรียน 2 เฟรมเวิร์กอเจนติกช่วยให้เรามีบล็อกพื้นฐานสำเร็จรูปสำหรับการใช้งานเครื่องมือ

ตัวอย่างการใช้เครื่องมือกับ Agentic Frameworks

ต่อไปนี้คือตัวอย่างวิธีการใช้งานรูปแบบการออกแบบการใช้เครื่องมือด้วยเฟรมเวิร์กอเจนติกต่าง ๆ:

Microsoft Agent Framework

Microsoft Agent Framework เป็นเฟรมเวิร์ก AI แบบโอเพนซอร์สสำหรับสร้างอเจนต์ AI ทำให้ง่ายต่อการใช้การเรียกฟังก์ชันด้วยการกำหนดเครื่องมือเป็นฟังก์ชัน Python ที่มี @tool decorator เฟรมเวิร์กจะจัดการการสื่อสารระหว่างโมเดลกับโค้ดของคุณโดยอัตโนมัติ และยังให้เครื่องมือสำเร็จรูปอย่าง File Search และ Code Interpreter ผ่าน FoundryChatClient

แผนภาพต่อไปนี้แสดงกระบวนการเรียกฟังก์ชันกับ Microsoft Agent Framework:

function calling

กับ Microsoft Agent Framework เครื่องมือถูกกำหนดเป็นฟังก์ชันที่ถูกตกแต่ง เราสามารถแปลงฟังก์ชัน get_current_time ที่เห็นก่อนหน้านี้ให้เป็นเครื่องมือด้วย @tool decorator เฟรมเวิร์กจะทำการแปลงฟังก์ชันและพารามิเตอร์เป็นสคีมาเพื่อส่งให้ LLM โดยอัตโนมัติ

import os
from agent_framework import tool
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

@tool(approval_mode="never_require")
def get_current_time(location: str) -> str:
    """Get the current time for a given location"""
    ...

# สร้างไคลเอนต์
provider = FoundryChatClient(
    project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
    model=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
    credential=AzureCliCredential(),
)

# สร้างเอเจนต์และรันด้วยเครื่องมือ
agent = provider.as_agent(name="TimeAgent", instructions="Use available tools to answer questions.", tools=get_current_time)
response = await agent.run("What time is it?")

Microsoft Foundry Agent Service

Microsoft Foundry Agent Service เป็นเฟรมเวิร์กอเจนติกรุ่นใหม่ที่ออกแบบมาเพื่อช่วยนักพัฒนาในการสร้าง ปล่อย และขยายอเจนต์ AI ที่มีคุณภาพสูงและขยายได้อย่างปลอดภัยโดยไม่ต้องดูแลทรัพยากรคอมพิวเตอร์และจัดเก็บข้อมูลเบื้องหลัง เป็นประโยชน์อย่างยิ่งสำหรับแอปพลิเคชันองค์กรเพราะเป็นบริการที่ได้รับการบริหารจัดการเต็มรูปแบบพร้อมความปลอดภัยระดับองค์กร

เมื่อเปรียบเทียบกับการพัฒนาด้วย API LLM โดยตรง Microsoft Foundry Agent Service มีข้อดีหลายอย่าง รวมถึง:

เครื่องมือใน Microsoft Foundry Agent Service ถูกแบ่งออกเป็นสองประเภท:

  1. เครื่องมือความรู้:
  2. เครื่องมือปฏิบัติการ:

บริการ Agent นี้ช่วยให้เราสามารถใช้เครื่องมือเหล่านี้ร่วมกันเป็น toolset และยังใช้ threads เพื่อเก็บประวัติข้อความจากแต่ละการสนทนา

สมมติว่าคุณเป็นตัวแทนขายของบริษัท Contoso คุณต้องการพัฒนาอเจนต์สนทนาที่สามารถตอบคำถามเกี่ยวกับข้อมูลการขายของคุณ

ภาพต่อไปนี้แสดงวิธีที่คุณสามารถใช้ Microsoft Foundry Agent Service ในการวิเคราะห์ข้อมูลการขายของคุณ:

Agentic Service In Action

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

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from fetch_sales_data_functions import fetch_sales_data_using_sqlite_query # ฟังก์ชัน fetch_sales_data_using_sqlite_query ซึ่งสามารถพบได้ในไฟล์ fetch_sales_data_functions.py
from azure.ai.projects.models import ToolSet, FunctionTool, CodeInterpreterTool

project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=os.environ["PROJECT_CONNECTION_STRING"],
)

# เริ่มต้นชุดเครื่องมือ
toolset = ToolSet()

# เริ่มต้นตัวแทนเรียกใช้ฟังก์ชันด้วยฟังก์ชัน fetch_sales_data_using_sqlite_query และเพิ่มเข้าไปในชุดเครื่องมือ
fetch_data_function = FunctionTool(fetch_sales_data_using_sqlite_query)
toolset.add(fetch_data_function)

# เริ่มต้นเครื่องมือ Code Interpreter และเพิ่มเข้าไปในชุดเครื่องมือ
code_interpreter = CodeInterpreterTool()toolset.add(code_interpreter)

agent = project_client.agents.create_agent(
    model="gpt-5-mini", name="my-agent", instructions="You are helpful agent", 
    toolset=toolset
)

ข้อควรพิจารณาพิเศษสำหรับการใช้รูปแบบการออกแบบการใช้เครื่องมือเพื่อสร้างอเจนต์ AI ที่น่าเชื่อถือ

ความกังวลทั่วไปกับ SQL ที่สร้างแบบไดนามิกโดย LLM คือความปลอดภัย โดยเฉพาะความเสี่ยงของ SQL injection หรือการกระทำที่เป็นอันตราย เช่น การลบหรือแก้ไขฐานข้อมูล แม้ว่าความกังวลเหล่านี้จะมีเหตุผล แต่สามารถลดความเสี่ยงได้อย่างมีประสิทธิภาพด้วยการตั้งค่าการเข้าถึงฐานข้อมูลอย่างถูกต้อง สำหรับฐานข้อมูลส่วนใหญ่จะตั้งให้ฐานข้อมูลเป็นอ่านอย่างเดียว สำหรับบริการฐานข้อมูลเช่น PostgreSQL หรือ Azure SQL แอปควรได้รับบทบาทอ่านอย่างเดียว (SELECT)

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

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

มีคำถามเพิ่มเติมเกี่ยวกับรูปแบบการออกแบบการใช้เครื่องมือไหม?

เข้าร่วม Microsoft Foundry Discord เพื่อพบกับผู้เรียนคนอื่น เข้าร่วมชั่วโมงพูดคุย และถามคำถามเกี่ยวกับอเจนต์ AI ของคุณ

แหล่งข้อมูลเพิ่มเติม

การทดสอบแบบ Smoke-Testing สำหรับเอเจนต์นี้ (ไม่บังคับ)

หลังจากที่คุณเรียนรู้การปรับใช้เอเจนต์ในบทเรียนที่ Lesson 16 แล้ว คุณสามารถทดสอบแบบ smoke-test สำหรับ TravelToolAgent ของบทเรียนนี้ (มันยังคงเรียกใช้เครื่องมือและตอบคำถามไหม?) ด้วย tests/lesson-04-smoke-tests.json ดูที่ tests/README.md สำหรับวิธีการรัน

บทเรียนก่อนหน้า

การทำความเข้าใจรูปแบบการออกแบบเอเจนต์

บทเรียนถัดไป

Agentic RAG

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

This site is open source. Improve this page.