LangChain และ LangGraph โดยไม่ต้องใช้คีย์ API โดยไม่มีคีย์ API

ความหมายที่เป็นไปได้จริงของ "ไม่มีคีย์ API"

การค้นหา langchain และ langraph โดยไม่มี api key มักหมายถึงสิ่งใดสิ่งหนึ่งจากสามสิ่ง คุณอาจต้องการหลีกเลี่ยงการจ่ายเงินก่อนที่คุณจะรู้ว่าสแต็กทำงานได้หรือไม่ คุณอาจไม่ต้องการมอบบัตรเครดิตให้กับผู้ขายรายอื่น หรือคุณอาจหวังที่จะรันกราฟเอเยนต์โดยไม่มีข้อมูลรับรองเลย

ความต้องการข้อสามไม่สามารถตอบสนองโดยบริการโฮสต์ใดๆ ได้: เซิร์ฟเวอร์ที่ทำงานให้คุณต้องรู้ว่าใครกำลังเรียกใช้งาน สิ่งที่คุณสามารถรับได้คือคีย์ที่ไม่มีค่าใช้จ่ายและไม่ต้องใช้บัตร ผู้ใช้ใหม่บนเว็บไซต์นี้สามารถรับเครดิตทดลอง $0.50 ได้ด้วยการคลิกเดียวที่หน้า API key หลังจากสมัครสมาชิกด้วย Google หรือด้วยอีเมลและรหัสผ่าน คีย์นี้ใช้ได้หนึ่งครั้งต่อบุคคลและมีอายุ 7 วัน

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

เนื่องจากเอนด์พอยต์เข้ากันได้กับ OpenAI LangChain จึงไม่ต้องการการผสานรวมพิเศษ คุณชี้คลาสแชท OpenAI ไปที่ URL ฐานอื่น กำหนดคีย์ และตั้งชื่อโมเดลเป็น uncensored ข้อด้านล่างทั้งหมดสมมติการตั้งค่านี้

ขั้นตอนที่ 1: รับคีย์ทดลองและตั้งค่าสภาพแวดล้อม

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

Copyexport UNCENSORED_API_KEY="paste-your-key-here"
pip install -U langchain-openai langgraph langchain-core

ก่อนใช้เฟรมเวิร์กใดๆ ให้ตรวจสอบคีย์ด้วยคำขอพื้นฐาน การใช้เวลาสองนาทีที่นี่จะช่วยประหยัดเวลาอ่าน Stack Trace นานหนึ่งชั่วโมงซึ่งจริงๆ แล้วคือข้อผิดพลาดการตรวจสอบสิทธิ์

Copycurl https://api.stableaudio.top/v1/chat/completions \
  -H "Authorization: Bearer $UNCENSORED_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"uncensored","messages":[{"role":"user","content":"Reply with one word: ready"}]}'

การเรียก GET /v1/models เป็นการตรวจสอบอย่างรวดเร็วอีกวิธีหนึ่ง; ควรแสดงรายการ uncensored คีย์ทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 คำขอและ 60 คำขอต่อนาที ซึ่งเพียงพอสำหรับการพัฒนากราฟแต่ควรจำไว้เมื่อคุณเพิ่มโหนดแบบขนาน

ขั้นตอนที่ 2: ชี้ LangChain ไปที่เอนด์พอยต์

คลาสที่ใช้คือ ChatOpenAI จาก langchain-openai พารามิเตอร์สองตัวคือ base_url และ api_key ชื่อโมเดลคือ uncensored และการตั้งค่าการสุ่มตัวอย่างทั่วไปจะถูกส่งผ่าน

Copyimport os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.stableaudio.top/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    temperature=0.7,
    max_retries=3,
)

print(llm.invoke("Give me three titles for an ambient track about rain.").content)

หากผลลัพธ์พิมพ์ข้อความ แสดงว่าการเชื่อมต่อใช้งานได้ดี การสตรีมทำงานในลักษณะเดียวกัน: วนลูปผ่าน llm.stream(...) และข้อมูลจะมาถึงผ่าน Server-Sent Events พร้อมรายงานการใช้งานที่ท้ายสตรีม

ข้อผิดพลาดทั่วไปอย่างหนึ่งคือการตั้งค่าตัวแปร OPENAI_API_KEY ไว้จากโปรเจกต์เก่า LangChain จะส่งค่านั้นไปยัง URL ฐานของคุณโดยอัตโนมัติหากคุณลืมส่ง api_key การส่งคีย์อย่างชัดเจนจะขจัดความสับสน

ขั้นตอนที่ 3: กราฟ LangGraph ขั้นพื้นฐาน

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

Copyfrom langgraph.graph import StateGraph, MessagesState, START, END

def call_model(state: MessagesState):
    reply = llm.invoke(state["messages"])
    return {"messages": [reply]}

builder = StateGraph(MessagesState)
builder.add_node("model", call_model)
builder.add_edge(START, "model")
builder.add_edge("model", END)
graph = builder.compile()

out = graph.invoke({"messages": [("user", "Outline a three-act short story about a lighthouse keeper.")]})
print(out["messages"][-1].content)

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

ขั้นตอนที่ 4: เพิ่มเครื่องมือและลูป

เอเจนต์จะน่าสนใจเมื่อโมเดลสามารถเรียกใช้ฟังก์ชันได้ เอนด์พอยต์รองรับการเรียกใช้ฟังก์ชันด้วย tools และ tool_choice และผลลัพธ์ของเครื่องมือจะถูกส่งกลับเป็นข้อความ role: "tool" LangChain และ LangGraph โดยไม่ต้องใช้คีย์ API จัดการโครงสร้างพื้นฐานนี้ให้คุณ

Copyfrom langchain_core.tools import tool
from langgraph.prebuilt import ToolNode, tools_condition

@tool
def word_count(text: str) -> int:
    'Count the words in a piece of text.'
    return len(text.split())

tools = [word_count]
llm_with_tools = llm.bind_tools(tools)

def agent(state: MessagesState):
    return {"messages": [llm_with_tools.invoke(state["messages"])]}

builder = StateGraph(MessagesState)
builder.add_node("agent", agent)
builder.add_node("tools", ToolNode(tools))
builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")
graph = builder.compile()

result = graph.invoke({"messages": [("user", "Write a 40-word product blurb, then check its word count with the tool.")]})
print(result["messages"][-1].content)

ลูปคือแนวคิดหลัก: โหนดเอเยนต์ตอบกลับ tools_condition ตรวจสอบว่าการตอบกลับนั้นเรียกใช้เครื่องมือหรือไม่ โหนดเครื่องมือจะดำเนินการ แล้วส่งการควบคุมกลับไปยังเอเยนต์ เมื่อการตอบกลับไม่มีการเรียกใช้เครื่องมือ กราฟจะสิ้นสุด

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

ขีดจำกัดอัตรา การเรียกซ้ำ และกิ่งก้านแบบขนาน

จุดที่กราฟเอเยนต์สะดุดบ่อยที่สุดคือการทำงานพร้อมกัน (concurrency) คีย์เต็มรูปแบบอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอและ 300 คำขอต่อนาที; คีย์ทดลองอนุญาตให้ทำ 2 และ 60 หากกราฟของคุณกระจายออกเป็นโหนดแบบขนาน 5 โหนดบนคีย์ทดลอง โหนดสามโหนดจะถูกปฏิเสธด้วย HTTP 429 และรหัสข้อผิดพลาด concurrency การเกินงบประมาณต่อนาทีจะส่งกลับ rate_limited การโอเวอร์โหลดชั่วคราวยังให้ 429 พร้อมส่วนหัว Retry-After: 5

สามนิสัยเหล่านี้ช่วยให้จัดการได้ง่าย:

• ตั้งค่า max_retries ไว้ที่ 2 หรือ 3 บน ChatOpenAI เพื่อให้คำขอ 429 สั้นๆ ถูกเรียกซ้ำด้วยการหน่วงเวลา
• จำกัดการกระจายสาขาที่ขีดจำกัดการทำงานพร้อมกันของคุณ ใน LangGraph คุณสามารถส่ง config={"max_concurrency": 2} เมื่อเรียกใช้กราฟ
• จำไว้ว่าคำขอแบบสตรีมจะครอบครองช่องของตัวเองจนกว่าสตรีมจะสิ้นสุด ดังนั้นผู้บริโภคที่ช้าจึงทำให้ช่องถูกใช้งานอยู่

Copyout = graph.invoke(
    {"messages": [("user", "Draft five taglines in parallel.")]},
    config={"max_concurrency": 2},
)

หัวข้อความตอบสนองช่วยให้การแก้ไขข้อบกพร่องทำได้ง่ายขึ้น X-Request-Id ระบุการเรียกใช้หากคุณต้องการสอบถามฝ่ายสนับสนุน และ X-Balance-USD แสดงเครดิตคงเหลือของคุณหลังจากแต่ละคำขอ

รายการตรวจสอบการแก้ไขข้อบกพร่องเมื่อกราฟทำงานผิดปกติ

ข้อผิดพลาดส่วนใหญ่ในโปรเจกต์ LangGraph ครั้งแรกไม่ได้เกี่ยวกับโมเดล แต่เกิดจากการกำหนดค่า และรายการตรวจสอบสั้นๆ สามารถจับข้อผิดพลาดได้เกือบทั้งหมด

1. 401 หรือข้อผิดพลาดการตรวจสอบสิทธิ์ คีย์อาจหายไป พิมพ์ผิด หรือมีการอ่านค่า OPENAI_API_KEY เก่าแทน ให้พิมพ์อักขระ 4 ตัวแรกของค่าที่สคริปต์ของคุณใช้งานจริง
2. 404 หรือไม่พบโมเดล ชื่อโมเดลต้องเป็น uncensored เรียกใช้ GET /v1/models หากไม่แน่ใจว่าเอนด์พอยต์แสดงรายการอะไร
3. ข้อผิดพลาดการเชื่อมต่อ Base URL ต้องลงท้ายด้วย /v1 และต้องไม่รวม /chat/completions; ไคลเอนต์จะเพิ่มส่วนนั้นให้
4. ลูปไม่สิ้นสุด หากเอเยนต์เรียกใช้เครื่องมืออย่างต่อเนื่อง ค่าที่ส่งกลับของเครื่องมืออาจไม่ตอบคำถาม ให้ส่งกลับสตริงสั้นๆ และตั้งค่าขีดจำกัดการเรียกซ้ำผ่านค่ากำหนดกราฟเพื่อให้ลูปที่ผิดพลาดหยุดลงก่อน
5. การตอบกลับว่างหรือผิดปกติ พิมพ์รายการข้อความทั้งหมดหลังจากการทำงานเสร็จสิ้น มักมีโหนดก่อนหน้าเขียนข้อความระบบที่ขัดแย้งกับข้อความในภายหลัง

เมื่อคำขอล้มเหลวจากฝั่งเซิร์ฟเวอร์ ให้อ้างอิงหัวข้อความ X-Request-Id ในข้อความของคุณถึง support มันช่วยให้พวกเขาพบการเรียกใช้นั้นได้โดยไม่ต้องเดา นอกจากนี้ โปรดจำไว้ว่าคำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน ดังนั้นเซสชันการแก้ไขข้อบกพร่องที่มีข้อผิดพลาดจำนวนมากจะไม่ทำให้เครดิตทดลองใช้ของคุณหมดไป

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

ต้นทุนที่แท้จริงของการรันทดลอง

ราคาอยู่ที่ $0.15 ต่อ 1M โทเคนอินพุตและ $0.50 ต่อ 1M โทเคนเอาต์พุต จากเครดิตแบบเติมเงินล่วงหน้า คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน กราฟเอเยนต์เรียกโมเดลหลายครั้งต่องาน และการเรียกแต่ละครั้งจะส่งรายการข้อความที่สะสมเพิ่มขึ้นใหม่ ดังนั้นโทเคนอินพุตจึงเป็นส่วนใหญ่

ทำการรันที่มีการเรียกโมเดลหกครั้ง สมมติว่าการเรียกแต่ละครั้งส่ง 3,000 โทเคนเข้าและส่งคืน 400 โทเคนออก นั่นคือ 18,000 โทเคนอินพุตและ 2,400 โทเคนเอาต์พุต

• อินพุต: 18,000 / 1,000,000 x $0.15 = $0.0027
• เอาต์พุต: 2,400 / 1,000,000 x $0.50 = $0.0012
• รวม: $0.0039 ต่อการรัน

เครดิตทดลอง $0.50 หารด้วย $0.0039 ได้ประมาณ 128 รันของขนาดนั้น เพียงพอสำหรับการสร้างและทดสอบกราฟอย่างถูกต้อง เมื่อต้องการใช้มากขึ้น การเติมเงินจะอยู่ในช่วง $20 ถึง $500 ในจำนวนเต็ม พร้อมโบนัส 5% จาก $50, 10% จาก $100 และ 15% จาก $200; หน้าราคา มีรายละเอียด คุณสามารถชำระเงินด้วยบัตร (Visa, Mastercard, Apple Pay, Google Pay) หรือด้วยคริปโต (USDT บน TRC20, USDC บน Base) เครดิตไม่มีวันหมดอายุ และพรอมต์ไม่ถูกใช้ในการฝึก

หน้าต่างบริบทมีขนาด 100,000 โทเคนสำหรับพรอมต์รวมกับการตอบกลับ ดังนั้นประวัติของเอเยนต์ที่ยาวจึงรองรับได้ แต่คุณต้องจ่ายสำหรับทุกโทเคนที่ส่งซ้ำ การตัดข้อความเก่าด้วยเครื่องมือจัดการข้อความของ LangGraph ช่วยลดต้นทุนและความหน่วง สำหรับรูปแบบคำขอแบบดิบที่ใช้ในทั้งหมดนี้ ดูเอกสาร API

คู่มือเพิ่มเติม

• โมเดลภาษาขนาดใหญ่ Text to Audio: สิ่งที่ทำได้และทำไม่ได้
• API ข้อความแบบไม่เซ็นเซอร์สำหรับพรอมต์วิดีโอ