TH ▾
รับคีย์ API

kimiapikey.comคู่มือ

การผสานคีย์ API Kimi กับ SDK ของ OpenAI และ LangChain

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

อัปเดต

บล็อกไอโซเมตริกที่เชื่อมต่อด้วยเส้นเรืองแสงไปยังฮับกลาง แสดงแอปที่ผสานกับ API เดียว

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

  • ไคลเอนต์ทุกตัวต้องการค่าสามค่าเดียวกัน: 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 URLhttps://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 นี้ การย้ายระบบจึงเป็นการค้นหาสตริงสามชุดเป็นหลัก

  1. ค้นหาจุดที่สร้างไคลเอนต์และเปลี่ยน Base URL
  2. ค้นหาอาร์กิวเมนต์ model= ทุกจุดและแทนที่ชื่อเก่าด้วย uncensored
  3. ค้นหาฟีเจอร์ที่โค้ดของคุณใช้ซึ่ง 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 เพื่อบังคับการเรียกใช้สำหรับขั้นตอนนี้ โมเดลมีความสามารถในการควบคุมลำดับการเรียกที่ยาวนานแตกต่างกัน ดังนั้นควรเก็บลำดับการเรียกให้สั้นและเพิ่มขีดจำกัดขั้นตอนในลูปใดๆ เพื่อไม่ให้การรันที่สับสนหมุนวนไปเรื่อยๆ และใช้เครดิตหมด

รายการตรวจสอบก่อนเปิดตัวแบบสั้นๆ

  1. รันคำขอหนึ่งรายการผ่าน curl หรือ SDK และยืนยันว่าบล็อกการใช้งานมีอยู่
  2. ทดสอบการสตรีมด้วยไคลเอนต์ที่จะใช้ในสภาพแวดล้อมการผลิต รวมถึงสิ่งที่เกิดขึ้นเมื่อผู้ใช้ปิดหน้าเว็บกลางการสตรีม
  3. จำกัดการทำงานพร้อมกันของคุณเองให้ต่ำกว่าขีดจำกัดของคีย์
  4. ตั้งค่า max_tokens เมื่อคาดหวังคำตอบสั้นๆ และตัดประวัติแชทออกก่อนที่มันจะเติบโตเกินกว่าที่คุณต้องการจ่าย
  5. เก็บคีย์ในการกำหนดค่าฝั่งเซิร์ฟเวอร์และเปลี่ยนคีย์ใหม่หากปรากฏใน log
  6. ตรวจสอบต้นทุนจาก traffic จริง ที่ราคา $0.15 ต่อ 1M input และ $0.50 ต่อ 1M output คำขอที่มี 3,000 โทเคนเป็น input และ 700 โทเคนเป็น output มีค่าใช้จ่าย $0.0008 ดังนั้น 10,000 คำขอจะมีค่าใช้จ่ายประมาณ $8 รายละเอียดอยู่ที่ หน้าราคา

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

คำถามที่พบบ่อย

โมเดลเหมือนกันกับ 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 นั่นคือการตั้งค่าทั้งหมด

รับคีย์ APIอ่านเอกสาร