TH ▾
รับคีย์ API
https://api.deepseekapipricing.com/v1

การตั้งค่า LangChain API DeepSeek: Python และ Node

สำหรับการตั้งค่า DeepSeek API กับ LangChain คุณต้องการเพียงคลาส ChatOpenAI base URL คีย์ และชื่อโมเดล คู่มือนี้ครอบคลุมโค้ด Python และ Node สำหรับการแชท สตรีมมิง การเรียกใช้ฟังก์ชัน JSON output และ concurrency โดยใช้เอนด์พอยต์ที่เข้ากันได้กับ OpenAI แบบอิสระแทน API ของผู้ผลิต

อัปเดต

โซ่เชื่อมส่องแสงเชื่อมต่อเซิร์ฟเวอร์กับฟองแชท แสดงถึงการผสานรวม LangChain กับ API

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

  1. ใช้ ChatOpenAI โดยตั้งค่า base_url เป็น https://api.deepseekapipricing.com/v1 และโมเดล uncensored
  2. ส่ง api_key โดยชัดเจนเพื่อให้คีย์ OpenAI ในสภาพแวดล้อมของคุณไม่ถูกส่งมาที่นี่
  3. สตรีมมิง bind_tools และโหมด JSON ทำงานผ่านพารามิเตอร์รูปแบบ OpenAI มาตรฐาน
  4. จำกัด max_concurrency ไว้ที่ 8 สำหรับคีย์เต็ม หรือ 2 สำหรับคีย์ทดลอง เพื่อหลีกเลี่ยงข้อผิดพลาด 429

สิ่งที่คุณต้องมีก่อนเริ่ม

LangChain เชื่อมต่อกับเซิร์ฟเวอร์ใดๆ ที่รองรับโปรโตคอล chat completions ของ OpenAI จึงไม่ต้องติดตั้งการเชื่อมต่อพิเศษ จุดเริ่มต้นของคุณคือแพ็กเกจเดียวกันที่ใช้กับ OpenAI โดยตรง: langchain-openai สำหรับ Python หรือ @langchain/openai สำหรับ Node มีเพียงสามค่าที่ต้องเปลี่ยน

  • Base URL: https://api.deepseekapipricing.com/v1
  • โมเดล: uncensored
  • คีย์ API: ส่งเป็น Authorization: Bearer <key> ซึ่งไคลเอนต์จัดการให้

คำอธิบายเรื่องชื่อเรียก เอนด์พอยต์นี้เป็นบริการอิสระที่รันโมเดลแบบเปิดน้ำหนักตัวหนึ่งซึ่งปรับแต่งมาเพื่อตอบคำถามโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย ไม่ใช่ API ทางการของ DeepSeek และไม่ใช่ตัวกระจายคำขอข้ามผู้ขาย ดังนั้นชื่อโมเดลคือ uncensored เสมอ ไม่ใช่ ID โมเดลของผู้ขาย หากต้องการคีย์ API หน้า หน้าคีย์ API แสดงขั้นตอนการสมัครและเครดิตทดลองใช้ $0.50 แบบคลิกเดียว

ติดตั้งและเรียกใช้ครั้งแรกด้วย Python

ติดตั้งแพ็กเกจ:

pip install -U langchain-openai langchain-core
# then use base_url https://api.deepseekapipricing.com/v1 and model "uncensored"

จากนั้นสร้างออบเจกต์โมเดล ส่งคีย์ API โดยตรงแทนที่จะพึ่งพาตัวแปรสภาพแวดล้อม OPENAI_API_KEY ซึ่งอาจเก็บคีย์ OpenAI จริงที่คุณไม่อยากส่งไปยังโฮสต์อื่น

import os
from langchain_openai import ChatOpenAI

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

print(llm.invoke("Say hello in five words.").content)

หากพิมพ์คำทักทายได้ แสดงว่าการเชื่อมต่อ คีย์ และชื่อโมเดลถูกต้อง ข้อผิดพลาดที่พบบ่อยที่สุดคือลืม /v1 ใน base URL ซึ่งมักทำให้เกิดข้อผิดพลาด not-found

พรอมต์ เชน และสตรีมมิง

จากจุดนี้ LangChain ทำงานตามปกติ เทมเพลตพรอมต์ โมเดล และ output parser ประกอบเป็น chain ด้วยตัวดำเนินการ pipe:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "You write tight, vivid scene descriptions for adult fiction."),
    ("human", "Describe this setting in under 80 words: {setting}"),
])

chain = prompt | llm | StrOutputParser()
print(chain.invoke({"setting": "a flooded subway station at night"}))

การสตรีมมิงทำงานผ่าน server-sent events ใน LangChain คุณเรียกใช้ stream และแต่ละ chunk จะประกอบด้วยข้อความส่วนหนึ่ง ตั้งค่า stream_usage=True บนโมเดลหากต้องการนับโทเคนที่ตอนจบของสตรีม; API ส่งข้อมูลการใช้งานในเหตุการณ์สุดท้าย

llm_stream = ChatOpenAI(
    model="uncensored",
    base_url="https://api.deepseekapipricing.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
    stream_usage=True,
)

for chunk in llm_stream.stream("Write a four-line poem about a night train."):
    print(chunk.content, end="", flush=True)

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

Node และ TypeScript

แพ็กเกจ JavaScript รับ base URL ภายในออบเจกต์ configuration:

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "uncensored",
  apiKey: process.env.UNCENSORED_API_KEY,
  configuration: { baseURL: "https://api.deepseekapipricing.com/v1" },
  maxRetries: 2,
});

const res = await llm.invoke("Say hello in five words.");
console.log(res.content);

const stream = await llm.stream("Write a four-line poem about a night train.");
for await (const chunk of stream) {
  process.stdout.write(chunk.content);
}

รันเป็น ES module ("type": "module" ใน package.json หรือไฟล์ .mjs) ส่วนอื่น ๆ ของ Node API รวมถึงเทมเพลตพรอมต์และ runnable ทำงานเหมือนโมเดลแชทอื่น ๆ

การเรียกใช้ฟังก์ชันและเอเจนต์

API รองรับรูปแบบเครื่องมือของ OpenAI: พารามิเตอร์ tools และ tool_choice, สตรีมมิง tool_calls และผลลัพธ์เครื่องมือที่ส่งกลับเป็นข้อความด้วย role: "tool" ใน LangChain คุณประกาศเครื่องมือด้วยดีโคเรเตอร์และผูกด้วย bind_tools:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, ToolMessage

@tool
def order_status(order_id: str) -> str:
    """Return the shipping status of an order."""
    return f"Order {order_id} left the warehouse yesterday."

llm_tools = llm.bind_tools([order_status])

messages = [HumanMessage("Where is order 1042?")]
ai = llm_tools.invoke(messages)
messages.append(ai)

for call in ai.tool_calls:
    result = order_status.invoke(call["args"])
    messages.append(ToolMessage(content=result, tool_call_id=call["id"]))

print(llm_tools.invoke(messages).content)

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

นี่คือลูปแบบแมนนวล: โมเดลขอใช้เครื่องมือ คุณเรียกใช้และส่งผลลัพธ์กลับ โมเดลจึงเขียนคำตอบสุดท้าย หากชอบ agent loop สำเร็จรูป ใช้แพ็กเกจ langgraph พร้อม create_react_agent(llm, [order_status]) และเรียกด้วย {"messages": [("user", "Where is order 1042?")]}

ความสามารถของโมเดลในการเลือกเครื่องมือขึ้นอยู่กับตัวโมเดล ดังนั้นควรทดสอบด้วยสคีมาเครื่องมือจริงของคุณ คำอธิบายเครื่องมือที่สั้นและเฉพาะเจาะจงร่วมกับ temperature ต่ำจะช่วยได้ เอเจนต์ที่ทำหกการเรียกพร้อมประวัติที่ยาวขึ้นเรื่อย ๆ รวมอินพุตประมาณ 27,000 โทเคนและเอาต์พุต 1,800 โทเคน มีค่าใช้จ่ายประมาณ $0.00405 บวก $0.0009 หรือประมาณครึ่งเซ็นต์

ผลลัพธ์ที่มีโครงสร้างด้วยโหมด JSON

รองรับโหมด JSON ผ่าน response_format ผูกกับโมเดลและระบุในพรอมต์ว่าคุณต้องการ JSON พร้อมคีย์เฉพาะ เนื่องจากแฟลกรูปแบบควบคุมไวยากรณ์ ไม่ใช่สคีมาของคุณ:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
import json

json_llm = llm.bind(response_format={"type": "json_object"})

msg = json_llm.invoke(
    "Return a JSON object with keys title (string) and tags (list of 3 strings) "
    "for a short story about a lighthouse keeper."
)
data = json.loads(msg.content)
print(data["title"], data["tags"])

ตรวจสอบผลลัพธ์ที่แยกวิเคราะห์แล้วด้วย Pydantic หรือการตรวจสอบของคุณเองก่อนเชื่อถือ และจัดการ json.JSONDecodeError ด้วยการลองใหม่หนึ่งครั้ง สำหรับงานสกัดข้อมูลขนาดใหญ่ ให้แยกวิเคราะห์ทุกการตอบกลับแบบป้องกันไว้ก่อน แทนที่จะสมมติว่าการตอบกลับแรกจะสะอาด

การดึงข้อมูล ความจำ และ callbacks

API นี้ไม่มีเอนด์พอยต์ embeddings ดังนั้นไปป์ไลน์การดึงข้อมูลจึงต้องการแหล่ง embeddings แยก ทุกอย่างหลังจากการดึงข้อมูลคือแชทธรรมดา chain การดึงข้อมูลทั่วไปจะดึงส่วนข้อความที่เกี่ยวข้องจาก vector store ของคุณ นำไปรวมในพรอมต์ และถามโมเดลให้ตอบจากข้อความนั้น เนื่องจากหน้าต่างบริบทคือ 100,000 โทเคน คุณสามารถใช้ส่วนข้อความที่ยาวได้ แต่โปรดจำใบเรียกเก็บเงิน: ทุกโทเคนของบริบทที่ดึงมาคืออินพุตที่ $0.15 ต่อล้าน ดังนั้นบริบท 20,000 โทเคนมีค่าใช้จ่าย $0.003 ต่อคำถาม

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

Callbacks คือจุดที่ใช้บันทึกต้นทุนของการเรียกใช้แต่ละครั้ง การตอบกลับแต่ละครั้งมีบล็อกการใช้งานที่มีโทเคนพรอมต์และโทเคนการตอบกลับ และใน LangChain ข้อความที่ส่งกลับจะเก็บไว้ใน usage_metadata:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
msg = llm.invoke("Name three rivers.")
u = msg.usage_metadata
cost = u["input_tokens"] * 0.15 / 1_000_000 + u["output_tokens"] * 0.50 / 1_000_000
print(u, f"${cost:.6f}")

บันทึกต้นทุนพร้อม ID ของคำขอ เพื่อให้สามารถติดตามบิลที่ผิดปกติไปยังเชนเฉพาะได้

พรอมต์ระบบและน้ำเสียง

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

รายการตรวจสอบสั้นๆ ก่อนนำผลิตภัณฑ์ออกสู่ตลาด

  • คีย์ต้องอยู่ในตัวแปรสภาพแวดล้อมหรือที่เก็บความลับ ห้ามอยู่ในที่เก็บซอร์สโค้ด
  • max_concurrency ถูกตั้งค่าให้ตรงกับขีดจำกัดของคีย์ของคุณ หรือต่ำกว่านั้นหากบริการอื่นใช้คีย์ร่วมกัน
  • การลองใหม่จะใช้back-off ระยะสั้น และจะเคารพการตอบสนอง 429 ที่มี Retry-After: 5
  • สตรีมจะถูกปิดเมื่อไคลเอนต์ตัดการเชื่อมต่อ เพื่อให้ปล่อยช่อง (slot) ให้ว่าง
  • เอาต์พุต JSON จะถูกแยกวิเคราะห์อย่างระมัดระวังและตรวจสอบความถูกต้อง
  • ต้นทุนจะถูกบันทึกแยกตามเชนจากบล็อกการใช้งาน
  • มีระบบสำรองสำหรับกรณีที่เอนด์พอยต์ไม่สามารถเข้าถึงได้ แม้ระบบสำรองจะเป็นเพียงข้อความแสดงข้อผิดพลาด

ปฏิบัติตามรายการนี้และการผสานรวมจะทำงานเหมือนโมเดลแชท LangChain อื่นๆ ความแตกต่างอยู่ที่ด้านเนื้อหา โดยคำขอที่โมเดลอื่นปฏิเสธเนื่องจากการใช้งานผู้ใหญ่ตามกฎหมาย จะได้รับการตอบกลับ

ขีดจำกัดอัตรา concurrency และข้อผิดพลาดทั่วไป

คีย์เต็มจำนวนอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอและ 300 คำขอต่อนาที คีย์ทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 คำขอและ 60 คำขอต่อนาที เนื้อหาคำขอ (body)มีขนาดสูงสุด 8 MB และหน้าต่างบริบทคือ 100,000 โทเคน ซึ่งครอบคลุมทั้งพรอมต์และการตอบกลับ

ตัวช่วยแบบแบทช์ของ LangChain จะกระจายคำขอ ดังนั้นให้ตั้งค่าขีดจำกัดที่ตรงกับคีย์ของคุณ:

# llm = ChatOpenAI(model="uncensored", base_url="https://api.deepseekapipricing.com/v1", ...)
inputs = [{"setting": s} for s in ["a rooftop garden", "a desert diner", "a quiet harbor"]]
results = chain.batch(inputs, config={"max_concurrency": 8})

ใช้ 2 แทน 8 บนคีย์แบบทดลอง เมื่อคุณเกินขีดจำกัด API จะส่ง HTTP 429 พร้อมรหัสข้อผิดพลาด rate_limited (คำขอมากเกินไปต่อนาที) หรือ concurrency (คำขอพร้อมกันมากเกินไป) ในกรณีการโอเวอร์โหลดชั่วคราว API จะส่ง 429 พร้อมเฮดเดอร์ Retry-After: 5 การตั้งค่า max_retries ในไคลเอนต์จะจัดการกรณีชั่วคราว แต่หากคุณเห็นรหัสข้อผิดพลาด concurrency ซ้ำๆ ให้ลด max_concurrency แทนที่จะเพิ่มการลองใหม่

  • ข้อผิดพลาด Not-found ทุกครั้งในการเรียกใช้งาน: ตรวจสอบว่า Base URL ลงท้ายด้วย /v1
  • ข้อผิดพลาดการตรวจสอบสิทธิ์: คีย์หายไปหรือมีตัวอักษรผิด; ยืนยันว่าส่งผ่าน api_key
  • ข้อผิดพลาดของโมเดล: ชื่อโมเดลต้องเป็น uncensored พอดี
  • การรันแบบแบทช์ช้า: สตรีมที่ค้างอยู่จะครอบครองช่อง concurrency ดังนั้นให้ปิดสตรีมเหล่านั้นหรือตั้งค่าเวลาหมดอายุ

ราคาอยู่ที่ $0.15 ต่อล้านโทเคนอินพุตและ $0.50 ต่อล้านโทเคนเอาต์พุต และการเรียกใช้ที่ล้มเหลวหรือถูกปฏิเสธจะไม่คิดเงิน หน้า ราคา แสดงรายการการเติมเงิน และ เอกสารประกอบ ครอบคลุมพารามิเตอร์ทั้งหมดและเฮดเดอร์การตอบกลับ รวมถึง X-Request-Id และ X-Balance-USD ซึ่งมีประโยชน์ต่อการบันทึกใน LangChain callback

01

ถาม-ตอบ

ควรใช้คลาส LangChain ใด?

ใช้ ChatOpenAI จาก langchain-openai ใน Python หรือ ChatOpenAI จาก @langchain/openai ใน Node ตั้งค่า base URL เป็น https://api.deepseekapipricing.com/v1 และโมเดลเป็น uncensored

การสตรีมมิงทำงานกับ LangChain ได้หรือไม่?

ได้ API ส่งข้อมูลแบบสตรีมมิงผ่าน SSE และส่งข้อมูลการใช้งานที่ส่วนท้าย ดังนั้น llm.stream จึงใช้งานได้ ตั้งค่า stream_usage=True หากคุณต้องการนับจำนวนโทเคนในสตรีม

สามารถใช้ embeddings หรือ vector store ที่นี่ได้ไหม?

ไม่ได้จาก API นี้ API นี้รองรับเฉพาะข้อความและไม่มีเอนด์พอยต์สำหรับ embeddings ดังนั้นให้ใช้แหล่งข้อมูล embeddings แยกต่างหากสำหรับการดึงข้อมูล แล้วส่งข้อความที่ดึงได้มาที่นี่

ทำไมฉันจึงได้รับ HTTP 429?

คุณอาจเกินขีดจำกัดต่อนาที (rate_limited) ส่งคำขอพร้อมกันมากเกินไป (concurrency) หรือผู้ให้บริการมีภาระงานเกินชั่วคราว ให้ลด max_concurrency และเคารพค่า Retry-After

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

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

รับคีย์ API