TH ▾

openaiapiproxy.comพร็อกซี API OpenAI ในภาษา Python: การตั้งค่าและตัวอย่าง

พร็อกซี API OpenAI ในภาษา Python: การตั้งค่าและตัวอย่าง

สำหรับโปรเจกต์พร็อกซี api python openai คุณใช้แพ็กเกจ openai ทางการและเปลี่ยนอาร์กิวเมนต์คอนสตรัคเตอร์สองตัว: base_url และ api_key ส่วนที่เหลือของหน้านี้ครอบคลุมการสตรีมมิง, async, เครื่องมือ, การลองใหม่ และการจัดการงบประมาณ

อัปเดต

เทอร์มินอลแก้วที่มีแถบแสงไหลเข้าสู่ลูกบาศก์ แสดงภาพโค้ด Python ที่เรียกใช้พร็อกซี API

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

  • ติดตั้ง openai จากนั้นสร้าง OpenAI(base_url=..., api_key=...) โดยตั้งค่าโมเดลเป็น uncensored
  • การสตรีมมิง โหมด JSON และการเรียกใช้ฟังก์ชันใช้พารามิเตอร์มาตรฐาน และการทำงานแบบ async ทำงานในลักษณะเดียวกัน
  • จำกัดจำนวนคำขอพร้อมกันสูงสุดที่ 8 ด้วยเซมิโฟร์และให้ SDK ลองใหม่กับการตอบกลับ 429
  • อ่านค่า X-Balance-USD จาก raw response headers เพื่อตรวจสอบเครดิตของคุณจากโค้ด

ตัวอย่างโค้ดที่ทำงานได้ขั้นต่ำ

นี่คือการตั้งค่าพร็อกซี api python openai ที่สั้นที่สุดและใช้งานได้ มันสมมติว่าใช้ Python 3.9 ขึ้นไป คีย์จากหน้า คีย์ API ติดตั้งแพ็กเกจด้วย pip install openai และส่งออกคีย์เป็น UNCENSORED_API_KEY

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.openaiapiproxy.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Give me a one-line product tagline for a hiking app."}],
    temperature=0.8,
    max_tokens=60,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

เอนด์พอยต์นี้เข้ากันได้กับ OpenAI แต่เป็นบริการแยกต่างหาก ไม่ใช่ API ทางการของ OpenAI หรือผู้ขายรายอื่น และโฮสต์โมเดลเพียงโมเดลเดียว คือ uncensored มีเพียงสองเส้นทาง (route) คือ POST /v1/chat/completions และ GET /v1/models ดังนั้นให้ใช้ส่วนติดต่อ (interface) chat completions ของ SDK

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

สตรีมมิงโทเคนเมื่อได้รับ

การสตรีมมิงใช้เหตุการณ์ที่ส่งจากเซิร์ฟเวอร์ (server-sent events) ส่ง stream=True และวนลูปผ่านชิ้นข้อมูล (chunks) ส่วนสุดท้ายของสตรีมมีข้อมูลการใช้งานโทเคน ดังนั้นควรตรวจสอบชิ้นข้อมูล (chunks) ที่ไม่มีตัวเลือก (choices)

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell a two-paragraph ghost story."}],
    stream=True,
)

usage = None
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        usage = chunk.usage
print()
if usage:
    print("tokens:", usage.prompt_tokens, usage.completion_tokens)

รายละเอียดการทำงานอย่างหนึ่ง: การเรียกแบบสตรีมมิงจะครอบครองช่อง (slot) ความพร้อมพร้อมกันหนึ่งช่อง จนกว่าสตรีมจะสิ้นสุด หากโค้ดของคุณออกจากลูปก่อนเวลา ควรปิดสตรีม (stream.close()) เพื่อให้ช่องนั้นว่าง

เว็บแอปพลิเคชันมักห่อหุ้มลูปนี้ไว้ในเจเนอเรเตอร์ (generator) และส่งแต่ละส่วนไปยังเบราว์เซอร์ ด้วย FastAPI นั่นหมายถึงการส่งคืน StreamingResponse ที่ yield ส่วนข้อความ เก็บคีย์ไว้ที่เซิร์ฟเวอร์ในการออกแบบนี้ เบราว์เซอร์จะสื่อสารกับเส้นทาง (route) ของคุณ และเส้นทาง (route) ของคุณจะสื่อสารกับ API ดังนั้นคีย์จะไม่ถูกเปิดเผยต่อโค้ดฝั่งไคลเอนต์

ไคลเอนต์แบบ async และความพร้อมกันที่ควบคุมได้

คีย์แบบเต็มอนุญาตให้ทำคำขอได้ 8 คำขอพร้อมกันและ 300 คำขอต่อนาที คีย์แบบทดลองอนุญาตให้ทำ 2 คำขอและ 60 คำขอ หากคุณเรียก coroutine 200 ตัวด้วย asyncio.gather คุณจะได้รับข้อผิดพลาด 429 หลายรายการด้วยโค้ด concurrency เซมาโฟร์จะแก้ไขปัญหานี้ก่อนเกิดเหตุการณ์

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
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}],
            max_tokens=200,
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Write a title for chapter {i} of a sea adventure." for i in range(1, 41)]
    results = await asyncio.gather(*(ask(p) for p in prompts))
    for t in results:
        print(t)

asyncio.run(main())

ใช้ขนาดเซมิโฟร์เป็น 2 ขณะที่คุณใช้คีย์ทดลองใช้ SDK จะลองใหม่กับการตอบกลับ 429 ด้วยแบ็คออฟโดยอัตโนมัติ และ max_retries เพิ่มจำนวนครั้งที่ลอง สำหรับโอเวอร์โหลดชั่วคราว บริการจะตอบกลับ 429 พร้อม Retry-After: 5 ซึ่ง SDK จะเคารพ

เซมิโฟร์จำกัดเฉพาะคำขอที่กำลังดำเนินการภายในโปรเซสเดียว หากคุณรันเวิร์กเกอร์หลายตัว ให้แบ่งขีดจำกัดระหว่างพวกเขา: ด้วยคีย์แบบเต็ม เวิร์กเกอร์สี่ตัวควรใช้เซมิโฟร์ตัวละ 2 ขีดจำกัดต่อนาทีที่ 300 จะถูกแชร์โดยทั้งหมด ดังนั้นการใช้คิวด้วยอัตราคงที่จึงดีกว่าการส่งข้อมูลแบบบัสต์สำหรับงานออฟไลน์ขนาดใหญ่ ขีดจำกัดขนาดบอดี 8 MB มักไม่ใช่ปัญหาสำหรับแชท แต่มีผลกับทุกคำขอ

โหมด JSON และการเรียกใช้เครื่องมือ

ทั้งสองอย่างทำงานผ่านพารามิเตอร์ปกติ สำหรับโหมด JSON ให้ตั้งค่า response_format และขอ JSON ในพรอมต์

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

r = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Return JSON with keys name, mood and hook."},
        {"role": "user", "content": "Invent a tavern keeper for a fantasy game."},
    ],
)
npc = json.loads(r.choices[0].message.content)
print(npc["name"])

การเรียกใช้เครื่องมือต้องการขั้นตอนเพิ่มเติม: คุณต้องเรียกใช้ฟังก์ชันด้วยตัวเองและส่งผลลัพธ์กลับเป็นข้อความ tool

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

tools = [{
    "type": "function",
    "function": {
        "name": "roll_dice",
        "description": "Roll a die with the given number of sides.",
        "parameters": {
            "type": "object",
            "properties": {"sides": {"type": "integer"}},
            "required": ["sides"],
        },
    },
}]

messages = [{"role": "user", "content": "Roll a twenty-sided die for me."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    sides = json.loads(call.function.arguments)["sides"]
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": "14"})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

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

รายละเอียดเพิ่มเติมอีกสองประการเกี่ยวกับเครื่องมือ ใช้ tool_choice เมื่อคุณต้องการบังคับใช้ฟังก์ชันเฉพาะแทนที่จะปล่อยให้โมเดลตัดสินใจ และรักษาคำอธิบายของเครื่องมือให้เฉพาะเจาะจง: โมเดลเลือกฟังก์ชันจากชื่อและคำอธิบายเพียงอย่างเดียว ดังนั้น "ทอยลูกเต๋าตามจำนวนด้านที่กำหนด" จึงทำงานได้ดีกว่า "ลูกเต๋า" หากคำตอบมีหลายการเรียกใช้ฟังก์ชัน ให้เรียกใช้ทั้งหมดและเพิ่มข้อความ tool ต่อ ID การเรียกใช้แต่ละรายการก่อนที่จะขอคำตอบสุดท้าย

ข้อผิดพลาด การเรียกซ้ำ และประวัติการสนทนา

SDK ยกข้อยกเว้นที่มีประเภท ซึ่งทำให้การจัดการข้อผิดพลาดสั้นลง 429 จะยก openai.RateLimitError ความล้มเหลวของเครือข่ายจะยก openai.APIConnectionError และสถานะที่ไม่สำเร็จอื่นๆ จะยก openai.APIStatusError SDK ได้ทำการเรียกซ้ำแล้วก่อนที่คุณจะเห็นข้อผิดพลาดแรก ดังนั้นสิ่งที่มาถึงโค้ดของคุณคือการเรียกที่ล้มเหลวหลายครั้ง

import time
import openai
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=2)

def chat(messages, attempts=4):
    delay = 2.0
    for n in range(attempts):
        try:
            r = client.chat.completions.create(model="uncensored", messages=messages)
            return r.choices[0].message.content
        except openai.RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay *= 2
        except openai.APIConnectionError:
            time.sleep(delay)
            delay *= 2
    raise RuntimeError("gave up after repeated failures")

print(chat([{"role": "user", "content": "Name a color."}]))

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

ประวัติการสนทนาเป็นส่วนหนึ่งของสถานะอีกส่วนหนึ่ง API ไม่ได้เก็บข้อมูลนี้ให้คุณ ดังนั้นโปรแกรมของคุณจึงเป็นเจ้าของรายการข้อความ นโยบายง่ายๆ ที่ทำงานได้ดี: เก็บข้อความระบบ เก็บการสนทนา N รอบล่าสุด และเมื่อขนาดรวมเกินขนาดที่คุณเลือก ให้ขอให้โมเดลสรุปส่วนที่เก่าที่สุดให้เป็นข้อความสั้นๆ หนึ่งข้อความ

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

def compact(history, keep=6):
    system, rest = history[0], history[1:]
    if len(rest) <= keep:
        return history
    old, recent = rest[:-keep], rest[-keep:]
    text = "\n".join(m["role"] + ": " + m["content"] for m in old)
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": "Summarize this conversation in 120 words:\n" + text}],
        max_tokens=250,
    )
    summary = {"role": "system", "content": "Earlier in this conversation: " + r.choices[0].message.content}
    return [system, summary] + recent

การสรุปข้อมูลใช้โทเคนเช่นกัน แต่คุ้มค่า: การสนทนาที่ปกติจะต้องส่งโทเคน 20,000 ตัวในทุกการสนทนา จะลดลงเหลือเพียงไม่กี่พันตัว

การอ่านยอดคงเหลือและ ID คำขอ

ทุกการตอบกลับรวมถึง X-Request-Id และ X-Balance-USD SDK ซ่อนส่วนหัวโดยค่าเริ่มต้น แต่ with_raw_response เปิดใช้งานส่วนหัว ในขณะที่ยังคงให้วัตถุที่ผ่านการแยกวิเคราะห์มาแล้ว

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance USD:", raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

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

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

หากไม่มี SDK: requests หรือ httpx

หากคุณต้องการหลีกเลี่ยงการพึ่งพา SDK API ใช้งานง่ายพอที่จะใช้กับไคลเอนต์ HTTP ธรรมดาได้

import requests

r = requests.post(
    "https://api.openaiapiproxy.com/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_KEY"},
    json={
        "model": "uncensored",
        "messages": [{"role": "user", "content": "Name three sea shanty topics."}],
    },
    timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])

ตั้งค่า timeout ที่เพียงพอสำหรับการสร้างข้อความยาว โมเดลสามารถใช้หน้าต่างบริบท 100,000 โทเคนได้มากเท่าที่พรอมต์เหลือพื้นที่ว่าง ดังนั้นคำขอสำหรับงานเขียนนิยายยาวๆ ที่ไม่มีข้อจำกัดอาจใช้เวลาสักพัก

แนวทางเดียวกันนี้ใช้ได้กับการสตรีมมิง เพิ่ม "stream": true ในเนื้อหา (body) JSON ส่ง stream=True ไปยัง requests.post และอ่านการตอบกลับด้วย iter_lines() บรรทัดเหตุการณ์แต่ละบรรทัดเริ่มต้นด้วย data: ตามด้วย JSON และการสตรีมจะสิ้นสุดด้วยมาร์คเกอร์ data: [DONE] การแยกวิเคราะห์ด้วยตนเองเป็นแบบฝึกหัดการเรียนรู้ที่ดี แม้สำหรับโค้ดในสภาพแวดล้อมจริง SDK จะทำสิ่งนี้ด้วยกรณีพิเศษที่น้อยกว่า เช่น บรรทัดบางส่วนและการเชื่อมต่อใหม่

การกำหนดงบประมาณภายในโค้ด Python ของคุณ

จำนวนโทเคนใน resp.usage ช่วยให้คุณคำนวณค่าใช้จ่ายต่อคำขอได้ ราคาคือ $0.15 ต่อ 1M โทเคนอินพุต และ $0.50 ต่อ 1M โทเคนเอาต์พุต

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

def cost_usd(prompt_tokens: int, completion_tokens: int) -> float:
    return prompt_tokens * 0.15 / 1_000_000 + completion_tokens * 0.50 / 1_000_000

r = client.chat.completions.create(model="uncensored", messages=[{"role": "user", "content": "Hi"}])
print(cost_usd(r.usage.prompt_tokens, r.usage.completion_tokens))
print(cost_usd(1_000_000, 200_000))  # 0.25

บรรทัดที่สองตรวจสอบด้วยตนเอง: โทเคนอินพุต 1M มีราคา $0.15 และโทเคนเอาต์พุต 200,000 มีราคา 0.2 x $0.50 = $0.10 ซึ่งรวมเป็น $0.25 คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน ดังนั้นคุณไม่จำเป็นต้องลบออก การเติมเงินเริ่มต้นที่ $20 และหน้า ราคา แสดงโบนัสที่ $50, $100 และ $200

สำหรับรายการพารามิเตอร์เต็มรูปแบบและรหัสข้อผิดพลาด ดูที่ เอกสาร

เก็บยอดรวมสะสมในงานของคุณเพื่อให้ลูปไม่สามารถใช้จ่ายเกินกว่าที่คุณวางแผนไว้ งานชุดที่จัดประเภทข้อความสั้นๆ 50,000 ข้อความ ที่ 400 โทเคนอินพุตและ 20 โทเคนเอาต์พุตต่อข้อความ จะใช้โทเคนอินพุต 20M และโทเคนเอาต์พุต 1M ซึ่งคิดเป็นค่าใช้จ่าย 20 x $0.15 + 1 x $0.50 = $3.50 หากตัวนับของคุณระบุว่างานอยู่ที่สองเท่าของจำนวนนั้น แสดงว่ามีลูปทำงานซ้ำ

ถาม-ตอบ

ฉันต้องการแพ็กเกจ Python พิเศษหรือไม่?

ไม่ แพ็คเกจ openai ทางการก็เพียงพอแล้ว ตั้งค่า base_url และ api_key บนไคลเอนต์และใช้ชื่อโมเดล uncensored

ไคลเอนต์ async ทำงานได้หรือไม่?

ได้ AsyncOpenAI รับอาร์กิวเมนต์เดียวกัน จำกัดความพร้อมกันไว้ที่ 8 คำขอต่อคีย์เต็ม หรือ 2 คำขอต่อคีย์ทดลอง

ฉันจะดูเครดิตคงเหลือจากโค้ดได้อย่างไร?

อ่านส่วนหัวการตอบสนอง X-Balance-USD ในแพ็กเกจ openai ให้ใช้ with_raw_response แล้วอ่าน raw.headers

เกิดอะไรขึ้นเมื่อมีข้อผิดพลาด 429?

รหัสข้อผิดพลาด rate_limited หรือ concurrency บอกให้คุณทราบว่าผ่านขีดจำกัดใด SDK จะลองใหม่โดยค่าเริ่มต้น และจะส่งส่วนหัว Retry-After เมื่อมีการโอเวอร์โหลดชั่วคราว

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

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

รับคีย์ API