คู่มือ LangChain Deep Agents: ฟีเจอร์ เครื่องมือ และการตั้งค่า

สร้าง AI agent ที่มีความสามารถมากขึ้นด้วย LangChain Deep Agents เรียนรู้ว่าการวางแผน การเรียกใช้เครื่องมือ การจัดการไฟล์ระบบ และเวิร์กโฟลว์ของ subagent ช่วยให้ทำงานได้อย่างอิสระได้อย่างไร จากนั้นเชื่อมต่อ Kimi API เพื่อเสริมพลังให้ agent ของคุณด้วยความสามารถด้านความเข้าใจภาษาและการให้เหตุผลขั้นสูง

รับ Kimi API Key ของคุณ

12 นาทีในการอ่าน2026-08-14

เชื่อมต่อ Kimi API กับ LangChain Deep Agents

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

LangChain Deep Agents คืออะไร?

LangChain Deep Agents เป็นเฟรมเวิร์ก agent ที่สร้างขึ้นบนบล็อกพื้นฐานหลักของ LangChain และรันไทม์ LangGraph โดยขยายเวิร์กโฟลว์ agent มาตรฐานด้วยความสามารถที่มีมาในตัว เช่น การเข้าถึงไฟล์ระบบ การมอบหมายงานให้ subagent การวางแผน memory และการรองรับ human-in-the-loop Deep Agents ใช้ agent loop ที่ผสมผสานการให้เหตุผล การเรียกใช้เครื่องมือ และการทำงานแบบวนซ้ำ ทำให้เหมาะกับงานที่ซับซ้อนซึ่งต้องใช้หลายขั้นตอน มีข้อมูล context จำนวนมาก และต้องมีการประสานงานที่เป็นระบบ

ต่างจาก agent พื้นฐานที่ส่วนใหญ่เรียกใช้เครื่องมือแบบวนซ้ำง่าย ๆ Deep Agents มีโครงสร้างพื้นฐานเพิ่มเติมสำหรับจัดการงานที่ใช้เวลานาน สามารถจัดการไฟล์ มอบหมายงานให้ subagent ที่เชี่ยวชาญ คงข้อมูล context ไว้ตลอดเวิร์กโฟลว์ที่ซับซ้อน และเปิดให้มนุษย์เข้ามาแทรกแซงได้เมื่อจำเป็น ความสามารถที่มีมาในตัวเหล่านี้ช่วยลดปริมาณงานวิศวกรรมแบบกำหนดเองที่ต้องทำเมื่อสร้างระบบ agent ขั้นสูง

LangChain Deep Agents ทำงานอย่างไร

เมื่อ Deep Agent ได้รับงาน จะวิเคราะห์คำขอและวางแผนขั้นตอนที่ต้องทำเพื่อให้งานเสร็จสมบูรณ์ จากนั้นจะใช้เครื่องมือที่มีอยู่ เช่น การค้นหา การรันโค้ด หรือการดำเนินการกับไฟล์ระบบ เพื่อรวบรวมข้อมูลและดำเนินการต่าง ๆ

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

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

ด้วยฟีเจอร์ต่าง ๆ เช่น การวางแผน การใช้เครื่องมือ การจัดการไฟล์ระบบ การทำงานร่วมกันของ subagent และการควบคุมดูแลโดยมนุษย์ LangChain Deep Agents เป็นพื้นฐานสำหรับการสร้างระบบ AI ที่มีความสามารถมากขึ้น ซึ่งจัดการงานในโลกจริงที่ต้องใช้หลายขั้นตอนได้

ความสามารถหลักของ Deep Agents: การวางแผน เครื่องมือ และการดำเนินการ

Deep Agents สามารถจัดการงานที่ต้องใช้หลายขั้นตอน การตัดสินใจ และการดำเนินการ ฟีเจอร์หลักของมันช่วยให้วางแผนงาน ใช้เครื่องมือที่เหมาะสม และทำแต่ละขั้นตอนให้เสร็จอย่างมีประสิทธิภาพโดยต้องอาศัยการป้อนข้อมูลจากมนุษย์น้อยลง มาดูความสามารถเหล่านี้กันในรายละเอียด:

การวางแผนงาน

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

เมื่อใดควรใช้การวางแผน

งานหลายขั้นตอนที่ยาวหรือซับซ้อน
งานที่ได้ประโยชน์จากการติดตามความคืบหน้าอย่างชัดเจนและการดำเนินงานที่มีโครงสร้าง
UI ที่แสดงความคืบหน้าแบบสตรีมจากสถานะของ agent

วิธีเปิดใช้งาน

ส่ง TodoListMiddleware ไปยังพารามิเตอร์ middleware วิธีนี้จะให้เครื่องมือ write_todos แก่ agent สำหรับดูแลรายการงานที่มีโครงสร้าง พร้อมการติดตามสถานะ (pending, in_progress, completed)

from deepagents import create_deep_agent
from deepagents.middleware import TodoListMiddleware

agent = create_deep_agent(
    model="your-model",
    middleware=[TodoListMiddleware()],
)

งานต่าง ๆ จะถูกบันทึกไว้ใน state ของ agent ทำให้ agent มีเลเยอร์การวางแผนแบบเบา ๆ สำหรับจัดการงานที่ใช้เวลานาน

เครื่องมือระบบไฟล์เสมือน

Deep Agents มีระบบไฟล์เสมือนที่ปรับแต่งได้ โดยรองรับ backend หลายรูปแบบ เช่น state ในหน่วยความจำ, ดิสก์ในเครื่อง, LangGraph store, การจัดเส้นทางแบบผสม (composite routing) หรือ backend ที่กำหนดเองพร้อมกฎการอนุญาต

เครื่องมือระบบไฟล์ที่มีมาให้ในตัว

เครื่องมือ	คำอธิบาย
`ls`	แสดงรายการไฟล์ในไดเรกทอรีพร้อมข้อมูลเมตา (ขนาด, เวลาที่แก้ไขล่าสุด)
`read_file`	อ่านเนื้อหาไฟล์พร้อมเลขบรรทัด รองรับ offset/limit สำหรับไฟล์ขนาดใหญ่ และยังคืนบล็อกเนื้อหาแบบมัลติโมดัลสำหรับภาพ วิดีโอ เสียง และเอกสาร
`write_file`	สร้างไฟล์ใหม่หรือเขียนทับไฟล์ที่มีอยู่
`edit_file`	แทนที่ข้อความในไฟล์แบบตรงตัว (พร้อมโหมดแทนที่ทั้งหมด)
`delete`	ลบไฟล์หรือไดเรกทอรีแบบครอบคลุมทั้งหมด
`glob`	ค้นหาไฟล์ที่ตรงกับรูปแบบ (เช่น `*/.py`)
`grep`	ค้นหาเนื้อหาไฟล์ด้วยรูปแบบการแสดงผลหลายแบบ
`execute`	รันคำสั่ง shell ในสภาพแวดล้อม (เฉพาะ backend แบบ sandbox)

นามสกุลไฟล์มัลติโมดัลที่รองรับ

ภาพ: .png, .jpg, .jpeg, .gif, .webp, .heic, .heif
วิดีโอ: .mp4, .mpeg, .mov, .avi, .flv, .mpg, .webm, .wmv, .3gpp
เสียง: .wav, .mp3, .aiff, .aac, .ogg, .flac
เอกสาร: .pdf, .ppt, .pptx

สิทธิ์การเข้าถึงระบบไฟล์

Harness รองรับกฎสิทธิ์การเข้าถึงแบบ declarative ที่ควบคุมว่าไฟล์และไดเรกทอรีใดบ้างที่ agent สามารถอ่านหรือเขียนได้ กฎจะถูกประเมินจากบนลงล่างตามหลัก first-match-wins

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:your-model",
    permissions=[
        {"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
        {"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
    ],
)

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:your-model",
    permissions=[
        {"operations": ["read", "write"], "paths": ["/workspace/**"], "mode": "allow"},
        {"operations": ["read"], "paths": [".env", "**/secrets/**"], "mode": "deny"},
    ],
)

สิ่งนี้ช่วยให้คุณจำกัด agent ให้เข้าถึงได้เฉพาะไดเรกทอรีที่กำหนด ปกป้องไฟล์สำคัญ และให้ subagent มีสิทธิ์เข้าถึงที่แคบกว่า agent หลัก

การจำกัดการเข้าถึงเครื่องมือ

คุณสามารถเปิดให้ใช้เฉพาะบางส่วนของเครื่องมือระบบไฟล์ได้ โดยส่ง allowlist ของ tools ไปยัง FilesystemMiddleware โดยต้องรวม read_file ไว้ทุกครั้ง

from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware

# Read-only agent
agent = create_deep_agent(
    model="your-model",
    middleware=[
        FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
    ],
)

from deepagents import create_deep_agent
from deepagents.middleware import FilesystemMiddleware

# Read-only agent
agent = create_deep_agent(
    model="your-model",
    middleware=[
        FilesystemMiddleware(backend=backend, tools=["read_file", "ls", "glob", "grep"]),
    ],
)

Subagent (การมอบหมายงาน)

Harness มีเครื่องมือ task ที่ติดตั้งมาให้ในตัว ซึ่งช่วยให้ agent หลักสร้าง subagent แบบชั่วคราวสำหรับงานที่ต้องแยกส่วน ใช้เวลานาน มีหลายขั้นตอน หรือทำงานแบบพร้อมกัน

ลักษณะสำคัญ

Context ใหม่: การเรียกใช้แต่ละครั้งจะสร้าง agent instance ใหม่ที่มี context เป็นของตัวเอง
ทำงานอย่างอิสระ: subagent จะทำงานอย่างเป็นอิสระไปจนเสร็จสมบูรณ์
ส่งมอบผลลัพธ์เพียงครั้งเดียว: จะส่งรายงานสุดท้ายเพียงชิ้นเดียวกลับไปยัง agent หลัก
กำหนดกลยุทธ์ได้: ใช้ subagent แบบ general-purpose ที่เป็นค่าเริ่มต้น หรือกำหนด subagent เองก็ได้
ประสิทธิภาพด้าน context: งานย่อยที่หนักจะถูกแยกเก็บไว้ต่างหากและถูกบีบอัดเป็นผลลัพธ์ที่กระชับ

การปิดใช้งาน subagent

หากต้องการรัน agent โดยไม่ใช้เครื่องมือ task ให้ปิดการเพิ่ม subagent อัตโนมัติผ่าน harness profile และไม่ส่ง subagent แบบ synchronous ผ่าน subagents= อย่าพยายามลบ SubAgentMiddleware ผ่าน excluded_middleware เพราะการทำเช่นนั้นจะถูกปฏิเสธโดยตั้งใจ

ความสามารถในการเรียกใช้เครื่องมือ

Deep Agents รองรับเครื่องมือสามประเภท ได้แก่:

ฟังก์ชันแบบกำหนดเองและเครื่องมือของ LangChain

ส่งฟังก์ชันแบบกำหนดเองหรือเครื่องมือของ LangChain ได้โดยตรงผ่านพารามิเตอร์ tools=:

from deepagents import create_deep_agent def get_weather(city: str) -> str: """Get weather for a given city.""" return f"It's always sunny in {city}!" agent = create_deep_agent( model="your-model", tools=[get_weather], system_prompt="You are a helpful assistant", )

MCP (Model Context Protocol)

Deep Agents รองรับ MCP อย่างสมบูรณ์ ทำให้คุณเชื่อมต่อกับฐานข้อมูล API ระบบไฟล์ และอื่น ๆ ผ่านอินเทอร์เฟซมาตรฐานได้

การรันโค้ด

Sandbox backend: เปิดใช้งานเครื่องมือ execute สำหรับคำสั่ง shell ในสภาพแวดล้อมที่แยกส่วน
Interpreter: เพิ่มเครื่องมือ eval ที่รัน JavaScript ใน QuickJS runtime แบบจำกัดขอบเขต สำหรับสร้างเลเยอร์ที่ตั้งโปรแกรมได้แบบเบา ๆ

เมื่อความสามารถเหล่านี้ทำงานร่วมกัน โมเดลภาษาที่ขับเคลื่อน agent จึงกลายเป็นส่วนสำคัญของการตั้งค่าทั้งหมด โมเดลที่มีความสามารถสูงจะช่วยให้ Deep Agents เข้าใจคำสั่ง ใช้เหตุผลในการทำงาน และใช้เครื่องมือที่มีอยู่ได้ดียิ่งขึ้น Kimi API สามารถเป็นเลเยอร์โมเดลนี้ได้ ทำให้เป็นขั้นตอนต่อไปที่เป็นธรรมชาติสำหรับการสร้างเวิร์กโฟลว์ Deep Agent ที่มีความสามารถมากขึ้น

เชื่อมต่อ Kimi API กับ LangChain Deep Agents ใน 6 ขั้นตอน

โมเดลที่มีความสามารถจะให้ Deep Agent ของคุณมีความเข้าใจภาษาและการใช้เหตุผลที่จำเป็นในการจัดการงานได้อย่างมีประสิทธิภาพ Kimi API สามารถมอบความสามารถเหล่านี้ได้ ในขณะที่ agent ทำงานกับเครื่องมือ จัดการงาน และรับมือกับคำสั่งที่ซับซ้อน เมื่อมีเลเยอร์โมเดลพร้อมแล้ว การตั้งค่าก็สามารถดำเนินต่อไปสู่การเชื่อมต่อ Kimi API กับ LangChain Agents ได้อย่างเป็นธรรมชาติ นี่คือวิธีเชื่อมต่อ Kimi API กับ LangChain Deep Agents:

ขั้นตอนที่ 1: รับ Kimi API Key ของคุณ

เข้าสู่ระบบ Kimi API platform และสร้าง API key ใหม่ คัดลอกและบันทึกคีย์นี้ไว้อย่างปลอดภัย เนื่องจากคุณจะต้องเพิ่มมันเข้าไปในการตั้งค่า Deep Agents ของคุณ API key นี้ใช้สำหรับยืนยันตัวตนของคำขอ และช่วยให้ Deep Agents ของ LangChain เข้าถึงโมเดล Kimi ผ่าน API ได้

รับ Kimi API Key ของคุณ

ขั้นตอนที่ 2: ตั้งค่าตัวแปรสภาพแวดล้อม

ตั้งค่า Kimi API key ของคุณเป็นตัวแปรสภาพแวดล้อม (environment variable) Kimi API ใช้ endpoint ของ Moonshot API ดังนั้นให้กำหนดตัวแปรต่อไปนี้:

export MOONSHOT_API_KEY="your-api-key-here"

export MOONSHOT_API_KEY="your-api-key-here"

URL หลักของ API คือ:

https://api.moonshot.ai/v1

https://api.moonshot.ai/v1

ขั้นตอนที่ 3: ติดตั้ง dependencies

ติดตั้ง Deep Agents และ LangChain dependencies ที่จำเป็น:

pip install deepagents langchain-openai
``````bash
pip install deepagents langchain-openai

เนื่องจาก Kimi API รองรับรูปแบบเดียวกับ OpenAI langchain-openai จึงช่วยให้ LangChain เชื่อมต่อกับโมเดล Kimi ผ่านอินเทอร์เฟซที่รองรับ OpenAI ได้

หากต้องการเพิ่มความสามารถในการค้นหาเว็บให้กับ Deep Agent ของคุณ คุณสามารถติดตั้ง Tavily เพิ่มเติมได้:

pip install tavily-python

pip install tavily-python

หลังจากสร้าง Tavily API key จากแพลตฟอร์ม Tavily แล้ว ให้ตั้งค่าเป็นตัวแปรสภาพแวดล้อม:

export TAVILY_API_KEY="your-tavily-api-key"

export TAVILY_API_KEY="your-tavily-api-key"

คุณจำเป็นต้องใช้ Tavily เฉพาะในกรณีที่วางแผนจะเพิ่มเครื่องมือค้นหาเว็บให้กับ agent ของคุณ

ขั้นตอนที่ 4: กำหนดค่า Deep Agent ด้วย Kimi API

เนื่องจาก Kimi API รองรับรูปแบบเดียวกับ OpenAI API คุณสามารถเชื่อมต่อกับ LangChain Deep Agents ผ่าน init_chat_model ได้

ตัวอย่างต่อไปนี้สร้าง Deep Agent พื้นฐานที่ขับเคลื่อนด้วย Kimi คุณสามารถขยายเพิ่มด้วยเครื่องมือ เช่น การค้นหาเว็บได้ตามต้องการ

Deep Agent พื้นฐานที่ขับเคลื่อนด้วย Kimi

from os import environ from deepagents import create_deep_agent from langchain.chat_models import init_chat_model kimi_model = init_chat_model( "kimi-k3", api_key=environ["MOONSHOT_API_KEY"], base_url="https://api.moonshot.ai/v1", temperature=0.7, ) agent = create_deep_agent( model=kimi_model, system_prompt="""You are an expert assistant. Your job is to solve tasks with structured reasoning and provide clear outputs. """, )

เพิ่มความสามารถในการค้นหาเว็บ (ไม่บังคับ)

เพื่อเปิดใช้งานการค้นหาเว็บ ให้เชื่อมต่อเครื่องมือค้นหา เช่น Tavily:

from tavily import TavilyClient tavily_client = TavilyClient( api_key=os.environ["TAVILY_API_KEY"] ) def internet_search(query: str, max_results: int = 5): """Run a web search""" return tavily_client.search( query=query, max_results=max_results ) agent = create_deep_agent( model=kimi_model, tools=[internet_search], system_prompt="""You are an expert researcher. Use the internet search tool when additional information is required. """, )

ด้วยการกำหนดค่านี้ Deep Agents สามารถใช้ Kimi เป็นโมเดลสำหรับการให้เหตุผล พร้อมทั้งเข้าถึงความสามารถในการค้นหาข้อมูลภายนอกผ่าน Tavily ได้ในเวลาเดียวกัน

ขั้นตอนที่ 5: รัน Deep Agent ที่ขับเคลื่อนด้วย Kimi ของคุณ

เมื่อกำหนดค่า Deep Agent ของคุณด้วย Kimi เรียบร้อยแล้ว ให้รัน agent เพื่อทดสอบว่ามันจัดการกับงานและการเรียกใช้เครื่องมือ (tool calls) อย่างไร

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)

print(result["messages"][-1].content)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "What is LangGraph?"}]}
)

print(result["messages"][-1].content)

ขั้นตอนที่ 6: เปิดใช้งาน LangSmith tracing (ไม่บังคับ)

LangSmith tracing ช่วยให้คุณตรวจสอบการทำงานของ agent ได้ รวมถึงการเรียกใช้เครื่องมือ ขั้นตอนกลาง และการตอบสนองของโมเดล

เปิดใช้งาน tracing ด้วยตัวแปรสภาพแวดล้อมต่อไปนี้:

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-langsmith-api-key"

ใช้ LangSmith เมื่อคุณต้องการมองเห็นการทำงานของ agent ได้ลึกขึ้น สำหรับการดีบัก หรือการวิเคราะห์ประสิทธิภาพ

เชื่อมต่อ Agent ด้วย Kimi API

ประโยชน์ของการใช้ Kimi API

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

ปรับปรุงการให้เหตุผลและการทำงานของ agent

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

สร้างเวิร์กโฟลว์ AI ที่มีความสามารถมากขึ้น

เมื่อเชื่อมต่อ Kimi API กับ Deep Agents นักพัฒนาสามารถผสมผสานความสามารถของโมเดล Kimi เข้ากับเครื่องมือ ระบบไฟล์ และการเชื่อมต่อกับระบบภายนอกที่ LangChain รองรับได้ ทำให้ agent สามารถทำงานต่างๆ เช่น การค้นคว้า การประมวลผลเอกสาร การวิเคราะห์โค้ด และการจัดการข้อมูลภายในเวิร์กโฟลว์เดียวกันได้

ขยายขนาดงานที่ซับซ้อนด้วย agent ที่ทำงานอัตโนมัติ

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

บทสรุป

การสร้าง AI agent ที่เชื่อถือได้เริ่มต้นจากการเลือกพื้นฐานที่เหมาะสมสำหรับเวิร์กโฟลว์ที่ซับซ้อน LangChain Deep Agents มอบเครื่องมือและโครงสร้างที่จำเป็นสำหรับการสร้าง agent ที่สามารถวางแผน ใช้เครื่องมือ จัดการ context และรับมือกับงานหลายขั้นตอนได้โดยใช้แรงงานคนน้อยลง ด้วยโมเดลและการตั้งค่าที่เหมาะสม นักพัฒนาสามารถเปลี่ยนไอเดีย agent ขั้นสูงให้กลายเป็นแอปพลิเคชันที่ใช้งานได้จริง โดยการเชื่อมต่อ Kimi API คุณสามารถเสริมความสามารถให้เวิร์กโฟลว์ Deep Agent ของคุณด้วยความสามารถในการให้เหตุผลที่แข็งแกร่งและการรองรับ context ที่ยาวขึ้น เริ่มสำรวจ Kimi API และค้นพบสิ่งที่คุณสามารถสร้างได้ด้วย AI agent

รับ Kimi API Key ของคุณ

คำถามที่พบบ่อย

LangChain agents กับ Deep Agents ต่างกันอย่างไร?

LangChain agents เป็นพื้นฐานสำหรับการสร้าง AI agent ที่ใช้เครื่องมือต่าง ๆ Deep Agents พัฒนาต่อจากพื้นฐานนี้ด้วยฟีเจอร์เพิ่มเติม เช่น การวางแผน การจัดการไฟล์ การมอบหมายงานให้ subagent และการจัดการ context ความสามารถเหล่านี้ทำให้ Deep Agents เหมาะกับงานที่ยาวนานและซับซ้อนมากขึ้น รวมถึงลดความจำเป็นในการสร้างฟีเจอร์เหล่านี้ขึ้นมาเองแยกต่างหาก

LangChain Deep Agents ใช้ทำอะไรได้บ้าง?

LangChain Deep Agents สามารถจัดการงานที่ต้องใช้หลายขั้นตอน การใช้เครื่องมือ และการตัดสินใจอย่างต่อเนื่อง รองรับกรณีการใช้งานเช่นการทำวิจัยแบบอัตโนมัติ การวิเคราะห์เอกสาร การทำความเข้าใจโค้ด การประมวลผลข้อมูล และการดำเนินเวิร์กโฟลว์ที่ซับซ้อน สำหรับงานที่เกี่ยวข้องกับความเชี่ยวชาญหลายด้าน Deep Agents สามารถมอบหมายงานย่อยเฉพาะให้กับ subagent ที่เชี่ยวชาญ และรวมผลลัพธ์เข้าด้วยกัน ด้วยการเชื่อมต่อ Deep Agents กับ Kimi API นักพัฒนาสามารถสร้างแอปพลิเคชัน AI ที่ใช้ประโยชน์จากความสามารถในการให้เหตุผลของ Kimi และหน้าต่าง context ขนาดใหญ่ สำหรับงานต่าง ๆ เช่นการวิเคราะห์เอกสารจำนวนมาก การประมวลผลข้อมูลที่ซับซ้อน และการทำเวิร์กโฟลว์ที่ต้องใช้องค์ความรู้แบบอัตโนมัติ

สามารถเพิ่ม memory ให้กับ LangChain Deep Agent ได้หรือไม่?

ได้ LangChain Deep Agents สามารถรองรับ memory ผ่านการรวมระบบ persistence และ memory ที่มีให้ใช้งาน ซึ่งช่วยให้ agent เก็บรักษาข้อมูลที่เกี่ยวข้องไว้ใช้ในการโต้ตอบและงานต่าง ๆ ต่อเนื่อง โดยไม่ต้องเริ่มต้นใหม่ทุกครั้ง memory มีประโยชน์สำหรับเวิร์กโฟลว์ที่ปรับให้เหมาะกับผู้ใช้ งานที่ใช้เวลานาน และข้อมูลที่ต้องคงอยู่ต่อเนื่อง

คุณอาจจะชอบสิ่งเหล่านี้ด้วย