TH ▾
รับคีย์ API

เอกสาร LangChain Agentic AI: เครื่องมือและโหมด JSON

เอกสาร LangChain Agentic AI ส่วนใหญ่จะสมมติคลาสโมเดลของผู้ขายเอง แต่เอนด์พอยต์ที่เข้ากันได้กับ OpenAI ใดๆ ก็ทำงานกับ ChatOpenAI ได้เมื่อคุณตั้งค่า base URL คู่มือนี้จะเชื่อมต่อ LangChain กับ API นี้และสร้างเอเจนต์ที่เรียกใช้ฟังก์ชันทีละขั้นตอน

อัปเดต

ประเด็นสำคัญ

  • ใช้ ChatOpenAI โดยตั้งค่า base_url เป็น API นี้ และตั้งค่า model เป็น uncensored
  • รองรับการเรียกใช้ฟังก์ชันและโหมด JSON ดังนั้น bind_tools และ response_format จึงทำงานตามที่เอกสารระบุ
  • จำกัดลูปเอเจนต์ ตรวจสอบอาร์กิวเมนต์ของเครื่องมือ และรักษา max_concurrency ไว้ที่ 8 หรือน้อยกว่านั้นสำหรับคีย์แบบเต็ม
  • การสตรีมมิงผ่าน SSE จะส่งการใช้งานโทเคนที่ส่วนท้าย ซึ่งช่วยให้คุณติดตามต้นทุนของการรันเอเจนต์แต่ละครั้ง
แขนกลเคลื่อนย้ายกล่องผ่านสถานีเครื่องมือบนรางวนซ้ำ ซึ่งแสดงถึงลูปเอเจนต์ LangChain

สิ่งที่คุณต้องมีก่อนเริ่ม

หากคุณกำลังอ่านเอกสาร LangChain agentic ai และสงสัยว่าจะมีการเปลี่ยนแปลงอย่างไรเมื่อโมเดลไม่ได้มาจากผู้ขายในตัวอย่าง คำตอบคือแทบไม่มีการเปลี่ยนแปลงเลย เอเจนต์ใน LangChain คือลูป: โมเดลอ่านบทสนทนา ตัดสินใจว่าจะเรียกใช้เครื่องมือหรือไม่ โค้ดของคุณรันเครื่องมือ และผลลัพธ์จะถูกส่งกลับไปยังโมเดลจนกว่าจะผลิตคำตอบสุดท้าย โมเดลเอนด์พอยต์ต้องรองรับ chat completions พร้อม function calling เท่านั้น และ API นี้รองรับ

คุณต้องมีสามสิ่ง: คีย์ API จากหน้าคีย์, Python 3.10 ขึ้นไป และแพ็กเกจด้านล่าง Base URL คือhttps://api.unlimitedaiapi.com/v1 และโมเดล ID คือuncensored นี่คือโมเดลแบบเปิดน้ำหนักตัวเดียวที่ให้บริการโดยผู้ให้บริการอิสระ ดังนั้นจึงไม่มีรายการโมเดลให้เลือก; GET /v1/models จะส่งคืนโมเดลนี้สำหรับการค้นพบไคลเอนต์

pip install -U langchain langchain-openai
export UNLIMITED_API_KEY="your-key-here"

ขั้นตอนที่ 1: เชื่อมต่อ ChatOpenAI กับเอนด์พอยต์

คลาส ChatOpenAI ของ LangChain รับค่า base_url แบบกำหนดเองได้ ส่วนอื่นๆ ยังคงเหมือนเดิม รวมถึง invoke, stream, batch และรูปแบบ async

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0.2,
)

print(llm.invoke("Reply with one short sentence.").content)

หากพิมพ์ประโยคนี้แสดงว่าการตรวจสอบสิทธิ์ การกำหนดเส้นทาง และชื่อโมเดลถูกต้องทั้งหมด การตรวจสอบสิทธิ์ใช้เฮดเดอร์มาตรฐาน Authorization: Bearer ซึ่งคลาสจะเพิ่มให้คุณโดยอัตโนมัติ ข้อผิดพลาดทั่วไปคือการลืม /v1 ใน base URL ซึ่งมักทำให้คำขอแรกล้มเหลว

ขั้นตอนที่ 2: กำหนดเครื่องมือและผูกเครื่องมือ

เครื่องมือคือฟังก์ชัน Python ธรรมดาที่มี docstring docstring และ type hints จะกลายเป็นสคีมาที่โมเดลเห็น ดังนั้นให้เขียนเหมือนคุณกำลังอธิบายฟังก์ชันให้เพื่อนร่วมงานใหม่

import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def get_order_status(order_id: str) -> str:
    '''Look up the status of an order by its ID, for example A100.'''
    return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)
llm_with_tools = llm.bind_tools([get_order_status])

ai = llm_with_tools.invoke("Where is order A100?")
print(ai.tool_calls)

รายการที่พิมพ์ไว้มีการเรียกใช้ชื่อ get_order_status และอาร์กิวเมนต์เช่น {"order_id": "A100"} เบื้องหลัง LangChain จะส่งฟังก์ชันของคุณเป็นรายการในอาร์เรย์ tools ของคำขอ chat completions และ API รองรับ tools, tool_choice และ tool_calls แบบสตรีม เพื่อบังคับการเรียกใช้ฟังก์ชัน ให้ส่ง tool_choice ไปยัง bind_tools

ทำไมอุณหภูมิจึงต่ำ

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

ขั้นตอนที่ 3: รันลูปของเอเจนต์

การเขียน loop เองใช้โค้ดประมาณสิบห้าบรรทัดและแสดงสิ่งที่เกิดขึ้นในแต่ละขั้นตอนอย่างชัดเจน ซึ่งช่วยเมื่อเกิดข้อผิดพลาด ผลลัพธ์จากเครื่องมือจะกลับไปที่โมเดลเป็นวัตถุ ToolMessage ซึ่งกลายเป็นข้อความ role: "tool" บนสายส่ง

import os
from langchain_core.messages import HumanMessage, ToolMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def get_order_status(order_id: str) -> str:
    '''Look up the status of an order by its ID, for example A100.'''
    return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)
tools = {"get_order_status": get_order_status}
llm_with_tools = llm.bind_tools(list(tools.values()))

messages = [HumanMessage("Where is order A100, and what about A101?")]
for _ in range(5):                      # hard cap on loop length
    ai = llm_with_tools.invoke(messages)
    messages.append(ai)
    if not ai.tool_calls:
        break
    for call in ai.tool_calls:
        result = tools[call["name"]].invoke(call["args"])
        messages.append(ToolMessage(content=str(result), tool_call_id=call["id"]))

print(ai.content)

สังเกต range(5) เอเจนต์ที่ไม่มีขีดจำกัดขั้นตอนอาจวนลูปไม่มีที่สิ้นสุดเมื่อได้รับผลลัพธ์จากเครื่องมือที่ทำให้สับสน และทุกรอบจะเสียโทเคนอินพุตสำหรับทั้งบทสนทนาจนถึงตอนนั้น ห้ารอบเป็นเพดานที่เหมาะสมสำหรับงานง่ายๆ ให้เพิ่มอย่างตั้งใจ

การใช้ตัวช่วยเอเจนต์แบบสำเร็จรูป

เวอร์ชัน LangChain ล่าสุดมีตัวช่วยที่รัน loop นี้ให้คุณ ชื่อและเส้นทางนำเข้ามีการเปลี่ยนแปลงระหว่างเวอร์ชันต่างๆ ดังนั้นให้ตรวจสอบกับเอกสารของเวอร์ชันที่ติดตั้ง ในเส้น 1.x ปัจจุบันมีลักษณะดังนี้:

import os
from langchain.agents import create_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def get_order_status(order_id: str) -> str:
    '''Look up the status of an order by its ID, for example A100.'''
    return {"A100": "shipped", "A101": "processing"}.get(order_id, "not found")

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)

agent = create_agent(llm, tools=[get_order_status], system_prompt="You are a concise support assistant.")
result = agent.invoke({"messages": [{"role": "user", "content": "Where is order A100?"}]})
print(result["messages"][-1].content)

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

ผลลัพธ์ที่มีโครงสร้างด้วยโหมด JSON

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

import json
import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
    temperature=0,
)
json_llm = llm.bind(response_format={"type": "json_object"})

msg = json_llm.invoke(
    "Extract the city and country from: 'I moved to Lyon, France last spring.' "
    "Answer as JSON with the keys city and country."
)
print(json.loads(msg.content))

กล่าวถึงคำว่า JSON ในพรอมต์และอธิบายคีย์ที่คุณคาดหวัง เช่น ในตัวอย่าง โหมด JSON รับรองไวยากรณ์ ไม่ใช่สคีมาของคุณ ดังนั้นให้ตรวจสอบวัตถุที่แยกวิเคราะห์ (เช่น ด้วย Pydantic) และจัดการกับคีย์ที่หายไป

ขีดจำกัด สตรีมมิง และค่าใช้จ่ายสำหรับการรันเอเจนต์

เอเจนต์ทำการเรียกใช้หลายครั้งในเวลาอันสั้น ดังนั้นขีดจำกัดของบัญชีจึงสำคัญกว่าแชทบอททั่วไป คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอและ 300 คำขอต่อนาที คีย์ทดลองอนุญาตให้ทำ 2 และ 60 หากคุณกระจายคำขอด้วย batch หรือรันเอเจนต์หลายตัวพร้อมกัน ให้จำกัดจำนวนการทำงานพร้อมกันในการกำหนดค่า:

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.unlimitedaiapi.com/v1",
    api_key=os.environ["UNLIMITED_API_KEY"],
)
prompts = ["Name one prime number.", "Name one even number.", "Name one square number."]
answers = llm.batch(prompts, config={"max_concurrency": 8})
for a in answers:
    print(a.content)

ใช้ 2 แทน 8 บนคีย์ทดลอง สำหรับ agent แบบโต้ตอบ llm.stream(...) จะคืนค่าโทเคนผ่าน SSE เมื่อสร้างเสร็จ และตัวเลขการใช้งานจะมาถึงที่ท้ายสตรีม

การคำนวณต้นทุนทำได้ง่าย การรัน 5 ขั้นตอนซึ่งเฉลี่ย 4,000 input tokens และ 300 output tokens ต่อขั้นตอน ใช้ input tokens ทั้งหมด 20,000 และ output tokens 1,500 ซึ่งคิดเป็น $0.003 + $0.00075 = $0.00375 ต่อการรัน ที่อัตรา $0.15 และ $0.50 ต่อ 1M tokens หน้าราคามีอัตราค่าบริการ และ เอกสารมีรายการพารามิเตอร์คำขอและ headers รวมถึง X-Request-Id เพื่อติดตามการเรียกใช้ที่ล้มเหลวเพียงรายการเดียว

การออกแบบเครื่องมือที่โมเดลสามารถใช้งานได้

ความล้มเหลวของ agent ส่วนใหญ่สืบย้อนกลับไปที่เครื่องมือ ไม่ใช่ลูป กฎไม่กี่ข้อช่วยให้ทำงานกับโมเดลใดก็ได้:

  • ทำให้แต่ละเครื่องมือแคบลง เครื่องมือชื่อ get_order_status ทำงานได้ดีกว่าเครื่องมือชื่อ database_query ที่รับข้อความแบบอิสระ
  • ใช้ประเภทอาร์กิวเมนต์ที่เรียบง่าย: string, integer และ enum สั้นๆ วัตถุที่ซ้อนกันหลายชั้นทำให้โมเดลมีโอกาสระบุฟิลด์ผิดพลาดได้มากขึ้น
  • คืนค่าผลลัพธ์ที่สั้นและเรียบง่าย เครื่องมือที่ทิ้งข้อมูล 50,000 ตัวอักษรลงในบทสนทนาจะเติมเต็ม context window และเพิ่มต้นทุนของขั้นตอนที่ตามมาทั้งหมด
  • คืนค่าข้อผิดพลาดเป็นข้อความ เช่น "order_id ต้องมีรูปแบบเช่น A100" แทนที่จะโยนข้อยกเว้นที่ทำให้การรันสิ้นสุดลง

ทดสอบ agent ด้วยพรอมต์จริงจำนวนเล็กน้อยด้วยเครดิตทดลองใช้ $0.50 ก่อนที่จะขยายการใช้งาน ผู้ใช้ใหม่ได้รับเครดิตนี้ด้วยการคลิกเพียงครั้งเดียวบนหน้าคีย์ และใช้ได้เป็นเวลา 7 วัน

จุดบกพร่องที่ควรตรวจสอบเป็นอันดับแรก

  • การเรียกใช้เครื่องมือไม่ปรากฏเลย ทำให้ docstring เฉพาะเจาะจง ลดอุณหภูมิ หรือบังคับการเรียกด้วย tool_choice
  • อาร์กิวเมนต์ไม่ถูกต้อง ตรวจสอบภายในเครื่องมือ และส่งคืนสตริงข้อผิดพลาดที่ชัดเจน เพื่อให้โมเดลสามารถแก้ไขตัวเองได้ในขั้นตอนถัดไป
  • บริบทเพิ่มขึ้น หน้าต่างบริบทมีขนาด 100,000 tokens รวมถึงการตอบกลับ ตัดเอาต์พุตของเครื่องมือเก่าออกก่อนที่หน้าต่างจะเต็ม

ถาม-ตอบ

คลาส LangChain ใดที่ทำงานกับ API นี้ได้?

ChatOpenAI จาก langchain-openai ตั้งค่า base_url เป็น https://api.unlimitedaiapi.com/v1, model เป็น uncensored และส่งคีย์ของคุณเป็น api_key

API รองรับ function calling สำหรับ agent หรือไม่?

ใช่ มันรับพารามิเตอร์ tools และ tool_choice ส่งกลับ tool_calls (รวมถึงเมื่อสตรีมมิง) และรับผลลัพธ์กลับเป็นข้อความที่มี role tool

LangChain สามารถ parse output ที่มีโครงสร้างผ่าน API นี้ได้หรือไม่?

ใช่ ผ่านโหมด JSON: ตั้งค่า response_format เป็นประเภท json_object มันรับประกันไวยากรณ์ JSON ที่ถูกต้อง ดังนั้นคุณต้องตรวจสอบฟิลด์เอง

ฉันสามารถรัน agent พร้อมกันได้กี่ตัว?

คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 รายการและ 300 รายการต่อนาที คีย์แบบทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 รายการและ 60 รายการต่อนาที

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API