---
title: "Function calling (LLM) (TH)"
source: "https://systems-analysis.info/int/Function_calling_(LLM)_(TH)"
wiki: "systems-analysis.info/int"
article: "Function_calling_(LLM)_(TH)"
language: "th"
categories:
  - "Category:Large language models"
  - "Category:Machine learning"
  - "Category:Prompt engineering"
  - "Category:Thai"
revision_id: 2338
wiki_created_at: 2026-09-06T23:02:22Z
wiki_modified_at: 2026-09-06T23:02:22Z
downloaded_at: 2026-09-07T22:50:34Z
---

# Function calling (LLM) (TH)

**Function Calling** (**การเรียกใช้ฟังก์ชัน**) — คือกลไกในโมเดลภาษาขนาดใหญ่ (LLM) ที่ช่วยให้โมเดลสามารถโต้ตอบกับเครื่องมือภายนอกและ API ได้ โดยการสร้างข้อมูลที่มีโครงสร้าง (โดยทั่วไปคือ JSON) เพื่อเรียกใช้ฟังก์ชันแทนที่จะตอบกลับเป็นข้อความโดยตรง<sup>[\[1\]](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_note-hopsworks_whatis-1)</sup>

กล่าวอีกนัยหนึ่ง โมเดลจะพิจารณาจากคำขอของผู้ใช้ว่าควรเรียกใช้ฟังก์ชันใดจากชุดที่กำหนดไว้และด้วยพารามิเตอร์ใด กลไกนี้ขยายขอบเขตการใช้งาน LLM โดยทำให้สามารถทำหน้าที่เป็นอินเทอร์เฟซระหว่างภาษาธรรมชาติและการกระทำจริง ซึ่งเปิดโอกาสให้บูรณาการ AI เข้ากับระบบภายนอก ได้แก่ โมเดลสามารถดึงข้อมูลที่ทันสมัย ดำเนินการต่าง ๆ หรือใช้บริการต่าง ๆ ซึ่งมีคุณค่าอย่างยิ่งในการสร้างผู้ช่วยอัจฉริยะและตัวแทนอัตโนมัติ การใช้เครื่องมือภายนอกยังช่วยลดความเสี่ยงของการเกิด hallucination (ข้อเท็จจริงที่แต่งขึ้น) ด้วยการอ้างอิงแหล่งข้อมูลที่น่าเชื่อถือ<sup>[\[2\]](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_note-dark_side_paper-2)</sup>

## ประวัติและแนวทางการพัฒนา

### แนวทางยุคแรก (prompting และ Toolformer)

แนวคิดในการสอนโมเดลภาษาให้เรียกใช้เครื่องมือเริ่มก่อตัวขึ้นในช่วงปี 2022–2023 แนวทางยุคแรกอาศัยเทคนิคการทำ prompt ที่ซับซ้อน โดยในปี 2022 ได้มีการเสนอรูปแบบ **ReAct** ซึ่งโมเดลจะสลับกันระหว่างการใช้เหตุผลและการกระทำ (การเรียกใช้เครื่องมือ) ในระหว่างการสนทนา โดยทั้งหมดถูกเข้ารหัสในข้อความเดียวกัน

ก้าวสำคัญคือการปรากฏตัวของโมเดล **Toolformer** ที่นักวิจัยจาก Meta นำเสนอในต้นปี 2023 Toolformer แสดงให้เห็นว่า LLM สามารถ fine-tuning เป็นพิเศษเพื่อให้เรียกใช้เครื่องมือภายนอก (เครื่องคิดเลข เครื่องมือค้นหา ปฏิทิน) ได้อย่างอิสระตามคำใบ้เป็นข้อความ โดยแทรก token พิเศษสำหรับการเรียก API ลงในข้อความที่สร้างขึ้น<sup>[\[3\]](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_note-toolformer_paper-3)</sup>

### การรองรับอย่างเป็นทางการและการพัฒนาต่อเนื่อง

จุดเปลี่ยนสำคัญเกิดขึ้นเมื่อ OpenAI ได้เปิดตัวการรองรับ Function Calling อย่างเป็นทางการใน API สำหรับโมเดล GPT-3.5 และ GPT-4 ในเดือนมิถุนายน 2023<sup>[\[4\]](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_note-openai_fc_announcement-4)</sup> โมเดลเวอร์ชันใหม่ได้รับการ fine-tuning ให้จดจำสถานการณ์ที่คำขอของผู้ใช้ต้องการการเรียกใช้ฟังก์ชันภายนอก และสร้าง JSON object ที่มีโครงสร้างถูกต้องพร้อมอาร์กิวเมนต์ OpenAI เรียกความสามารถนี้ว่า "วิธีใหม่ในการเชื่อมต่อ GPT กับเครื่องมือภายนอกและ API อย่างน่าเชื่อถือ"

### โครงการโอเพนซอร์ส

หลังจากการพัฒนาเชิงพาณิชย์ ก็ปรากฏโมเดลโอเพนซอร์สที่ผ่านการ fine-tuning เพื่อการสร้างการเรียกใช้ฟังก์ชันที่ถูกต้อง

- **Gorilla**: โครงการจาก UC Berkeley ซึ่งเป็นเวอร์ชัน fine-tuning ของ LLaMA ที่สามารถสร้างการเรียกใช้ API หลายพันรายการ เพื่อการประเมินโมเดลเหล่านี้จึงได้สร้าง benchmark ชื่อ Berkeley Function-Calling Leaderboard<sup>[\[5\]](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_note-gorilla_site-5)</sup>
- **ToolAlpaca**, **ToolLLaMA**, **Hermes**: ชุดโมเดลโอเพนซอร์สที่ผ่านการ fine-tuning บนตัวอย่างการเรียกใช้ฟังก์ชันแบบสังเคราะห์ ซึ่งมักสร้างโดยโมเดลที่มีความสามารถสูงกว่า

## กลไกการทำงาน

กระบวนการใช้งาน Function Calling โดยทั่วไปประกอบด้วยหลายขั้นตอน:

1.  **การกำหนดฟังก์ชัน** นักพัฒนากำหนดชุดฟังก์ชันที่โมเดลสามารถใช้งานได้ล่วงหน้า (เช่น API ภายนอก) และอธิบาย signature และวัตถุประสงค์ของฟังก์ชันเหล่านั้น โดยทั่วไปในรูปแบบ JSON Schema
2.  **การวิเคราะห์คำขอ** ระหว่างการสนทนา โมเดลจะวิเคราะห์เจตนาของผู้ใช้และตัดสินใจด้วยตัวเองว่าควรเรียกใช้ฟังก์ชันใดฟังก์ชันหนึ่งที่กำหนดไว้เพื่อตอบสนองหรือไม่
3.  **การสร้างการเรียกใช้** หากต้องการการกระทำ LLM จะสร้างผลลัพธ์แบบมีโครงสร้างพิเศษ (เช่น JSON ที่มีชื่อฟังก์ชันและอาร์กิวเมนต์) แทนที่จะเป็นข้อความธรรมดา หากไม่จำเป็นต้องเรียกใช้ โมเดลจะส่งคืนคำตอบเป็นข้อความธรรมดา
4.  **การประมวลผลฟังก์ชัน** โปรแกรมภายนอก (shell ของ chatbot หรือ agent) จะรับ JSON ดำเนินการเรียกใช้ฟังก์ชันที่ระบุจริงด้วยพารามิเตอร์ที่เสนอ และส่งผลลัพธ์กลับไปยังโมเดล
5.  **การสร้างคำตอบสุดท้าย** โมเดลใช้ข้อมูลที่ได้รับเพื่อสร้างคำตอบสุดท้ายให้กับผู้ใช้<sup>[\[4\]](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_note-openai_fc_announcement-4)</sup>

สำหรับการจัดการกระบวนการหลายขั้นตอนนี้ในระหว่างการฝึกโมเดล จะใช้รูปแบบการสนทนาพิเศษ เช่น ChatML markup จาก OpenAI ซึ่งนอกจากบทบาท "ผู้ใช้" และ "ผู้ช่วย" แล้ว ยังมีการเพิ่มบทบาท "ฟังก์ชัน" สำหรับการส่งผลลัพธ์ของการเรียกใช้

## การประยุกต์ใช้และข้อดี

ความสามารถในการเรียกใช้ฟังก์ชันขยายขอบเขตงานที่สามารถแก้ไขได้ด้วย LLM อย่างมีนัยสำคัญ

- **การบูรณาการกับ API ภายนอก** โมเดลสามารถตอบสนองต่อคำขอที่ต้องการข้อมูลทันสมัยโดยการเรียกใช้บริการภายนอก (เช่น สำหรับการดึงข้อมูลสภาพอากาศ อัตราแลกเปลี่ยน ข่าวสาร)
- **การทำงานอัตโนมัติของผู้ใช้** LLM สามารถดำเนินงานประจำได้แก่ ส่งอีเมล สร้างกิจกรรมในปฏิทิน สั่งซื้อในร้านค้าออนไลน์
- **การเข้าถึงฐานข้อมูลและการวิเคราะห์** คำขอในภาษาธรรมชาติสามารถแปลงเป็นการเรียกใช้ API ภายในหรือ SQL query เพื่อดึงและวิเคราะห์ข้อมูล
- **การดึงข้อมูลที่มีโครงสร้าง** LLM สามารถดึงข้อเท็จจริงจากข้อความยาว (เช่น ชื่อ วันที่ ที่อยู่) ด้วยตัวเองและส่งคืนในรูปแบบ JSON array ที่มีโครงสร้างซึ่งสะดวกสำหรับการประมวลผลด้วยโปรแกรมในภายหลัง

## ปัญหาด้านความปลอดภัย

ขณะที่ขยายขีดความสามารถของโมเดล Function Calling ก็นำมาซึ่งความเสี่ยงใหม่ด้วยเช่นกัน

- **ผลลัพธ์ที่ไม่ได้รับการตรวจสอบ** การโต้ตอบของโมเดลกับเครื่องมือภายนอกต้องได้รับการปกป้องอย่างรอบคอบ หากโมเดลได้รับค่าที่เป็นอันตรายหรือผิดพลาดจาก API ก็อาจรวมค่านั้นไว้ในคำตอบหรือเรียกใช้ฟังก์ชันอื่นโดยอิงจากค่านั้น ซึ่งนำไปสู่ผลลัพธ์ที่คาดเดาไม่ได้
- **การโจมตีผ่านอาร์กิวเมนต์ของฟังก์ชัน** นักวิจัยค้นพบช่องโหว่เฉพาะในโหมด Function Calling ในปี 2025 มีการสาธิตการโจมตีที่เรียกว่า "The Dark Side of Function Calling" แก่นของการโจมตีคือการเสนอ "ฟังก์ชัน" พิเศษแก่โมเดล ซึ่งภายในอาร์กิวเมนต์จะซ่อนคำสั่งต้องห้าม (*jailbreak payload*) โมเดลเมื่อทำตามหลักการเรียกใช้ฟังก์ชันจะสร้างอาร์กิวเมนต์ที่มีเนื้อหาละเมิดกฎ และด้วยเหตุนี้จึงหลีกเลี่ยงตัวกรองการกลั่นกรองได้ การทดสอบแสดงให้เห็นว่าการโจมตีประสบความสำเร็จมากกว่า **90%** ของกรณีในโมเดลสมัยใหม่หกรุ่น รวมถึง GPT-4 และ Claude<sup>[\[2\]](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_note-dark_side_paper-2)</sup>

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

## ลิงก์

- ประกาศ Function Calling อย่างเป็นทางการจาก OpenAI
- หน้าโครงการ Gorilla LLM
- Apideck (2024). *An Introduction to Function Calling and Tool Use*. Apideck Blog.
- LangChain (2025). *Tool Calling (Documentation)*. LangChain Docs.
- Mistral AI (2025). *Function Calling – Documentation*. Mistral Docs.
- Hopsworks (2024). *What is Function Calling with LLMs?*. Hopsworks Dictionary.
- Hopsworks (2024). *Unlocking the Power of Function Calling with LLMs*. Hopsworks Blog.
- University of California, Berkeley (2025). *Berkeley Function Calling Leaderboard V3*. Online Resource.

## เอกสารอ้างอิง

- Wu, Z. et al. (2025). *The Dark Side of Function Calling: Pathways to Jailbreaking Large Language Models*. ACL 2025.
- OpenAI (2023). *Function Calling and Other API Updates*. OpenAI Blog.
- Schick, T. et al. (2023). *Toolformer: Language Models Can Teach Themselves to Use Tools*. arXiv:2302.04761.
- Patil, S. G. et al. (2023). *Gorilla: Large Language Model Connected with Massive APIs*. arXiv:2305.15334.
- Liu, W. et al. (2024). *ToolACE: Winning the Points of LLM Function Calling*. arXiv:2409.00920.
- Yao, S. et al. (2022). *ReAct: Synergizing Reasoning and Acting in Language Models*. arXiv:2210.03629.

## หมายเหตุ

1.  <span id="cite_note-hopsworks_whatis-1">[↑](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_ref-hopsworks_whatis_1-0) «What is Function Calling with LLMs?». *Hopsworks*. <a href="https://www.hopsworks.ai/dictionary/function-calling-with-llms" class="external autonumber" rel="nofollow">[1]</a></span>
2.  <span id="cite_note-dark_side_paper-2">↑ <sup>[2.0](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_ref-dark_side_paper_2-0)</sup> <sup>[2.1](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_ref-dark_side_paper_2-1)</sup> Wu, Z. et al. «The Dark Side of Function Calling: Pathways to Jailbreaking Large Language Models». *Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing*, 2025. <a href="https://aclanthology.org/2025.coling-main.39.pdf" class="external autonumber" rel="nofollow">[2]</a></span>
3.  <span id="cite_note-toolformer_paper-3">[↑](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_ref-toolformer_paper_3-0) Schick, T. et al. «Toolformer: Language Models Can Teach Themselves to Use Tools». *arXiv:2302.04761*, 2023. <a href="https://arxiv.org/abs/2302.04761" class="external autonumber" rel="nofollow">[3]</a></span>
4.  <span id="cite_note-openai_fc_announcement-4">↑ <sup>[4.0](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_ref-openai_fc_announcement_4-0)</sup> <sup>[4.1](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_ref-openai_fc_announcement_4-1)</sup> «Function calling and other API updates». *OpenAI*, 2023. <a href="https://openai.com/index/function-calling-and-other-api-updates/" class="external autonumber" rel="nofollow">[4]</a></span>
5.  <span id="cite_note-gorilla_site-5">[↑](https://systems-analysis.info/int/Function_calling_(LLM)_(TH)#cite_ref-gorilla_site_5-0) «Gorilla: Large Language Model Connected to Massive APIs». *University of California, Berkeley*. <a href="https://gorilla.cs.berkeley.edu/" class="external autonumber" rel="nofollow">[5]</a></span>