TH ▾
รับคีย์ API

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 ต้องลงท้ายด้วย /v1 LangChain จะเพิ่ม /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 นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API