kimiapikey.comคู่มือ
การผสานคีย์ API Kimi กับ SDK ของ OpenAI และ LangChain
การผสาน API นี้เข้ากับแอปหมายถึงการเปลี่ยนค่าสองค่าในโค้ดที่คุณน่าจะมีอยู่แล้ว ได้แก่ base URL และคีย์ คู่มือนี้แสดงการเปลี่ยนแปลงสำหรับ SDK ของ OpenAI LangChain และ LiteLLM จากนั้นครอบคลุมการลองใหม่และขีดจำกัดสำหรับการใช้งานจริง
อัปเดต

ประเด็นสำคัญ
- ไคลเอนต์ทุกตัวต้องการค่าสามค่าเดียวกัน: base URL https://api.kimiapikey.com/v1, คีย์ของคุณ และโมเดล
uncensored - เก็บค่าเหล่านี้ในตัวแปรสภาพแวดล้อมเพื่อให้คุณสามารถเปลี่ยนผู้ให้บริการได้โดยไม่ต้องแก้ไขโค้ด
- จัดการการตอบกลับ 429 แยกกัน: rate_limited, concurrency และการโอเวอร์โหลดชั่วคราวด้วย Retry-After: 5
- คีย์เต็มรูปแบบอนุญาตให้ทำคำขอพร้อมกัน 8 รายการและ 300 รายการต่อนาที ส่วนคีย์ทดลองอนุญาตให้ทำ 2 รายการและ 60 รายการ
สิ่งที่เปลี่ยนแปลงจริงในโค้ดของคุณ
การผสานรวมคีย์ API ของ kimi ดูเหมือนจะเป็นโปรเจกต์ แต่สำหรับเอนด์พอยต์นี้เป็นการเปลี่ยนแปลงการกำหนดค่า บริการนี้ใช้รูปแบบ chat completions ของ OpenAI ดังนั้นไลบรารีไคลเอนต์ใดๆ ที่ให้คุณตั้งค่า base URL และคีย์จะทำงานได้ ไม่ต้องติดตั้ง SDK แบบกำหนดเอง และไม่ต้องเรียนรู้รูปแบบคำขอใหม่
| การตั้งค่า | ค่า |
|---|---|
| Base URL | https://api.kimiapikey.com/v1 |
| การยืนยันตัวตน | คีย์จากแดชบอร์ดของคุณ ส่งเป็น Authorization: Bearer |
| โมเดล | uncensored |
| เอนด์พอยต์ | POST /v1/chat/completions, GET /v1/models |
สองจุดนี้ช่วยประหยัดเวลา ประการแรก นี่คือโมเดลข้อความที่อยู่หลังเอนด์พอยต์เดียว: ไม่มีเส้นทาง embeddings, ไม่มีการสร้างภาพ, ไม่มีเสียง หากแอปของคุณเรียกใช้ฟีเจอร์เหล่านั้น ให้ใช้ผู้ให้บริการอื่นสำหรับฟีเจอร์เหล่านั้นและกำหนดเส้นทางเฉพาะการสนทนาที่นี่ ประการที่สอง นี่ไม่ใช่ API ทางการของ Kimi หรือผู้ขายรายอื่น แต่เป็นผู้ให้บริการอิสระที่รันโมเดลแบบ open-weight หนึ่งโมเดล ดังนั้นชื่อโมเดลจากแพลตฟอร์มอื่นจะใช้ไม่ได้ คำอธิบายคีย์ API ของ Kimi อธิบายความแตกต่างนี้โดยละเอียดมากขึ้น
รับคีย์ของคุณที่หน้า คีย์ API บัญชีใหม่สามารถรับเครดิตทดลองใช้ฟรีมูลค่า $0.50 ได้ ซึ่งเพียงพอสำหรับทุกตัวอย่างด้านล่าง
การกำหนดค่าและการย้ายแอปพลิเคชันที่มีอยู่
ไลบรารี Python และ Node ของ OpenAI ทางการจะอ่านค่า OPENAI_API_KEY และ OPENAI_BASE_URL จากตัวแปรสภาพแวดล้อมเมื่อคุณไม่ได้ส่งค่าเหล่านี้โดยชัดเจน นั่นทำให้การผสานรวมที่ใช้ความพยายามน้อยที่สุดคือการเปลี่ยนแปลง shell:
export OPENAI_BASE_URL="https://api.kimiapikey.com/v1"
export OPENAI_API_KEY="YOUR_KEY"
โค้ดที่มีอยู่ซึ่งสร้างไคลเอนต์ OpenAI() แบบเปล่าตอนนี้จะเชื่อมต่อกับเอนด์พอยต์นี้ คุณยังคงต้องเปลี่ยนอาร์กิวเมนต์ model เป็น uncensored ควรตั้งชื่อโมเดลเป็นตัวแปรด้วย เช่น LLM_MODEL เพื่อให้สภาพแวดล้อมการทดสอบและสภาพแวดล้อมการผลิตแตกต่างกันได้โดยไม่ต้องแก้ไขโค้ด
นิสัยนี้คุ้มค่ากับเวลาเพียงเล็กน้อยที่ใช้ เมื่อ Base URL คีย์ และโมเดลอยู่ในไฟล์กำหนดค่า การลองใช้ผู้ให้บริการที่เข้ากันได้กับ OpenAI อื่นๆ จึงเป็นการเปลี่ยนแปลงการปรับใช้ และการย้อนกลับก็เป็นการเปลี่ยนแปลงเดียวกันในทิศทางตรงกันข้าม
ทีมส่วนใหญ่ไม่ได้เริ่มจากไฟล์เปล่า พวกเขาจะมีแอปที่เรียกใช้ API รูปแบบ OpenAI อยู่แล้ว และต้องการให้แอปนั้นเรียกใช้ API นี้ การย้ายระบบจึงเป็นการค้นหาสตริงสามชุดเป็นหลัก
- ค้นหาจุดที่สร้างไคลเอนต์และเปลี่ยน Base URL
- ค้นหาอาร์กิวเมนต์
model=ทุกจุดและแทนที่ชื่อเก่าด้วยuncensored - ค้นหาฟีเจอร์ที่โค้ดของคุณใช้ซึ่ง API นี้ไม่มี เช่น embeddings การสร้างภาพ หรือเสียง การเรียกใช้เหล่านั้นต้องอยู่กับผู้ให้บริการรายอื่นหรือถูกลบออก
จากนั้นให้เปรียบเทียบพฤติกรรม ไม่ใช่แค่ไวยากรณ์ โมเดลที่แตกต่างกันมีน้ำเสียง ความยาวเริ่มต้นและนิสัยในการจัดรูปแบบที่แตกต่างกัน รันพรอมต์ทดสอบที่มีอยู่ของคุณ อ่านคำตอบเคียงข้างกันและปรับ system prompt เมื่อโทนเสียงเบี่ยงเบน ข้อความพรอมต์ที่เคยใช้เลี่ยงข้อบกพร่องของโมเดลอื่นบางครั้งไม่ได้ผลอะไรที่นี่ และบางครั้งทำให้แย่ลง ดังนั้นให้ลบวิธีแก้เก่าออกทีละรายการและสังเกตสิ่งที่เปลี่ยนแปลง
ตรวจสอบพารามิเตอร์ที่คุณส่งด้วย temperature top_p stop seed และค่าปรับถูกส่งผ่าน ดังนั้นจึงทำงานตามที่คาดไว้ ฟิลด์ที่เป็นของผู้ขายรายอื่น หรือฟีเจอร์ที่ API นี้ไม่มี จะไม่เกิดประโยชน์ใดๆ รักษาขนาด body ของคำขอให้เล็กและเป็นมาตรฐาน ขีดจำกัดของ body คือ 8 MB ซึ่งสำคัญเฉพาะเมื่อคุณฝังเอกสารขนาดใหญ่โดยตรง
Python: แบบซิงโครนัส สตรีมมิง และแบบอะซิงโครนัส
รูปแบบที่ชัดเจน ซึ่งไม่ขึ้นอยู่กับตัวแปรสภาพแวดล้อม:
from openai import OpenAI
client = OpenAI(
base_url="https://api.kimiapikey.com/v1",
api_key="YOUR_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You answer in plain English."},
{"role": "user", "content": "Explain idempotency in two sentences."},
],
temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
สำหรับการสตรีม ให้ตั้งค่า stream=True และอ่านข้อมูลแบบ chunk เมื่อข้อมูลมาถึง การสตรีมส่งผ่าน server-sent events และรายงานการใช้งานที่ส่วนท้าย
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a limerick about retries."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
สำหรับบริการที่จัดการผู้ใช้จำนวนมาก ให้ใช้ไคลเอนต์แบบ async และจำกัดการทำงานพร้อมกันของคุณเองเพื่อไม่ให้เกินขีดจำกัดการทำงานพร้อมกันของคีย์ Semaphore เป็นวิธีที่ง่ายที่สุด:
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI(
base_url="https://api.kimiapikey.com/v1",
api_key="YOUR_KEY",
)
gate = asyncio.Semaphore(8)
async def ask(prompt: str) -> str:
async with gate:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
)
return r.choices[0].message.content
async def main():
prompts = [f"Give one fact about the number {n}." for n in range(20)]
answers = await asyncio.gather(*(ask(p) for p in prompts))
print(len(answers), "answers")
asyncio.run(main())
ตั้งค่า semaphore เป็น 2 ในขณะที่คุณใช้คีย์ทดลอง และ 8 สำหรับคีย์ที่เติมเงินแล้ว
Node และ TypeScript
ไลบรารี Node ใช้ตัวเลือกสองอย่างเดียวกันภายใต้ชื่อที่แตกต่างเล็กน้อย:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.kimiapikey.com/v1",
apiKey: process.env.API_KEY,
});
const completion = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Name three HTTP status codes." }],
});
console.log(completion.choices[0].message.content);
การสตรีมด้วยไคลเอนต์เดียวกันใช้ stream: true และ async iterator สำหรับผลลัพธ์ หากคุณใช้เฟรมเวิร์ก front-end ที่ห่อหุ้มไลบรารี OpenAI เช่น ชุดเครื่องมือ UI การสนทนา ให้ค้นหาตัวเลือก base URL ของมันและตั้งค่าในลักษณะเดียวกัน เก็บคีย์ไว้ที่เซิร์ฟเวอร์ คีย์ที่วางในโค้ดเบราว์เซอร์สามารถถูกคัดลอกโดยทุกคนที่เปิดเครื่องมือพัฒนาซอฟต์แวร์ และเครดิตที่อยู่เบื้องหลังคีย์นั้นคือเงินจริง
LangChain และ LiteLLM
เฟรมเวิร์กที่ห่อหุ้มไคลเอนต์ OpenAI มักจะเปิดเผยพารามิเตอร์สองตัวเดียวกัน ใน LangChain สำหรับ Python คลาสโมเดลการสนทนาของ OpenAI จะยอมรับพารามิเตอร์เหล่านี้โดยตรง:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="uncensored",
base_url="https://api.kimiapikey.com/v1",
api_key="YOUR_KEY",
temperature=0.5,
)
reply = llm.invoke("Summarize what a message queue does in one sentence.")
print(reply.content)
จากจุดนั้น chains, พรอมต์เทมเพลตและ output parsers ทำงานเหมือนกับโมเดลการสนทนาใดๆ หากคุณผูกเครื่องมือ API รองรับ tool calling ด้วย tools และ tool_choice และผลลัพธ์จากเครื่องมือจะถูกส่งกลับไปยังโมเดลในรูปแบบข้อความ role: "tool" ซึ่งคือสิ่งที่เฟรมเวิร์กสร้างขึ้น
LiteLLM มีประโยชน์เมื่อคุณต้องการรูปแบบการเรียกใช้งานแบบเดียวสำหรับหลายผู้ให้บริการ ให้เติม prefix openai/ หน้าชื่อโมเดล และส่ง base URL เป็น api_base:
import litellm
resp = litellm.completion(
model="openai/uncensored",
api_base="https://api.kimiapikey.com/v1",
api_key="YOUR_KEY",
messages=[{"role": "user", "content": "Say hello in French."}],
)
print(resp.choices[0].message.content)
สำหรับข้อมูลที่มีโครงสร้าง ให้ส่ง response_format={"type": "json_object"} และระบุในพรอมต์ว่าคุณต้องการ JSON ควรแยกวิเคราะห์ผลลัพธ์อย่างระมัดระวังเสมอ เพราะโหมด JSON ขอ JSON ที่ถูกต้อง แต่สคีมาของคุณยังคงเป็นเพียงคำขอในพรอมต์
ขีดจำกัด การ retry และการจัดการข้อผิดพลาด
คีย์ที่เติมเงินแล้วอนุญาตให้ทำคำขอพร้อมกัน 8 รายการและ 300 คำขอต่อนาที คีย์ทดลองอนุญาตให้ทำ 2 และ 60 body สามารถมีขนาดได้สูงสุด 8 MB และหน้าต่างบริบทรองรับ 100,000 โทเคนสำหรับพรอมต์และการตอบกลับรวมกัน เมื่อคุณเกินขีดจำกัด API จะตอบกลับด้วย HTTP 429 และข้อความใดข้อความหนึ่งต่อไปนี้:
rate_limited: คำขอมากเกินไปต่อนาที ให้หน่วงเวลา (back off) สักสองสามวินาทีconcurrency: คำขอมากเกินไปที่กำลังทำงานอยู่ ให้รอให้คำขอหนึ่งเสร็จสิ้น คำขอที่สตรีมจะยึดช่องของมันไว้จนกว่าการสตรีมจะสิ้นสุด ดังนั้นconsumer ที่อ่านข้อมูลช้าจึงนับเป็นภาระของคุณ- 429 พร้อม
Retry-After: 5: เกิด overload ชั่วคราว ให้รอห้าวินาทีแล้วลองอีกครั้ง
ตัวห่อการ retry ขนาดเล็กที่เคารพ header นี้จะจัดการทั้งสามกรณี:
import time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.kimiapikey.com/v1", api_key="YOUR_KEY", max_retries=0)
def chat(messages, tries=4):
for attempt in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError as e:
wait = int(e.response.headers.get("retry-after", 2 ** attempt))
time.sleep(wait)
raise RuntimeError("still rate limited after retries")
คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน ดังนั้นการลองใหม่จึงไม่มีค่าใช้จ่ายเพิ่มเติม บันทึกส่วนหัวการตอบกลับ X-Request-Id กับทุกการเรียกใช้ ซึ่งเป็นวิธีที่เร็วที่สุดในการชี้ไปที่คำขอหนึ่งรายการหากมีบางอย่างดูผิดปกติ X-Balance-USD บอกคุณว่าเครดิตที่เหลืออยู่ ซึ่งคุณสามารถนำไปใช้กับการแจ้งเตือนได้ เอกสารประกอบ ระบุส่วนหัวการตอบกลับทั้งหมด
การเรียกใช้ฟังก์ชันผ่าน framework
เฟรมเวิร์ก Agent ขึ้นอยู่กับ tool calling ดังนั้นจึงคุ้มค่ากับการทดสอบสั้นๆ ก่อนที่จะสร้างบนสิ่งนี้ API นี้ยอมรับ tools และ tool_choice คืนค่า tool_calls เมื่อโมเดลต้องการให้ฟังก์ชันทำงาน และคาดหวังผลลัพธ์เป็นข้อความ role: "tool" ที่อ้างอิงถึง ID การเรียกใช้ การสตรีมทำงานกับเครื่องมือ โดยที่การเรียกมาถึงในชิ้นส่วนที่ SDK รวบรวมให้คุณ
การทดสอบเบื้องต้นที่ดีคือการใช้ agent ที่มีฟังก์ชันเดียว ซึ่งผลลัพธ์สามารถตรวจสอบด้วยตาเปล่าได้ เช่น เครื่องคิดเลขหรือการค้นหาในพจนานุกรมขนาดเล็ก รันมันสิบครั้ง หากโมเดลเลือกฟังก์ชันและกรอกอาร์กิวเมนต์ได้ถูกต้องทุกครั้ง คุณสามารถเพิ่มฟังก์ชันที่สองได้ หากบางครั้งโมเดลตอบจากหน่วยความจำแทนที่จะเรียกฟังก์ชัน ให้ทำให้คำอธิบายฟังก์ชันเฉพาะเจาะจงขึ้น หรือตั้งค่า tool_choice เพื่อบังคับการเรียกใช้สำหรับขั้นตอนนี้ โมเดลมีความสามารถในการควบคุมลำดับการเรียกที่ยาวนานแตกต่างกัน ดังนั้นควรเก็บลำดับการเรียกให้สั้นและเพิ่มขีดจำกัดขั้นตอนในลูปใดๆ เพื่อไม่ให้การรันที่สับสนหมุนวนไปเรื่อยๆ และใช้เครดิตหมด
รายการตรวจสอบก่อนเปิดตัวแบบสั้นๆ
- รันคำขอหนึ่งรายการผ่าน curl หรือ SDK และยืนยันว่าบล็อกการใช้งานมีอยู่
- ทดสอบการสตรีมด้วยไคลเอนต์ที่จะใช้ในสภาพแวดล้อมการผลิต รวมถึงสิ่งที่เกิดขึ้นเมื่อผู้ใช้ปิดหน้าเว็บกลางการสตรีม
- จำกัดการทำงานพร้อมกันของคุณเองให้ต่ำกว่าขีดจำกัดของคีย์
- ตั้งค่า
max_tokensเมื่อคาดหวังคำตอบสั้นๆ และตัดประวัติแชทออกก่อนที่มันจะเติบโตเกินกว่าที่คุณต้องการจ่าย - เก็บคีย์ในการกำหนดค่าฝั่งเซิร์ฟเวอร์และเปลี่ยนคีย์ใหม่หากปรากฏใน log
- ตรวจสอบต้นทุนจาก traffic จริง ที่ราคา $0.15 ต่อ 1M input และ $0.50 ต่อ 1M output คำขอที่มี 3,000 โทเคนเป็น input และ 700 โทเคนเป็น output มีค่าใช้จ่าย $0.0008 ดังนั้น 10,000 คำขอจะมีค่าใช้จ่ายประมาณ $8 รายละเอียดอยู่ที่ หน้าราคา
พรอมต์ที่ส่งไปยัง API ไม่ถูกใช้ในการฝึกอบรม กฎเนื้อหาข้อเดียวที่ไม่เปลี่ยนแปลงคือขีดจำกัดที่เข้มงวดเกี่ยวกับเนื้อหาทางเพศที่เกี่ยวข้องกับผู้เยาว์ โมเดลได้รับการปรับแต่งเพื่อตอบโดยไม่มีการปฏิเสธสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย ดังนั้นแอปที่ให้บริการสาธารณะควรเพิ่มการตรวจสอบเนื้อหาและการตรวจสอบอายุของตนเองตามกฎหมายหรือความคาดหวังของผู้ใช้
คู่มือเพิ่มเติม
- วิธีใช้คีย์ API แบบ Kimi ใน Cursor: คู่มือการติดตั้ง
- ราคาคีย์ API ของ Kimi: ค่าใช้จ่ายของทางเลือกนี้
- คีย์ API ของ Kimi: วิธีการทำงานและทางเลือกอื่นๆ
คำถามที่พบบ่อย
โมเดลเหมือนกันกับ Kimi ทางการของ Moonshot หรือไม่?
ไม่ เราโฮสต์โมเดลแบบเปิดน้ำหนักที่ปรับแต่งให้ไม่เซ็นเซอร์ มันไม่ใช่ GPT, Claude, Gemini, Grok, DeepSeek หรือโมเดลของผู้ให้บริการรายอื่น มันเป็นโมเดลที่แตกต่างกันที่รันบนเซิร์ฟเวอร์ของเราเอง
คุณฝึกข้อมูลของฉันหรือไม่?
ไม่ พรอมต์และการสร้างข้อความของคุณไม่ถูกใช้ในการฝึก เราให้ความสำคัญกับความเป็นส่วนตัวและความโปร่งใส ดังนั้นข้อมูลของคุณยังคงเป็นของคุณ
ขีดจำกัดอัตราคืออะไร?
คุณจำกัดอยู่ที่ 300 คำขอต่อนาทีต่อคีย์ ขนาด body ของคำขอสูงสุดคือ 8 MB ขีดจำกัดเหล่านี้ถูกออกแบบมาเพื่อให้แน่ใจว่าประสิทธิภาพที่เสถียรสำหรับผู้ใช้ทุกคน
นโยบายเนื้อหาคืออะไร?
โมเดลไม่เซ็นเซอร์เรื่องผู้ใหญ่ ที่ถกเถียงกัน และสร้างสรรค์ แต่เราบล็อกเนื้อหาทางเพศที่เกี่ยวข้องกับผู้เยาว์ นี่คือขีดจำกัดที่เข้มงวดซึ่งใช้เสมอไม่ว่าระดับสมาชิกของคุณจะเป็นอย่างไร
ถาม-ตอบ
ฉันต้องการ SDK พิเศษหรือไม่
ไม่ ไลบรารีมาตรฐานของ OpenAI สำหรับ Python และ Node ทำงานได้หลังจากที่คุณตั้งค่า base URL เป็น https://api.kimiapikey.com/v1 และใช้คีย์ของคุณ LangChain และ LiteLLM ทำงานในลักษณะเดียวกัน
ชื่อโมเดลที่โค้ดของฉันควรใช้คืออะไร?
ใช้ uncensored นี่คือโมเดล ID เดียวที่ API ให้บริการ และ GET /v1/models จะแสดงรายการนี้
ฉันจะหลีกเลี่ยงข้อผิดพลาด 429 ได้อย่างไร?
จำกัดคำขอพร้อมกันของคุณไว้ที่ 8 สำหรับคีย์ที่เติมเงินแล้ว หรือ 2 สำหรับคีย์ทดลอง และลองใหม่หลังจากช่วงความล่าช้า Retry-After เมื่อ API แจ้งขอ
รองรับการเรียกใช้เครื่องมือ (tool calling)และโหมด JSON หรือไม่
รองรับ ใช้ tools และ tool_choice สำหรับการเรียกใช้ฟังก์ชัน และ response_format พร้อม type json_object สำหรับผลลัพธ์ JSON การสตรีมมิงก็ใช้งานได้เช่นกัน
สามารถใช้ embeddings หรือการสร้างภาพผ่านคีย์เดียวกันได้หรือไม่?
ไม่ได้ API เป็นเพียงแชทข้อความเท่านั้น ไม่มีเอนด์พอยต์สำหรับ embeddings ภาพ เสียง หรือวิดีโอ
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด