LangChain Custom LLM API: ชี้ไปยัง Base URL ใดก็ได้ ชี้ไปยัง Base URL ใดก็ได้
การใช้ langchain custom llm api ไม่จำเป็นต้องเขียนคลาสเอง: wrapper chat ที่เข้ากันได้กับ OpenAI รับ base URL, คีย์ และชื่อโมเดล นี่คือค่ากำหนดที่แน่นอน รวมถึง streaming, tools, JSON output และการจัดการขีดจำกัด
ประเด็นสำคัญ
- ChatOpenAI รับ base_url, api_key และ model ดังนั้นจึงไม่ต้อง subclass
- ใช้โมเดล uncensored และ base URL https://api.llmapistatus.com/v1.
- การเรียกใช้ฟังก์ชัน, streaming และโหมด JSON ล้วนส่งผ่านเอนด์พอยต์
- จำกัด parallel chains ไว้ที่ 8 เพื่อไม่ให้เกินขีดจำกัด concurrency; embeddings ไม่ได้ให้บริการ

คำตอบสั้นๆ: ChatOpenAI พร้อม Base URL ที่แตกต่าง
LangChain สื่อสารกับเซิร์ฟเวอร์รูปแบบ OpenAI ผ่านแพ็กเกจ langchain-openai คลาส ChatOpenAI ช่วยให้คุณกำหนดตำแหน่งที่ส่งคำขอได้ ซึ่งตรงกับความต้องการของเอนด์พอยต์แบบกำหนดเอง ติดตั้งแพ็กเกจ แล้วส่งค่าสามค่า: Base URL https://api.llmapistatus.com/v1 คีย์ API ของคุณ และ ID โมเดล uncensored
ติดตั้งด้วย pip install -U langchain-openai langchain-core
import os
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmapistatus.com/v1",
api_key=os.environ["LLM_API_KEY"],
temperature=0.7,
)
print(llm.invoke("Reply with the single word: ready").content)
หากสิ่งนั้นพิมพ์ผลลัพธ์กลับมา แสดงว่าการเชื่อมต่อถูกต้อง คุณได้รับคีย์จากหน้าคีย์ API;การเริ่มต้นอย่างรวดเร็วแสดงการสลับเดียวกันสำหรับผู้ใช้ SDK ทั่วไป เอนด์พอยต์ให้บริการPOST /v1/chat/completionsและGET /v1/models และวิธีการทั้งสองนี้เป็นสิ่งที่ wrapper OpenAI ต้องการสำหรับการแชท
คำอธิบายเกี่ยวกับคำว่า "LLM แบบกำหนดเอง" LangChain ยังมีการบันทึกวิธีการเขียนโมเดลแชทของคุณเองโดยการสืบทอดจากคลาสฐาน ซึ่งสมเหตุสมผลสำหรับ API ที่ไม่รองรับรูปแบบ OpenAI เอนด์พอยต์นี้รองรับรูปแบบดังกล่าว ดังนั้นการสืบทอดคลาสจะเพิ่มโค้ดที่ต้องบำรุงรักษาเพิ่มเติม ใช้เฉพาะเมื่อคุณต้องการพฤติกรรมที่ wrapper ไม่สามารถแสดงได้
สร้างโซ่ด้วยพรอมต์และการแยกวิเคราะห์เอาต์พุต
เมื่อมีวัตถุโมเดลแล้ว ส่วนอื่นๆ ทั้งหมดใน LangChain จะทำงานเหมือนกับการใช้โมเดลแชททั่วไป นี่คือโซ่ขนาดเล็กที่เขียนในรูปแบบภาษาการแสดงนิพจน์: เทมเพลตพรอมต์ โมเดล และตัวแยกวิเคราะห์สตริง
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "You are a blunt technical editor. Answer in at most {limit} words."),
("human", "Rewrite this for clarity:\n\n{text}"),
])
chain = prompt | llm | StrOutputParser()
print(chain.invoke({
"limit": 60,
"text": "The thing that we did was basically to make the cache be invalidated on write.",
}))
ไม่มีอะไรในโซ่นี้รู้หรือสนใจว่าโมเดลอยู่ภายใต้โดเมนที่แตกต่าง นั่นคือประโยชน์ของ API ที่เข้ากันได้: พรอมต์ คลาสหน่วยความจำ ตัวดึงข้อมูล และเอเจนต์ที่เขียนสำหรับอินเทอร์เฟซแชทมาตรฐานจะทำงานต่อไป สิ่งที่คุณควรตรวจสอบคือพรอมต์เอง โมเดลที่ปรับแต่งเพื่อตอบโดยไม่มีการปฏิเสธเนื้อหาจะปฏิบัติตามคำแนะนำอย่างตรงไปตรงมา ดังนั้นพรอมต์ระบบที่คลุมเครือจึงทำให้เกิดพฤติกรรมที่คลุมเครือ ระบุบทบาท รูปแบบ และความยาว
มีขีดจำกัดหนึ่งที่คุณควรทราบก่อนออกแบบ retrieval pipeline บริการนี้รองรับเฉพาะข้อความ ไม่มี embeddings ดังนั้น OpenAIEmbeddings ที่ชี้ไปที่ Base URL นี้จะล้มเหลว ให้ใช้โมเดล embedding ในเครื่องหรือผู้ให้บริการอื่นสำหรับ vector store และใช้เอนด์พอยต์นี้สำหรับการสร้างข้อความเท่านั้น
สตรีมมิงโทเคนเมื่อได้รับ
เอนด์พอยต์รองรับเหตุการณ์ที่ส่งโดยเซิร์ฟเวอร์เมื่อคุณส่ง stream: true และ LangChain แปลงสิ่งนั้นเป็นอินเทอร์เรเตอร์ คุณไม่ต้องตั้งค่าแฟลกเอง; การเรียก .stream() จะทำสิ่งนั้น
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
for chunk in llm.stream("Write a four-line poem about a failing cron job."):
print(chunk.content, end="", flush=True)
print()
สำหรับเซิร์ฟเวอร์แบบอะซิงโครนัส ใช้ astream การเรียกเดียวกันมีอยู่ในไลบรารี JavaScript:
import { ChatOpenAI } from "@langchain/openai";
const llm = new ChatOpenAI({
model: "uncensored",
apiKey: process.env.LLM_API_KEY,
configuration: { baseURL: "https://api.llmapistatus.com/v1" },
});
const stream = await llm.stream("Write a four-line poem about a failing cron job.");
for await (const chunk of stream) {
process.stdout.write(chunk.content);
}
จำไว้ว่าคำขอแบบสตรีมจะคงสล็อตการทำงานพร้อมกันไว้จนกว่าเหตุการณ์สุดท้ายจะมาถึง หากผู้ใช้ปิดแท็บเบราว์เซอร์และเซิร์ฟเวอร์ของคุณยังคงอ่านสตรีม ช่องนั้นจะถูกยึดไว้ ยกเลิกคำขอต้นทางเมื่อไคลเอนต์ตัดการเชื่อมต่อ จำนวนการใช้งานจะมาถึงที่สิ้นสุดของสตรีม ซึ่งเป็นจุดที่คุณอ่านจำนวนโทเคนสุดท้ายสำหรับบันทึกการเรียกเก็บเงิน
การเรียกใช้ฟังก์ชันและเอเจนต์
การเรียกใช้ฟังก์ชันพร้อมใช้งาน: เอนด์พอยต์ยอมรับtoolsและtool_choice, สตรีมtool_callsกลับ, และรับผลลัพธ์ของคุณเป็นข้อความด้วยrole: "tool" ใน LangChain คุณแนบเครื่องมือด้วยbind_toolsและให้เฟรมเวิร์กสร้างข้อความ
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from langchain_core.tools import tool
@tool
def get_order_status(order_id: str) -> str:
'Look up the status of an order by its id.'
return f"Order {order_id} shipped yesterday."
llm_tools = llm.bind_tools([get_order_status])
ai = llm_tools.invoke("Where is order A-1042?")
print(ai.tool_calls)
การเรียกใช้และการส่งกลับผลลัพธ์เป็นครึ่งที่สองของลูป:
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
# llm_tools comes from the previous snippet
from langchain_core.messages import HumanMessage, ToolMessage
messages = [HumanMessage("Where is order A-1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)
for call in ai.tool_calls:
result = get_order_status.invoke(call["args"])
messages.append(ToolMessage(content=result, tool_call_id=call["id"]))
print(llm_tools.invoke(messages).content)
โมเดลแบบเปิดน้ำหนักมีความสามารถในการเลือกฟังก์ชันและเติมอาร์กิวเมนต์ที่แตกต่างกัน ควรใช้คำอธิบายฟังก์ชันให้สั้นและชัดเจน ใช้ฟังก์ชันให้น้อยที่สุดต่อหนึ่งการเรียก และตรวจสอบอาร์กิวเมนต์ในฟังก์ชันของคุณแทนที่จะเชื่อใจมัน หากเกิดวงวนในเอเจนต์ ให้ลดค่า temperature และกำหนดจำนวนขั้นตอนสูงสุดในตัวจัดการเอเจนต์ของคุณ
ผลลัพธ์แบบมีโครงสร้างและ JSON
รองรับโหมด JSON ผ่าน response_format: {"type": "json_object"} ใน LangChain วิธีที่ง่ายที่สุดคือการใช้ with_structured_output ซึ่งใช้วิธีการโหมด JSON และตรวจสอบผลลัพธ์กับสคีมาด้วย
# reuses llm from the first example: base_url https://api.llmapistatus.com/v1, model uncensored
from pydantic import BaseModel
class Ticket(BaseModel):
title: str
priority: str
tags: list[str]
structured = llm.with_structured_output(Ticket, method="json_mode")
result = structured.invoke(
"Return JSON with keys title, priority and tags for this report: "
"login page times out on mobile, affects many users."
)
print(result)
โหมด JSON รับประกันว่าผลลัพธ์จะเป็นวัตถุ JSON ไม่ใช่การรับประกันว่ามีฟิลด์ที่คุณต้องการ พฤติกรรมสองอย่างช่วยได้ ประการแรก ตั้งชื่อคีย์ในพรอมต์ตามที่กล่าวไว้ข้างต้น คำสั่งให้สร้าง JSON ควรชัดเจน ประการที่สอง ห่อการเรียกด้วยรีทรีที่ทำการแยกวิเคราะห์ใหม่เมื่อล้มเหลว การตรวจสอบด้วย pydantic จะจับฟิลด์ที่ขาดหายและประเภทข้อมูลที่ไม่ถูกต้อง การรีทรีหนึ่งครั้งพร้อมข้อความข้อผิดพลาดที่เพิ่มเข้าไปมักจะแก้ไขได้
คุณยังสามารถตั้งค่า response_format ได้โดยตรงเมื่อสร้างโมเดลด้วย model_kwargs={"response_format": {"type": "json_object"}} ซึ่งสะดวกสำหรับเชนธรรมดาที่ลงท้ายด้วยการแยกวิเคราะห์ JSON
ขีดจำกัดอัตรา การรีทรี และเชนแบบขนาน
งานแบทช์และเอเจนต์สร้างคำขอจำนวนมากพร้อมกัน และนี่คือจุดที่เอนด์พอยต์แบบกำหนดเองแตกต่างจากโมเดลท้องถิ่น คีย์เต็มรูปแบบอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอและ 300 คำขอต่อนาที คีย์ทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 คำขอและ 60 คำขอต่อนาที เมื่อเกินขีดจำกัด API จะตอบกลับด้วย HTTP 429 และรหัสข้อผิดพลาดrate_limitedหรือconcurrency; เมื่อโหลดเกินชั่วคราวจะตอบกลับ 429 พร้อมRetry-After: 5
การตั้งค่า LangChain สองอย่างจัดการกับเรื่องนี้ส่วนใหญ่ โมเดลรองรับ max_retries ซึ่งทำการรีทรีเมื่อเกิดข้อผิดพลาดชั่วคราวด้วยการถอยหลัง และรันนาเบิลยอมรับค่า max_concurrency ในการกำหนดค่าสำหรับงานแบทช์:
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.llmapistatus.com/v1",
api_key=os.environ["LLM_API_KEY"],
max_retries=4,
timeout=120,
)
questions = [f"Summarise item {i} in one sentence." for i in range(40)]
answers = llm.batch(questions, config={"max_concurrency": 6})
การตั้งค่าค่าจำกัดที่ 6 บนคีย์แบบเต็มจะเหลือพื้นที่สำหรับคำขออื่น ๆ อีกสองคำขอ เช่น คำขอที่แสดงต่อผู้ใช้จากแอปเดียวกัน บนคีย์แบบทดลองให้ใช้ 1 หรือ 2 อย่าพึ่งพาการรีทรีเพียงอย่างเดียวสำหรับปัญหาความพร้อมกัน: หากค่าจำกัดสูงกว่าขีดจำกัด การรีทรีจะสร้างการชนกันเดิมซ้ำ การอ่านค่า X-RateLimit-Limit-Requests และ X-RateLimit-Limit-Concurrency จากส่วนหัวของคำตอบจะบอกคุณว่าคีย์ของคุณได้รับอนุญาตให้ทำอะไรได้
อินพุตที่ยาวใช้ได้จนกว่าจะถึงหน้าต่าง 100,000 โทเคน ซึ่งแบ่งปันระหว่างพรอมต์และการสร้างข้อความ และขนาดของคำขอถูกจำกัดไว้ที่ 8 MB เครื่องมือแบ่งข้อความของ LangChain ที่ตั้งค่าไว้ที่หลายพันโทเคนต่อชิ้นจะช่วยให้คุณอยู่ห่างจากทั้งสองขีดจำกัดนี้
การแก้ไขปัญหาเอนด์พอยต์แบบกำหนดเอง
ปัญหาส่วนใหญ่กับ base URL แบบกำหนดเองอยู่ในรายการสั้น ๆ และแต่ละปัญหามีการทดสอบอย่างรวดเร็ว
- ข้อผิดพลาดการตรวจสอบสิทธิ์ LangChain ยังอ่านตัวแปรสภาพแวดล้อม
OPENAI_API_KEYหากคุณระบุapi_keyโดยตรง ค่านี้จะถูกใช้ แต่ตัวแปรที่ล้าสมัยอาจทำให้ออบเจ็กต์โมเดลที่สองที่คุณลืมกำหนดค่าสับสนได้ ควรส่งคีย์ทุกครั้ง และตั้งชื่อตัวแปรเป็นชื่ออื่น เช่นLLM_API_KEY - ข้อผิดพลาดไม่พบ Base URL ต้องลงท้ายด้วย
/v1LangChain จะเพิ่ม/chat/completionsให้เอง ดังนั้นการเพิ่มลงใน base URLจะทำให้เกิดเส้นทางซ้ำ - โมเดลไม่รู้จักสอบถาม
GET /v1/modelsด้วยคีย์เดียวกันและคัดลอก ID ที่พิมพ์ออกมา มันควรจะเป็นuncensored - การค้างแบบเงียบในโซ่ยาวตั้งค่า
timeoutบนโมเดลและบันทึกส่วนหัวของคำตอบX-Request-Idหากคุณติดต่อฝ่ายสนับสนุน ID นั้นจะช่วยให้พวกเขาพบคำขอที่แน่นอนได้ - ผลลัพธ์ที่น่าประหลาด พิมพ์พรอมต์สุดท้ายก่อนส่ง คำตอบแปลก ๆ ส่วนใหญ่ใน LangChain มาจากเทมเพลตที่เติมตัวแปรด้วยสิ่งที่ไม่คาดคิด ไม่ใช่มาจากโมเดล
เมื่อไม่แน่ใจ ให้ทำซ้ำคำขอที่ล้มเหลวด้วย curl ธรรมดาต่อ URL เดียวกัน หาก curl ทำงานและ LangChain ไม่ทำงาน ความผิดพลาดอยู่ในโซ่ของคุณ; หากทั้งสองอย่างล้มเหลว ให้ตรวจสอบคีย์และยอดเงิน
การตรวจสอบต้นทุนขณะสร้าง
โซ่ซ่อนจำนวนโทเคน ดังนั้นควรวัดตั้งแต่เนิ่นๆ แต่ละการตอบกลับรวมถึงการใช้งาน และส่วนหัวของคำตอบรวมถึงX-Balance-USD ราคาคือ $0.15 ต่อ 1M โทเคนอินพุตและ $0.50 ต่อ 1M โทเคนเอาต์พุต ซึ่งเรียกเก็บจากเครดิตแบบเติมเงินล่วงหน้า
ตัวอย่างการคำนวณ: โซ่การดึงข้อมูลที่ส่ง 6,000 โทเคนของบริบทและคำถามและได้รับ 400 โทเคนกลับมีค่าใช้จ่าย 6,000 x $0.15 / 1M = $0.0009 สำหรับอินพุตบวก 400 x $0.50 / 1M = $0.0002 สำหรับเอาต์พุต ดังนั้น $0.0011 ต่อคำขอ การรัน 5,000 คำขอเช่นนี้ในการทดสอบมีค่าใช้จ่าย $5.50 สิ่งนี้มีประโยชน์ที่จะรู้ก่อนที่คุณจะปล่อยเอเจนต์ลูปทำงานตลอดคืน
คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน หน้าการกำหนดราคา แสดงจำนวนเงินเติมเงินตั้งแต่ $20 ถึง $500 พร้อมโบนัส และบัญชีใหม่สามารถขอเครดิตทดลองใช้ $0.50 ได้ด้วยการคลิกเพียงครั้งเดียว ซึ่งเพียงพอสำหรับการทดสอบขนาดเล็กหลายร้อยครั้งในขณะที่คุณเชื่อมต่อระบบ
คู่มือเพิ่มเติม
ถาม-ตอบ
ฉันต้องสืบทอดคลาสฐานของโมเดลแชทใน LangChain หรือไม่?
ไม่ เอนด์พอยต์นี้เข้ากันได้กับ OpenAI ดังนั้น ChatOpenAI พร้อม base_url แบบกำหนดเอง api_key และโมเดลจึงใช้งานได้ การสืบทอดคลาสจำเป็นเฉพาะสำหรับ API ที่ใช้รูปแบบอื่นเท่านั้น
ฉันสามารถใช้ OpenAIEmbeddings กับเอนด์พอยต์นี้ได้หรือไม่
ไม่ บริการนี้มีเฉพาะข้อความและไม่มีเวกเตอร์ embedding ใช้โมเดล embedding ท้องถิ่นหรือผู้ให้บริการอื่นสำหรับเวกเตอร์ และใช้เอนด์พอยต์นี้สำหรับการสร้างข้อความ
ฉันต้องส่งชื่อโมเดลใด
ส่ง uncensored เป็นโมเดล GET /v1/models จะส่ง ID เดียวกันกลับ
ทำไมฉันจึงได้รับข้อผิดพลาด 429 ในงานแบทช์
คุณเกินขีดจำกัดจำนวนคำขอต่อนาทีหรือคำขอพร้อมกัน ลด max_concurrency ต่ำกว่า 8 บนคีย์เต็ม หรือ 2 บนคีย์ทดลอง และเปิดใช้งานการเรียกซ้ำ
การสตรีมมิงของ LangChain ทำงานที่นี่หรือไม่
ได้ การเรียกใช้ stream หรือ astream ใช้ server-sent events และข้อมูลการใช้งานจะถูกส่งที่ท้ายสตรีม
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด