TH ▾

Uncensored Model Hubโมเดล LangChain แบบโอเพนซอร์สผ่าน API ที่ไม่เซ็นเซอร์

โมเดลโอเพนซอร์ส LangChain ผ่าน API แบบไม่เซ็นเซอร์

LangChain ทำงานกับโมเดลโอเพนซอร์สผ่านเซิร์ฟเวอร์ที่เข้ากันได้กับ OpenAI และ API แบบโฮสต์ช่วยให้คุณไม่ต้องรัน GPU ด้วยตนเอง นี่คือวิธีการตั้งค่าใน Python และ Node พร้อมเครื่องมือ เอเจนต์ ผลลัพธ์ JSON สตรีมมิง และแผนรองรับคำขอพร้อมกัน

อัปเดต

โซ่แก้วที่เชื่อมบล็อกโมดูลาร์เข้ากับกล่องเซิร์ฟเวอร์ แสดงภาพ LangChain พร้อม API โมเดลแบบเปิดน้ำหนัก

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

  1. ใช้ ChatOpenAI โดยตั้งค่า base_url เป็น https://api.uncensoredmodelhub.com/v1 และโมเดล uncensored
  2. การเรียกใช้เครื่องมือ โหมด JSON และสตรีมมิงทำงานผ่านอินเทอร์เฟซ LangChain มาตรฐานทั้งหมด
  3. จำกัด max_concurrency ที่ 8 สำหรับคีย์เต็ม และ 2 สำหรับคีย์ทดลอง เพื่อหลีกเลี่ยงข้อผิดพลาด 429
  4. ราคา $0.15 ต่อ 1M โทเคนอินพุต และ $0.50 ต่อ 1M โทเคนเอาต์พุต โดยไม่มีค่าสมาชิก

เชื่อมต่อ 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 ระบุพารามิเตอร์ที่รองรับทั้งหมดหากคุณต้องการไปให้ไกลกว่านี้

ถาม-ตอบ

ฉันควรใช้คลาส LangChain ใดสำหรับ API นี้?

ใช้ ChatOpenAI จาก langchain-openai ใน Python หรือ @langchain/openai ใน JavaScript ตั้งค่าโมเดลเป็น uncensored และชี้ base_url ไปยัง https://api.uncensoredmodelhub.com/v1.

รองรับเอเจนต์และการเรียกใช้เครื่องมือหรือไม่?

รองรับ การเรียกใช้เครื่องมือใช้รูปแบบ tools แบบ OpenAI ดังนั้น bind_tools และ LangGraph agents จึงใช้งานได้ ตรวจสอบอาร์กิวเมนต์ของเครื่องมือด้วยตนเอง เนื่องจากโมเดลจะส่งกลับเป็นข้อความ

หน้าต่างบริบทสำหรับสายการดึงข้อมูล LangChain คืออะไร?

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

มี embeddings สำหรับเวกเตอร์สโตร์ของฉันหรือไม่?

ไม่มี API เป็นเพียงการแชทข้อความ ไม่มี embeddings รูปภาพ เสียง หรือ fine-tuning ใช้ผู้ให้บริการ embedding แยกต่างหากสำหรับการดึงข้อมูล และใช้ API นี้สำหรับขั้นตอนการสร้างข้อความ

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

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

รับคีย์ API