การเรียกใช้ฟังก์ชันและการผสานรวม API
เชี่ยวชาญการเขียนพรอมป์ให้ LLM เรียกใช้ฟังก์ชันหรือ API ภายนอก เพื่อให้โต้ตอบกับระบบในโลกจริงได้
การเรียกใช้ฟังก์ชันและการผสานรวม API เป็นบทเรียน AI Prompt Engineering ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Prompt Engineering และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 3 บทเรียน
เรียกใช้เครื่องมือภายนอก
LLM มีความทรงพลัง แต่โดยหลักแล้วทำงานอยู่ในโลกของข้อความ แล้วถ้า LLM ต้องการข้อมูลจากโลกจริงหรือต้องดำเนินการบางอย่างล่ะ
การเรียกใช้ฟังก์ชันช่วยให้ LLM โต้ตอบกับเครื่องมือภายนอกและส่วนต่อประสานโปรแกรมประยุกต์ได้ วิธีนี้เชื่อมช่องว่างระหว่างภาษาและการกระทำ ทำให้ AI สามารถ:
- get ข้อมูลปัจจุบัน (สภาพอากาศ ราคาหุ้น)
- ดำเนินการต่าง ๆ (ส่งอีเมล จองนัดหมาย)
- เชื่อมต่อกับฐานข้อมูลหรือเครื่องมือที่กำหนดเอง
วิธีนี้เปิดความเป็นไปได้ใหม่ ๆ ให้แก่ระบบ AI
บทบาทของ LLM: การเสนอการเรียกใช้
เมื่อคุณเปิดใช้การเรียกใช้ฟังก์ชัน คุณจะจัดเตรียมคำอธิบายของเครื่องมือ (ฟังก์ชัน) ที่พร้อมใช้งานให้ LLM
แทนที่จะตอบโดยตรง LLM อาจตัดสินใจว่าเครื่องมือหนึ่งสามารถช่วยได้ จากนั้น LLM จะส่ง "ข้อเสนอ" ที่มีโครงสร้างสำหรับการเรียกใช้ฟังก์ชัน ซึ่งรวมชื่อฟังก์ชันและอาร์กิวเมนต์ของฟังก์ชันนั้น
สำคัญ: LLM ไม่ได้ดำเนินการฟังก์ชันนั้นด้วยตนเอง แต่เพียงบอกแอปพลิเคชันของคุณว่าควรเรียกใช้ฟังก์ชันใดและใช้ข้อมูลนำเข้าอะไร
การกำหนดเครื่องมือของคุณ
หากต้องการใช้การเรียกใช้ฟังก์ชัน คุณต้องกำหนดเครื่องมือ (ฟังก์ชัน) ในรูปแบบที่ LLM เข้าใจได้ โดยปกติจะต้องจัดเตรียม:
- ชื่อของฟังก์ชัน (เช่น
get_current_weather) - คำอธิบายเกี่ยวกับสิ่งที่ฟังก์ชันทำ (มีความสำคัญต่อการที่ LLM จะเลือกได้อย่างถูกต้อง)
- พารามิเตอร์ที่ฟังก์ชันยอมรับ รวมถึงชนิดและคำอธิบายของพารามิเตอร์เหล่านั้น (เช่น
location: string)
"โครงร่าง" นี้จะบอกทุกสิ่งที่ LLM จำเป็นต้องรู้เพื่อเสนอการเรียกใช้ที่ถูกต้อง
การกำหนดเครื่องมือสภาพอากาศ
นี่คือตัวอย่างเชิงแนวคิดของการกำหนดเครื่องมือสภาพอากาศด้วย Python โปรดสังเกตคำอธิบายและพารามิเตอร์ที่ชัดเจน นี่คือสิ่งที่คุณจะเปิดให้ LLM ใช้งาน
ฟังก์ชันนี้เป็นตัวแทนของเครื่องมือภายนอกที่ LLM จะ "เรียกใช้" ในเชิงแนวคิด
def get_current_weather(location: str, unit: str = "celsius"):
"""
Get the current weather in a given location.
Args:
location (str): The city and state, e.g. "London, UK"
unit (str): The unit of temperature, "celsius" or "fahrenheit"
Returns:
dict: Weather information.
"""
# In a real app, this would call a weather API
if location == "London, UK":
return {"temperature": "15", "unit": unit, "forecast": "cloudy"}
elif location == "New York, USA":
return {"temperature": "20", "unit": unit, "forecast": "sunny"}
else:
return {"temperature": "N/A", "unit": unit, "forecast": "unknown"}
การสร้างคำสั่งสำหรับเครื่องมือ
เพื่อกระตุ้นให้ LLM ใช้เครื่องมือของคุณ คำสั่งของคุณต้องระบุเจตนาของผู้ใช้อย่างชัดเจน จากนั้น LLM จะตัดสินใจว่าเครื่องมือใดสามารถช่วยได้
คุณไม่ได้บอก LLM โดยตรงว่า "เรียกใช้ get_weather" แต่ให้ถามคำถามที่สื่อเป็นนัยว่าต้องการใช้เครื่องมือแทน:
- "สภาพอากาศในลอนดอนเป็นอย่างไรบ้าง"
- "คุณช่วยจองการประชุมให้ฉันในวันพรุ่งนี้ได้ไหม"
LLM ซึ่งมีคำอธิบายของเครื่องมืออยู่ จะอนุมานได้ว่าจำเป็นต้องเรียกใช้ฟังก์ชัน
ข้อเสนอการเรียกใช้ของ LLM
เมื่อ LLM ตัดสินใจใช้เครื่องมือ LLM จะไม่ให้คำตอบโดยตรง แต่จะส่งออบเจ็กต์ที่มีโครงสร้าง โดยทั่วไปอยู่ในรูปแบบเจสัน เพื่อระบุฟังก์ชันที่จะเรียกใช้และอาร์กิวเมนต์ของฟังก์ชันนั้น
จากนั้นแอปพลิเคชันของคุณจะแยกวิเคราะห์ผลลัพธ์นี้
นี่คือตัวอย่างสิ่งที่ LLM อาจเสนอเมื่อถูกถามว่า "สภาพอากาศในลอนดอนเป็นอย่างไร"
{
"tool_calls": [
{
"id": "call_abc123",
"function": {
"name": "get_current_weather",
"arguments": "{\"location\": \"London, UK\", \"unit\": \"celsius\"}"
},
"type": "function"
}
]
}แอปของคุณเรียกใช้เครื่องมือ
เมื่อได้รับข้อเสนอการเรียกใช้ฟังก์ชันจาก LLM แอปพลิเคชันของคุณจะเข้ามาดำเนินการต่อ:
- ระบุฟังก์ชันที่ร้องขอ (เช่น
get_current_weather) - ดึงอาร์กิวเมนต์ออกมา (เช่น
"London, UK") - ดำเนินการฟังก์ชัน Python จริง (หรือเรียกใช้ส่วนต่อประสานโปรแกรมประยุกต์) ภายในสภาพแวดล้อมของแอปพลิเคชัน
การกระทำใน "โลกจริง" เกิดขึ้นที่จุดนี้ภายนอก LLM
LLM ประมวลผลผลลัพธ์จากเครื่องมือ
หลังจากแอปพลิเคชันของคุณดำเนินการฟังก์ชันแล้ว แอปพลิเคชันจะได้รับผลลัพธ์ (เช่น {"temperature": "15", ...})
จากนั้นผลลัพธ์นี้จะถูกส่งกลับไปยัง LLM พร้อมกับประวัติการสนทนาเดิมและคำขอเรียกใช้ฟังก์ชัน
LLM จะใช้ข้อมูลใหม่นี้เพื่อสร้างคำตอบภาษาธรรมชาติสำหรับคำถามเดิมของผู้ใช้
การโต้ตอบตั้งแต่ต้นจนจบ
ลองนำทุกอย่างมาประกอบกัน ตัวอย่างนี้แสดงขั้นตอนการทำงานที่คำถามของผู้ใช้กระตุ้นให้ LLM เสนอการเรียกใช้ฟังก์ชัน จากนั้นแอปของคุณดำเนินการ และ LLM จึงให้คำตอบสุดท้าย
นี่คือการนำเสนอวงจรการโต้ตอบแบบง่าย
def get_current_weather(location, unit="celsius"):
if location == "London, UK":
return {"temp": "15", "unit": unit, "forecast": "cloudy"}
return {"temp": "N/A", "unit": unit, "forecast": "unknown"}
def simulate_llm_response(user_query):
# LLM 'thinks' and decides to call a tool
if "weather in London" in user_query:
return {
"type": "tool_call",
"function": "get_current_weather",
"args": {"location": "London, UK"}
}
return {"type": "text", "content": "I cannot help with that."}
def simulate_llm_final_response(tool_output):
# LLM processes tool output and gives natural language
temp = tool_output.get("temp", "N/A")
forecast = tool_output.get("forecast", "unknown")
return f"The weather in London is {temp} degrees and {forecast}."
def main():
user_input = "What is the weather in London, UK?"
print(f"User: {user_input}")
llm_output = simulate_llm_response(user_input)
if llm_output["type"] == "tool_call":
func_name = llm_output["function"]
func_args = llm_output["args"]
print(f"LLM suggested calling: {func_name}({func_args})")
# Execute the function
tool_result = get_current_weather(**func_args)
print(f"Tool output: {tool_result}")
# Feed result back to LLM
final_answer = simulate_llm_final_response(tool_result)
print(f"LLM's final answer: {final_answer}")
else:
print(f"LLM: {llm_output['content']}")
if __name__ == "__main__":
main()
ตรวจสอบการเรียกใช้ฟังก์ชัน
ลองจินตนาการว่า LLM ส่งคำขอเรียกใช้ฟังก์ชันกลับมา ขั้นตอนถัดไปในทันทีที่แอปพลิเคชันของคุณควรดำเนินการคืออะไร
สรุป: เครื่องมือในการทำงาน
ในบทเรียนนี้ เราได้สำรวจว่า LLM สามารถโต้ตอบกับโลกจริงผ่านการเรียกใช้ฟังก์ชันและการผสานรวมส่วนต่อประสานโปรแกรมประยุกต์ได้อย่างไร
เราได้เรียนรู้ว่า:
- คุณกำหนดเครื่องมือ (ฟังก์ชัน) พร้อมคำอธิบายและพารามิเตอร์
- LLM เสนอว่าจะเรียกใช้เครื่องมือใดและใช้อาร์กิวเมนต์ใด
- แอปพลิเคชันของคุณดำเนินการเครื่องมือจริงและส่งผลลัพธ์กลับไป
- จากนั้น LLM จะใช้ผลลัพธ์เพื่อร่างคำตอบสุดท้ายที่มีข้อมูลประกอบ
เทคนิคอันทรงพลังนี้ช่วยให้ LLM ทำได้มากกว่าการสร้างข้อความเพียงอย่างเดียว โดยทำให้ LLM ดำเนินการและเรียกดูข้อมูลล่าสุดได้
คำถามที่พบบ่อย
บทเรียน “การเรียกใช้ฟังก์ชันและการผสานรวม API” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การเรียกใช้ฟังก์ชันและการผสานรวม API” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Prompt Engineering ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 3 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การเรียกใช้ฟังก์ชันและการผสานรวม API”
เชี่ยวชาญการเขียนพรอมป์ให้ LLM เรียกใช้ฟังก์ชันหรือ API ภายนอก เพื่อให้โต้ตอบกับระบบในโลกจริงได้ คุณปฏิบัติ AI Prompt Engineering ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Prompt Engineering หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Prompt Engineering บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน
บทเรียน “การเรียกใช้ฟังก์ชันและการผสานรวม API” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน AI Prompt Engineering นี้ได้ไหม
ได้ บทเรียน AI Prompt Engineering ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การเรียกใช้ฟังก์ชันและการผสานรวม API
- ระบบการเขียนพรอมป์แบบหลายเอเจนต์
- เครื่องมือและปลั๊กอินแบบกำหนดเองสำหรับ LLM