เชื่อมต่อ LangChain ในสี่บรรทัด
หากคุณต้องการใช้โมเดลโอเพนซอร์ส langchain โดยไม่ต้องโฮสต์อะไรเอง เส้นทางที่สั้นที่สุดคือ API ที่เข้ากันได้กับ OpenAI คลาสแชท OpenAI ของ LangChain ไม่สนใจว่าใครจะตอบตราบใดที่เอนด์พอยต์ใช้โปรโตคอลเดียวกัน คุณเปลี่ยน base URL และคีย์ และเชน พรอมต์ และเอเจนต์ที่เหลือของคุณจะคงเดิม
บริการนี้โฮสต์โมเดลแบบเปิดน้ำหนักหนึ่งตัว ซึ่งดำเนินการโดยผู้ให้บริการอิสระและปรับแต่งเพื่อตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย ไม่ใช่ API ทางการของผู้ขายโมเดลใด ๆ และไม่ใช่ตัวกระจายการรับส่งระหว่างผู้ขาย ติดตั้งแพ็กเกจและสร้างวัตถุโมเดล:
pip install langchain-openai langchain-core
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
temperature=0.7,
)
print(llm.invoke("Give me three names for a fantasy tavern.").content)
นี่คือการเชื่อมต่อทั้งหมด เก็บคีย์ในตัวแปรสภาพแวดล้อมในโปรเจกต์จริง และอ่านด้วย os.environ แทนที่จะเขียนลงในไฟล์ หากคุณยังไม่มีคีย์ หน้า คีย์ แสดงวิธีสมัครและรับเครดิตทดลองใช้ $0.50 ซึ่งไม่ต้องใช้บัตร
Node.js และ LangChain.js
แพ็กเกจ JavaScript ใช้แนวคิดเดียวกัน โดยส่ง Base URL ผ่านวัตถุการกำหนดค่า
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.API_KEY,
temperature: 0.7,
configuration: { baseURL: "https://api.uncensoredmodelhub.com/v1" },
});
const reply = await llm.invoke("Summarize the plot of a heist film in two lines.");
console.log(reply.content);
หากคุณเห็น 404 หรือหน้า HTML ในข้อผิดพลาด base URL มักจะผิด ต้องลงท้ายด้วย /v1 เอนด์พอยต์สองตัวเบื้องหลังคือ POST /v1/chat/completions และ GET /v1/models และไม่มีอะไรอื่นที่จำเป็นสำหรับโมเดลแชทของ LangChain
โมเดลโอเพนซอร์สใน LangChain ดีกว่าเมื่อโฮสต์หรือแบบโลคอล?
LangChain สามารถรันโมเดลโลคอลบนเครื่องของคุณเองได้ เช่น ผ่าน Ollama หรือเซิร์ฟเวอร์โลคอล เส้นทางนี้มีข้อได้เปรียบจริง และต้องยอมรับตามตรงว่าเป็นเช่นนั้น โมเดลโลคอลไม่มีค่าใช้จ่ายต่อโทเคน ทำงานออฟไลน์ และเก็บทุกไบต์ไว้ในฮาร์ดแวร์ของคุณ ราคาที่ต้องจ่ายคือฮาร์ดแวร์: คุณต้องมีหน่วยความจำ GPU เพียงพอสำหรับโมเดลที่คุณเลือก คุณดูแลรันไทม์ และปริมาณงานจำกัดโดยเครื่องของคุณ
| คำถาม | เซิร์ฟเวอร์โลคอล | API ที่โฮสต์นี้ |
|---|---|---|
| ต้นทุนล่วงหน้า | ฮาร์ดแวร์หรือ GPU เช่า | ไม่มี; เครดิตแบบเติมเงินล่วงหน้าเริ่มต้นที่ $20 |
| ค่าใช้จ่ายต่อโทเคน | ไม่มี แต่ใช้พลังงานและทำให้ฮาร์ดแวร์เสื่อม | $0.15 ต่อ 1M เข้า, $0.50 ต่อ 1M ออก |
| หน้าต่างบริบท | ขึ้นอยู่กับหน่วยความจำที่คุณมี | 100,000 โทเคน |
| คำขอพร้อมกัน | ขึ้นอยู่กับเซตอัพของคุณ | 8 บนคีย์เต็ม |
| ตำแหน่งข้อมูล | เครื่องของคุณ | โฮสต์; พรอมต์ไม่ถูกใช้สำหรับการเทรน |
รูปแบบทั่วไปคือการสร้างต้นแบบกับเอนด์พอยต์ที่โฮสต์ไว้ แล้วตัดสินใจด้วยจำนวนโทเคนจริงว่าการติดตั้งในเครื่องสมเหตุสมผลหรือไม่ เนื่องจากทั้งสองฝ่ายใช้โปรโตคอล OpenAI การเปลี่ยนจึงเป็นการแก้ไข base_url เพียงบรรทัดเดียว และเชนที่คุณสร้างไว้จะยังคงไม่เปลี่ยนแปลง หน้า โมเดลที่ไม่เซ็นเซอร์คืออะไร อธิบายว่าการปรับแต่งเปลี่ยนแปลงพฤติกรรมอย่างไร
เครื่องมือและเอเจนต์แบบง่าย
การเรียกใช้เครื่องมือผ่านฟิลด์ tools แบบมาตรฐานของ OpenAI และ bind_tools ของ LangChain สร้างสิ่งนั้นให้คุณจากฟังก์ชัน Python ที่ตกแต่งไว้ โมเดลจะส่งคืนคำขอเรียกใช้เครื่องมือ และผลลัพธ์จะกลับเป็นข้อความ role: "tool"
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent
@tool
def word_count(text: str) -> int:
'''Count the words in a piece of text.'''
return len(text.split())
agent = create_react_agent(llm, [word_count])
result = agent.invoke({"messages": [("user", "How many words are in 'the quick brown fox jumps'?")]})
print(result["messages"][-1].content)
ลูปของเอเจนต์เรียกโมเดล รันเครื่องมือเมื่อถูกขอ และส่งผลลัพธ์กลับจนกว่าโมเดลจะตอบเป็นข้อความธรรมดา ข้อควรระวังสองข้อคือ ให้ทุกเครื่องมือมี docstring ที่เขียนสำหรับโมเดล เพราะข้อความนั้นคือสิ่งที่โมเดลอ่านเพื่อเลือกเครื่องมือ และกำหนดขีดจำกัดการเรียกซ้ำบนเอเจนต์เพื่อให้การรันที่สับสนไม่สามารถใช้เครดิตต่อไปได้; LangGraph ยอมรับ recursion_limit ในการกำหนดค่า
สำหรับการควบคุมโดยตรงโดยไม่ใช้เอเจนต์ ให้ใช้ llm.bind_tools([word_count]) และตรวจสอบ .tool_calls บนข้อความที่ส่งกลับด้วยตัวเอง
ผลลัพธ์ที่มีโครงสร้างด้วยโหมด JSON
สำหรับงานสกัดข้อมูล ให้ส่งพารามิเตอร์โหมด JSON ผ่าน bind พรอมต์ต้องบอกโมเดลว่าต้องการคีย์อะไร เพราะโหมด JSON แค่ผลักดันให้สร้าง JSON ที่ถูกต้อง
import json
from langchain_core.prompts import ChatPromptTemplate
json_llm = llm.bind(response_format={"type": "json_object"})
prompt = ChatPromptTemplate.from_messages([
("system", "Return a JSON object with keys title, genre and summary."),
("human", "{idea}"),
])
chain = prompt | json_llm
raw = chain.invoke({"idea": "A lighthouse keeper finds a door in the sea floor."})
data = json.loads(raw.content)
ตรวจสอบผลลัพธ์ด้วย Pydantic หรือการตรวจสอบคีย์ธรรมดาก่อนใช้งาน โหมดนี้ไม่ได้บังคับใช้สคีมา ดังนั้นอาจมีฟิลด์ขาดหายไปได้ และการลองใหม่พร้อมพรอมต์ที่ชัดเจนกว่ามักจะแก้ไขได้
การสตรีมมิงและความพร้อมกัน
การสตรีมมิงทำงานผ่านเซิร์ฟเวอร์ส่งเหตุการณ์ (server-sent events) และใช้วิธี stream มาตรฐาน การใช้งานจะถูกส่งเมื่อสิ้นสุดสตรีม
for chunk in llm.stream("Write a four-line poem about rain on a tin roof."):
print(chunk.content, end="", flush=True)
เมื่อประมวลผลหลายรายการ batch จะรันแบบขนาน และตรงนี้เองที่ขีดจำกัดมีความสำคัญ คีย์เต็มอนุญาตคำขอพร้อมกัน 8 รายการและ 300 รายการต่อนาที คีย์ทดลองอนุญาต 2 และ 60 คำขอแบบสตรีมจะครอบครองช่องจนกว่าสตรีมจะจบ ส่งค่าจำกัดเพื่อให้ LangChain ไม่เกินสิ่งที่คีย์อนุญาต:
prompts = [f"Write a one-line tagline for product {i}." for i in range(40)]
results = llm.batch(prompts, config={"max_concurrency": 6})
หากคุณยังเห็น HTTP 429 รหัสข้อผิดพลาดจะบอกว่าคุณชนขีดจำกัดใด: rate_limited สำหรับคำขอต่อนาที concurrency สำหรับคำขอพร้อมกันมากเกินไป 429 พร้อมหัว Retry-After: 5 บ่งชี้การโอเวอร์โหลดชั่วคราว ChatOpenAI มีตัวเลือก max_retries ที่จะลองใหม่เมื่อเกิดข้อผิดพลาดแบบนั้นโดยเพิ่มระยะห่าง; ตั้งค่าเป็น 3 หรือ 4 สำหรับงานแบทช์
สายการดึงข้อมูลที่ไม่ใช้เอนด์พอยต์ embeddings
API นี้รองรับเฉพาะการสร้างข้อความ ดังนั้นสายการดึงข้อมูลจำเป็นต้องใช้ผู้ให้บริการสองราย: รายหนึ่งสำหรับ embeddings และอีกรายสำหรับขั้นตอนแชท LangChain ทำให้เรื่องนี้เป็นไปได้ง่าย เพราะที่เก็บเวกเตอร์และโมเดลแชทเป็นวัตถุแยกกัน คุณสามารถใช้โมเดล embeddings ใดๆ ก็ได้ จากไลบรารีในเครื่องหรือบริการอื่น เพื่อจัดทำดัชนีเอกสารของคุณ จากนั้นส่งข้อความที่ดึงได้ไปยังโมเดลแชทผ่านพรอมต์
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "Answer using only the context. If the answer is not there, say so.\n\nContext:\n{context}"),
("human", "{question}"),
])
chain = prompt | llm | StrOutputParser()
answer = chain.invoke({"context": "\n\n".join(top_chunks), "question": "What is the refund window?"})
ที่นี่ top_chunks คือสิ่งที่ตัวดึงข้อมูลของคุณส่งคืน เก็บไว้เฉพาะส่วนที่เกี่ยวข้องเพียงไม่กี่ส่วน ชิ้นส่วน 4 ชิ้น ชิ้นละ 300 โทเคน เพิ่ม 1,200 โทเคนต่อคำขอ ซึ่งโอเค แต่ชิ้นส่วน 40 ชิ้นเพิ่ม 12,000 และทำให้ทุกคำขอหนักขึ้นสิบเท่า
รายการตรวจสอบการแก้ปัญหา
- ข้อผิดพลาดการตรวจสอบสิทธิ์: ยืนยันว่าคีย์อยู่ใน
api_keyไม่ใช่ในพารามิเตอร์อื่น และไม่มีตัวแปรสภาพแวดล้อมOPENAI_API_KEYที่กำลังแทนที่สิ่งที่ตั้งใจส่งอยู่ - ไม่พบโมเดล: ID ของโมเดลคือ
uncensoredเรียกGET /v1/modelsเพื่อดูว่าเซิร์ฟเวอร์แสดงรายการอะไร - อาร์กิวเมนต์เครื่องมือแปลกๆ: อ่านสตริงอาร์กิวเมนต์ดิบ ปรับปรุงคำอธิบายเครื่องมือ และลดอุณหภูมิลงเหลือประมาณ 0.2 สำหรับการรันเอเจนต์
- การติดตามและแก้ไขข้อบกพร่อง: เปิดโหมด verbose หรือ debug ของ LangChain ในเครื่องเพื่อเห็นพรอมต์ที่ส่งออกไปและคำตอบที่ได้รับกลับ
- การทดสอบที่ทำซ้ำได้: ส่ง
seedและอุณหภูมิต่ำเมื่อเปรียบเทียบเวอร์ชันพรอมต์ เพื่อให้ความแตกต่างมาจากสิ่งที่คุณเปลี่ยน ไม่ใช่จากความโชคดีในการสุ่ม
ต้นทุนของงาน LangChain
การเรียกเก็บเงินคิดต่อโทเคนจากเครดิตแบบเติมเงินล่วงหน้า ไม่มีระบบสมาชิก คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน และเครดิตไม่หมดอายุ เติมเงินได้จำนวนเต็มใดๆ ตั้งแต่ $20 ถึง $500 โดยคริปโต (USDT บน TRC20, USDC บน Base) พร้อมโบนัส 5% เมื่อเติม $50, 10% เมื่อเติม $100 และ 15% เมื่อเติม $200 หน้า ราคา มีรายละเอียด
ลองคำนวณตัวอย่าง บอทสนับสนุนลูกค้าตอบคำถาม 2,000 คำถามในหนึ่งวัน แต่ละคำขอส่งประมาณ 1,500 โทเคน (พรอมต์ระบบ, ส่วนที่ดึงกลับมา, คำถาม) และส่งกลับประมาณ 250 โทเคน
- อินพุต: 2,000 x 1,500 = 3,000,000 โทเคน ดังนั้น 3 x $0.15 = $0.45
- เอาต์พุต: 2,000 x 250 = 500,000 โทเคน ดังนั้น 0.5 x $0.50 = $0.25
- รวม: $0.70 ต่อวันสำหรับคำตอบ 2,000 คำ หรือ $0.00035 ต่อคำตอบ
สายการดึงข้อมูลคือจุดที่ต้นทุนอาจเพิ่มขึ้น เนื่องจากแต่ละชิ้นส่วนที่ดึงเพิ่มเข้ามาจะเพิ่มโทเคนอินพุตให้กับทุกคำขอ บันทึก usage_metadata จากคำตอบ ตรวจสอบขนาดเฉลี่ยของพรอมต์ และลดจำนวนชิ้นส่วนก่อนขยายขนาด เอกสาร API ระบุพารามิเตอร์ที่รองรับทั้งหมดหากคุณต้องการไปให้ไกลกว่านี้
