สำหรับ Gemini API ค่อนข้างอัปเดตอย่างต่อเนื่องเรียกว่าตื่นเต้นแทบทุกอาทิตย์เลย สำหรับสัปดาห์นี้เราจะได้รู้จักกับของเล่นใหม่อย่าง Interactions API ซึ่งเหมือน Google รู้ใจเราเสมอครับว่า การทำ AI Application จะมีปัญหาคลาสสิกอย่างนึงคือเรื่องจัดการ Memory หรือ State ครับ วันนี้เลยอยากจะมาชวนคุยว่า API ตัวใหม่นี้เจ๋งยังไง แล้วทำไม Gemini ถึงปฎิวัติวงการ AI (อีกแล้ว)
Interactions API คืออะไร?
ถ้าใครเคยใช้ Gemini API มาก่อน จะคุ้นเคยกับคำสั่ง generateContent ใช่ไหมครับ อันนั้นคือท่ามาตรฐาน ที่เราโยน Prompt ไป AI ตอบกลับมาแบบง่ายที่สุด แต่ปัญหาคือ มันเป็น Stateless ครับ
เดี๋ยวนะ … แล้ว Stateless คืออะไร ? เปรียบเหมือนคุยกับคนความจำสั้นครับ ทุกครั้งที่เริ่มคุยประโยคใหม่ เราต้องทวนความหลังทั้งหมด อารมณ์แบบส่ง Chat History ให้เขารู้เรื่องใหม่ทุกรอบ ซึ่งเปลือง Token มากและจัดการยากครับ แต่เมื่อก่อนก็ใช้ท่านี้กัน เช่น เก็บบทสนทนาไว้บน Firestore พอเริ่มต้นใหม่ก็ให้อ่าน History จาก Firestore เป็นต้นครับ
Interactions API เกิดมาเพื่อแก้ตรงนี้ มันถูกออกแบบมาเพื่อ Stateful Multi-turn Conversations โดยเฉพาะ คือ:
- Server-side State
Google จะช่วยจำบทสนทนาให้ เราไม่ต้องส่ง History ไป-กลับ เอง
(ใช้วิธีการ Passidเข้าไปในprevious_interaction_id) - Dedicated for Agents
ออกแบบมาเพื่อรองรับการทำงานแบบ Agent ที่ซับซ้อน เช่น การเรียกใช้ Tools หรือการค้นหาข้อมูล
เปรียบเทียบให้เห็นภาพ
แบบเดิม (generateContent)
Me : (เริ่มต้นบทสนทนา)
Agent: (ตอบ)
Me: (ส่ง history เก่าที่คุยกัน + คำถามใหม่)
Agent: (ตอบ)
แบบใหม่ (interactions)
สร้าง Session ID เดียว แล้วคุยต่อเนื่องได้เลย ระบบจัดการ Context ให้เอง
Use Cases และวิธีการใช้งาน
ความเจ๋งของ Interactions API คือมันรองรับ Use Cases ที่หลากหลายมากครับ มาดูกันทีละตัว
1. Use Case ทั่วไป
หากไม่ได้มี Use Case เฉพาะเจาะจง แบบ Agentic Mode เน้นสนทนาทั่วไป สามารถเขียนแบบง่าย ๆ แบบนี้ได้เลยครับ
from google import genai
GOOGLE_API_KEY = "<API KEY>"
client = genai.Client(api_key = GOOGLE_API_KEY)
# รอบที่ 1
interaction1 = client.interactions.create(
model="gemini-2.5-flash",
input="เรากำลังจัดทริปชื่อ โอซาก้าในฝันของฉันและทีม Cloud AI บอกเฉยๆ ไม่ต้องแพลนทริป"
)
print(f"Output 1: {interaction1.outputs[-1].text}")
print("--")
# รอบที่ 2 (ไม่ต้องส่งบริบทญี่ปุ่นไปซ้ำ ระบบจำได้)
interaction2 = client.interactions.create(
model="gemini-2.5-flash",
input="ชื่อทริปอะไรนะ?",
previous_interaction_id=interaction1.id
)
print(f"Output 2: {interaction2.outputs[-1].text}")
ความง่ายคือ Code เราจะสะอาดขึ้นเยอะครับ ไม่ต้องมี List เก็บ History หรือต่อ Database ไป Retrieve บทสนทนาเก่า
การเขียนแบบข้างบนเรียกว่า Stateful ใช้เทคนิคการ Pass id เข้าไปใน previous_interaction_id เราไม่ต้องจัดการบทสนทนาเลย ง่ายมาก ๆ ครับ
เรามาดูอีกตัวอย่างที่เรียกว่า Stateless คือการ Manual บทสนทนาแล้ว เหมาะกับมีการจัดการข้อความที่คุยกันแบบเฉพาะเจาะจง
# Stateless
from google import genai
GOOGLE_API_KEY = "<API KEY>"
client = genai.Client(api_key = GOOGLE_API_KEY)
conversation_history = [
{
"role": "user",
"content": "เรากำลังจัดทริปชื่อ โอซาก้าในฝันของฉันและทีม Cloud AI บอกเฉยๆ ไม่ต้องแพลนทริป"
}
]
interaction1 = client.interactions.create(
model="gemini-2.5-flash",
input=conversation_history
)
print(f"Model: {interaction1.outputs[-1].text}")
conversation_history.append({"role": "model", "content": interaction1.outputs})
conversation_history.append({
"role": "user",
"content": "ชื่อทริปอะไรนะ? ประเทศอะไร?"
})
interaction2 = client.interactions.create(
model="gemini-2.5-flash",
input=conversation_history
)
print(f"Model: {interaction2.outputs[-1].text}")
ก็เป็นอีกวิธีที่ทำงานร่วมกัน เช่น เราอยากจั่วหัวบทสนทนาก่อน หรือว่าใช้บนสนทนาจาก Session ก่อนหน้า เข้ามาคุยใน Session ใหม่ ก็จะทำให้บทสนทนา Session ใหม่ไหลลื่นยิ่งขึ้น (ประหยัด Prompt Token ได้แบบ Exponential เลยนะครับ)
2. เขียนแบบ Agentic AI
ปกติเวลาทำ Agentic AI เราก็จะไปยุ่งกับ Function Calling เป็นหลัก เช่น ให้ AI ไปดึงข้อมูลจาก Database หรือ API ภายนอก เราต้องเขียน Loop เช็คเองว่า AI ขอใช้ Tool ไหม? ถ้าใช้ ต้องเอาไปรัน แล้วส่งผลลัพธ์กลับมา ซึ่งตัว Interactions API ทำให้ Flow นี้สมูทขึ้นครับ
ลองทำ Use Case ไทย ๆ หน่อยแบบ AI ผู้ช่วยตรวจสอบงบประมาณแผ่นดิน โดยจะวิ่งไปดึงข้อมูลจริงจาก API กระทรวงการคลังแล้วช่วยสรุปตัวเลขที่ซับซ้อนให้อ่านง่ายๆ ครับ
แนวคิดคือ Agent รับ Prompt จากเรา แต่คำตอบนี้ต้องอาศัยการเรียก Tools ข้างนอกอีก เราเลย Call Tools ข้างนอก จากนั้นเอา Result ที่เป็น JSON ยิงไปที่ Gemini อีกครั้งเพื่อสรุปจาก Agent แบบงาม ๆ ครับ
import os
import requests
import json
from google import genai
from google.genai import types
from IPython.display import Markdown as md
GOOGLE_API_KEY = "<API KEY>"
client = genai.Client(api_key = GOOGLE_API_KEY)
# --- 1. Define Function ---
def get_thai_gov_expenditure (year: int = 2025):
"""
ดึงข้อมูลรายงานผลการเบิกจ่ายงบประมาณภาพรวม (รายจ่ายประจำ vs ลงทุน)
จาก dataservices.mof.go.th
"""
try:
# URL จากกระทรวงการคลัง
url = "https://dataservices.mof.go.th/api/data/expends/get_pay_account_job"
headers = {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)'
}
print(f"กำลังเชื่อมต่อฐานข้อมูลกระทรวงการคลัง... (Year: {year})")
response = requests.get(url, headers=headers, timeout=10)
if response.status_code == 200:
data = response.json()
return data
else:
return {"error": f"API Error: {response.status_code}", "status": "failed"}
except Exception as e:
return {"error": str(e), "status": "failed"}
# --- 2. Define Tool Schema ---
gov_budget_tool = {
"type": "function",
"name": "get_thai_gov_expenditure",
"description": "ดึงข้อมูลรายงานผลการเบิกจ่ายงบประมาณแผ่นดิน แยกตามรายจ่ายประจำและรายจ่ายลงทุน รวมถึงยอดงบประมาณรวม",
"parameters": {
"type": "object",
"properties": {
"year": {
"type": "integer",
"description": "ปีงบประมาณที่ต้องการตรวจสอบ (เช่น 2025, 2026) ถ้าไม่ระบุระบบจะดึงปีปัจจุบัน"
}
},
}
}
# --- 3. Start Interaction ---
print("--- เริ่มต้น Gov Data Analytics Agent ---")
model_id = "gemini-3-pro-preview"
user_prompt = "ช่วยสรุปสถานการณ์งบประมาณล่าสุดให้หน่อยครับ ว่าตอนนี้มีงบประจำและงบลงทุนเท่าไหร่ และยอดเบิกจ่ายสะสมเป็นกี่บาทแล้ว?"
interaction = client.interactions.create(
model=model_id,
input=user_prompt,
tools=[gov_budget_tool]
)
# --- 4. Handle Loop ---
for output in interaction.outputs:
if output.type == "function_call":
print(f"\n[AI Decision]: กำลังเรียกดูข้อมูลจากกระทรวงการคลัง...")
print(f"[Function]: {output.name}({output.arguments})")
if output.name == "get_thai_gov_expenditure":
# Execute Function
api_result = get_thai_gov_expenditure(**output.arguments)
print("[Data Fetched]: ได้ข้อมูลเรียบร้อย")
# Send Result Back
interaction = client.interactions.create(
model=model_id,
previous_interaction_id=interaction.id,
input=[{
"type": "function_result",
"name": output.name,
"call_id": output.id,
"result": api_result
}]
)
md(f"Response: {interaction.outputs[-1].text}")
3. Deep Research Agent
นี่คือสิ่งที่ผมตื่นเต้นที่สุดครับ! หลายคนน่าจะเคยเห็นฟีเจอร์ Deep Research ใน Gemini Advanced ที่มันค้นข้อมูลให้เราแบบลึกๆ อ่านเว็บให้เราเป็นสิบเป็นร้อยเว็บ แล้วสรุปมาให้ ตอนนี้เราเรียกใช้ผ่าน API ได้แล้วครับ
Deep Research เก่งกว่า Chatbot ทั่วไปยังไง
- Iterative Research Plan (วางแผนเองเป็น): มันไม่ได้แค่พุ่งไป Search เลยครับ แต่มันจะวางแผน ก่อนว่าโจทย์นี้ต้องหาข้อมูลด้านไหนบ้าง ต้องแตกประเด็นย่อยยังไง เหมือน Research Analyst มือโปรฯ
- Deep & Broad Browsing (อ่านเยอะ อ่านลึก): มันสามารถเข้าถึงเว็บไซต์ได้ “หลักร้อย” เว็บในการรันครั้งเดียว! ไม่ใช่แค่ดู Snippet หน้า Google แต่กดเข้าไปอ่านเนื้อหาข้างใน (Crawl) เพื่อหาข้อมูลที่ซ่อนอยู่
- Synthesis & Reporting (สรุปจบ ครบในที่เดียว): หลังจากกวาดข้อมูลมาแล้ว มันจะสังเคราะห์ (Synthesize) ข้อมูลจากหลายแหล่ง ตัดสิ่งที่ขัดแย้งกัน ตรวจสอบความถูกต้อง แล้วเขียนออกมาเป็น Report ขนาดยาวให้เรา
Deep Research Agent ทำงานยังไง ?
มันไม่ใช่แค่การ Search Google 1 ครั้งแล้วจบ แต่มันคือ Agent ที่รวมขั้นตอนหลาย ๆ อย่าง ดังนี้
- Plan: วางแผนว่าจะค้นหาอะไรบ้าง
- Browse: เข้าไปอ่านเนื้อหาในเว็บต่างๆ (Multi-step browsing)
- Synthesize: เอาข้อมูลจากหลายแหล่งมารวมกัน
- Report: เขียนสรุปออกมาเป็นรายงาน
ตัวอย่าง Prompt
- “ช่วยหาข้อมูลเปรียบเทียบ Market Share ของ Cloud Provider ในไทยย้อนหลัง 3 ปี พร้อมวิเคราะห์แนวโน้ม”
- “การวิเคราะห์เทรนด์ Technology และกฎระเบียบในภาคการเงินไทย (Banking)”
- “ช่วยหาซัพพลายเออร์ชิ้นส่วนรถยนต์ EV ในอาเซียน เปรียบเทียบราคา กำลังการผลิต และมาตรฐาน ISO ให้หน่อย”
ตัวอย่าง Use Case
เราสามารถประยุกต์กับข้อมูลในองค์กรได้ครับ เช่น
- ฝ่ายจัดซื้อ (Procurement): ให้ AI ช่วยทำ Vendor List เปรียบเทียบสินค้าจาก 50 บริษัท พร้อมตารางราคาและสเปก โดยที่เราไม่ต้องนั่งกดเอง
- ฝ่ายกลยุทธ์ (Strategy): วิเคราะห์ความเคลื่อนไหวของคู่แข่งในตลาดเครื่องดื่มชูกำลังช่วง 6 เดือนที่ผ่านมา โดยให้ AI ไปกวาดอ่านข่าว PR, รายงานประจำปี, บทวิเคราะห์หุ้น แล้วสรุปมาให้
- ฝ่ายขาย (Sales): ก่อนไปหาลูกค้า ให้ AI ทำ Client Brief เจาะลึกธุรกิจลูกค้า ปัญหาที่เขากำลังเจอ และโอกาสในการขายของเรา เตรียมไว้ให้ทีม Sale อ่านก่อนเข้าประชุมครับ
มาดูตัวอย่างโค้ดกันครับ
import time
from google import genai
from IPython.display import Markdown as md
GOOGLE_API_KEY = "<API KEY>"
client = genai.Client(api_key = GOOGLE_API_KEY)
# --- 1. กำหนดโจทย์ ---
# โจทย์นี้เราจะให้ Agent ไปหาข้อมูลที่ต้องรวมกันจากหลายแหล่ง:
# ทั้งข่าวธุรกิจ, ประกาศธนาคารแห่งประเทศไทย (ธปท.), และ Tech Blog
research_topic = """
ทำการวิจัยเชิงลึกเกี่ยวกับ 'แนวโน้มการนำ Generative AI มาประยุกต์ใช้ในภาคธนาคารของประเทศไทย ปี 2025-2026'
โดยขอให้ครอบคลุมหัวข้อดังนี้:
1. นโยบายและแนวทางการกำกับดูแลจาก ธนาคารแห่งประเทศไทย (BOT) เกี่ยวกับ AI ในภาคการเงิน
2. กรณีศึกษา (Use Cases) ที่น่าสนใจของธนาคารพาณิชย์ชั้นนำในไทย (เช่น SCB, KBank, Krungthai)
3. ความท้าทายเรื่อง PDPA และ Data Privacy ในบริบทของไทย
สรุปข้อมูลออกมาเป็นรายงานภาษาไทยที่มีโครงสร้างชัดเจน
"""
# --- 2. เริ่ม Research ---
print(f"--- เริ่มต้นภารกิจ Deep Research: {research_topic.splitlines()[1]} ---")
# สังเกต parameter 'background=True' นะครับ
# สำคัญมากสำหรับ Deep Research เพราะ Agent ต้องใช้เวลาอ่านเว็บเยอะมาก (อาจนาน 5-10 นาที)
# เราจึงสั่งแบบ Asynchronous (สั่งแล้วได้ ID มาถือไว้ก่อน)
initial_interaction = client.interactions.create(
input=research_topic,
agent="deep-research-pro-preview-12-2025", # ใช้ Model ตัวท็อปสำหรับงาน Research
background=True
)
print(f"Research Interaction ID: {initial_interaction.id}")
print(f"Agent is researching ..")
# --- 3. Poll for results ---
while True:
# เช็คสถานะงานด้วย ID ที่ได้มา
interaction = client.interactions.get(initial_interaction.id)
# แสดงสถานะปัจจุบัน (e.g., 'processing', 'completed')
print(f"Status Update: {interaction.status}")
if interaction.status == "completed":
print("\n" + "="*40)
print("✅ Final Research Report Complete!")
print("="*40)
# ผลลัพธ์จะเป็น Markdown ที่ยาวและละเอียดมาก
report_content = interaction.outputs[-1].text
md(report_content)
# บันทึกลงไฟล์ไว้อ่าน
with open("thai_banking_ai_research.md", "w", encoding="utf-8") as f:
f.write(report_content)
print("\n[System]: Saved thai_banking_ai_research.md to file!")
break
elif interaction.status == "failed":
print(f"❌ Research Failed. Error details: {interaction.error}")
break
# Deep Research ทำงานหนักครับ แนะนำให้หน่วงเวลา Poll นานหน่อย (เช่น 30 วินาที)
time.sleep(30)
Deep Research Agent: บน API vs บน Gemini App ต่างกันยังไง ?
หลายคนอาจสงสัยว่า “อ้าว ก็ใช้บนเว็บ Gemini ก็ได้นี่นา ทำไมต้องใช้ API?” ลองดูตารางนี้ครับ
ตัว APIs สามารถใช้ Tools file_search ได้ทำให้ Research กับไฟล์ในองค์กรได้ครับ ตาม docs นี้
พูดง่าย ๆ คือ API มันทำให้เราสร้าง นักวิจัยส่วนตัว ให้กับพนักงานในบริษัทเราได้เลยครับ โดยไม่ต้องให้พนักงานไปนั่งกดเอง
เปรียบเทียบ Gemini Deep Research Agent กับ Gemini Model
อย่างที่ Google แจ้งไว้เลยครับว่านี่คือ Agent ไม่ใช่ Model ซึ่งมันก็จะ based on Gemini Model อยู่ครับ ปัจจุบันใช้ Gemini 3 Pro และในมุมราคาก็จะราคาเท่า Model Gemini 3 Pro ทั่วไป และค่าเรียก Tools ต่างๆ ตามปกติครับ
สรุป
ส่วนตัวผมมองว่า Interactions API คือก้าวสำคัญที่ทำให้การพัฒนา AI Agent เข้าใกล้คำว่า Autonomous มากขึ้นครับ มันลดภาระงานถึกๆ (Boilerplate code) ของ Developer อย่างเรา ให้ไปโฟกัสที่ Logic และ Business Value แทน
ถ้าธุรกิจไหนกำลังมองหาทางที่จะเอา AI ไปช่วยงานที่ซับซ้อนกว่าแค่ถาม-ตอบ เช่น การวิจัยตลาดอัตโนมัติ หรือระบบ Customer Service ที่ทำรายการแทนลูกค้าได้จริง Interactions API ตัวนี้คือคำตอบที่น่าสนใจมากครับ
ใครที่อ่านแล้วคันไม้คันมืออยากลองของ หรืออยากรู้ว่าจะเอามาปรับใช้กับ Data ในองค์กรยังไง แวะมาคุยกับผมหรือทีม Tangerine ได้เสมอนะครับ เดี๋ยวพวกผมช่วยดูให้ว่าท่าไหนเวิร์กสุดครับ 😂
หน้าแรก 
โซลูชั่น 
โทร 
ติดต่อเรา