LLM ที่ดีที่สุดสำหรับเขียน Python: วิธีเลือกและทดสอบ
ไม่มี LLM เดียวที่ดีที่สุดสำหรับการเขียนโค้ด Python เพราะคำตอบขึ้นอยู่กับงานของคุณ ขนาด context size และสิ่งที่คุณยินดีจ่ายต่อคำขอ บทความนี้ให้เกณฑ์ โค้ดทำงานสำหรับ workflow การเขียนโค้ดสามรูปแบบ และ harness เล็กๆ เพื่อเปรียบเทียบโมเดลกับงานของคุณเอง
อัปเดต

ประเด็นสำคัญ
- การจัดอันดับสาธารณะเป็นจุดเริ่มต้น การทดสอบ 50 งานบนโค้ดเบสของคุณเองบอกคุณได้มากกว่า
- สำหรับการใช้งาน API ตรวจสอบขนาด context size, การเรียกใช้เครื่องมือ, โหมด JSON, การตั้งค่า deterministic และราคาต่อคำขอ
- API นี้ให้บริการโมเดลแบบเปิดน้ำหนักหนึ่งตัวพร้อมหน้าต่าง 100,000 โทเคน การเรียกใช้ฟังก์ชัน และโหมด JSON ในราคา $0.15 และ $0.50 ต่อ 1M โทเคน
- การรันการประเมินผลแบบ 150 ครั้งมีค่าใช้จ่ายประมาณ 5 เซนต์ ดังนั้นการวัดผลจึงถูกกว่าการเดา
ทำไมไม่มีโมเดลใดที่ดีที่สุดสำหรับทุกคน
การเขียนโค้ด Python ครอบคลุมงานที่หลากหลายมาก การเขียนฟังก์ชันช่วยขนาดสิบบรรทัด การรีแฟคเตอร์โมดูลขนาด 2,000 บรรทัด การอ่าน stack trace การสร้างเทสต์ การแปลสคริปต์ shell เป็น Python และการสร้างเครื่องมือที่แก้ไขไฟล์ ล้วนเป็นการเขียนโค้ด และโมเดลอาจเก่งในงานหนึ่งแต่ทำได้อ่อนด้อยในงานอื่น ตารางจัดอันดับเฉลี่ยจากงานหลายประเภทและหลายภาษา ที่เก็บโค้ดของคุณ กฎสไตล์ของคุณ และไลบรารีของคุณเป็นเพียงส่วนเล็กๆ ของสิ่งนั้น
ดังนั้นคำตอบในทางปฏิบัติต่อคำถามนี้คือขั้นตอนการตัดสินใจ เลือกสิ่งที่ต้องการ สั้นรายการโมเดลสองหรือสามตัวที่ตรงตามข้อกำหนดทางเทคนิค รันงานเดียวกันผ่านแต่ละโมเดล และนับจำนวนที่ผ่านเทสต์ของคุณเอง ส่วนที่เหลือของบทความนี้ครอบคลุมข้อกำหนด จากนั้นแสดงวิธีการทดสอบกับ API นี้
อีกจุดหนึ่งก่อนเข้าสู่รายละเอียด บริการเบื้องหลังเว็บไซต์นี้รันโมเดลแบบเปิดน้ำหนักหนึ่งตัว ดำเนินการโดยผู้ให้บริการอิสระและปรับแต่งให้ตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย ไม่ใช่ API ทางการของvendor โมเดลใด และไม่มีข้ออ้างเกี่ยวกับผลการทดสอบมาตรฐาน ให้ถือเป็นตัวเลือกหนึ่งในรายการสั้นๆ ของคุณและวัดผลเหมือนตัวเลือกอื่นๆ
เกณฑ์สำคัญสำหรับ API
หากคุณเรียกใช้โมเดลจากโค้ดแทนที่จะแชทกับมันใน editor คุณสมบัติทางเทคนิคไม่กี่อย่างจะเป็นตัวตัดสินว่าโมเดลนั้นเหมาะกับคุณหรือไม่
| เกณฑ์ | เหตุผลที่สำคัญสำหรับงาน Python | API นี้ |
|---|---|---|
| หน้าต่างบริบท | โมดูลทั้งหมด traceback ยาวและผลลัพธ์เทสต์ต้องพอดีกับพื้นที่สำหรับคำตอบ | 100,000 โทเคน, พรอมต์รวมกับผลลัพธ์ |
| การเรียกใช้ฟังก์ชัน | ช่วยให้โมเดลรันโค้ด เทสต์ และ linter จากนั้นตอบสนองต่อผลลัพธ์ | ใช่: tools, tool_choice, streamed tool_calls |
| โหมด JSON | การตรวจสอบ รายงาน linter และแผนการรีแฟคเตอร์ที่เครื่องอ่านได้ | ใช่: response_format json_object |
| ความสามารถในการทำซ้ำ | temperature ต่ำกว่าและ seed ที่กำหนดทำให้การรันเทสต์เปรียบเทียบกันได้ | temperature, top_p, stop, seed และค่าปรับส่งผ่าน |
| สตรีมมิง | เครื่องมือที่ตอบสนองเร็วและการสร้างข้อความยาว | SSE พร้อมข้อมูลการใช้งานที่ส่วนท้าย |
| ราคา | ลูปของ agent ส่งบริบทซ้ำหลายครั้ง | $0.15 สำหรับ input และ $0.50 สำหรับ output ต่อ 1M โทเคน |
| การปฏิเสธ | เครื่องมือด้านความปลอดภัย เครื่องเก็บข้อมูล และสคริปต์ red-team สำหรับระบบที่คุณเป็นเจ้าของเป็นสิ่งที่ถูกต้องตามกฎหมายแต่มักถูกปฏิเสธ | ปรับแต่งให้ตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย |
ตารางไม่ได้กล่าวถึงคุณภาพโค้ด เพราะคุณสมบัติข้างต้นเป็นข้อเท็จจริง และคุณภาพเป็นสิ่งที่ต้องทดสอบ คุณภาพยังเปลี่ยนแปลงตามพรอมต์ด้วย ข้อความระบบที่ระบุเวอร์ชัน Python ไลบรารีที่อนุญาต และรูปแบบคำตอบ มักมีความสำคัญพอๆ กับโมเดล
API นี้รองรับเฉพาะข้อความ คุณส่งโค้ดเป็นข้อความในพรอมต์ และได้รับข้อความกลับ ไม่มีการสร้างภาพ เสียง หรือวิดีโอ ไม่มี embeddings และไม่มี fine-tuning ดังนั้นระบบค้นหาโค้ดที่ต้องการ embeddings จะต้องรับค่าเหล่านั้นจากที่อื่น
เวิร์กโฟลว์ 1: สร้างฟังก์ชันด้วยพรอมต์ที่เข้มงวด
เริ่มต้นด้วยกรณีง่ายๆที่สุด: ขอฟังก์ชันเดียวแล้วแยกบล็อกโค้ด อุณหภูมิต่ำให้ผลลัพธ์ที่เสถียร ข้อความระบบระบุเวอร์ชันภาษาและรูปแบบการตอบ ซึ่งทำให้การแยกข้อมูลทำได้ด้วย regex บรรทัดเดียว รับคีย์จากหน้า key แล้ว export เป็น LLM_API_KEY
import os
import re
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
def ask_for_code(task):
resp = client.chat.completions.create(
model="uncensored",
temperature=0.2,
messages=[
{
"role": "system",
"content": (
"You are a senior Python developer. Use Python 3.11, the standard "
"library only unless told otherwise, and type hints. Reply with one "
"fenced python block and at most three sentences of explanation."
),
},
{"role": "user", "content": task},
],
)
text = resp.choices[0].message.content
match = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
return match.group(1) if match else text
print(ask_for_code("Write parse_duration(s) that turns '1h30m' or '45s' into seconds."))
นิสัยการเขียนพรอมต์สามอย่างช่วยในเรื่องนี้ ระบุเวอร์ชัน Python เพื่อให้โมเดลไม่ใช้ไวยากรณ์ที่คุณไม่สามารถรันได้ บอกว่า "ใช้เฉพาะไลบรารีมาตรฐาน" เว้นแต่คุณต้องการแพ็กเกจจากบุคคลที่สามจริงๆ และขอคำตอบสั้นๆ เพราะคำอธิบายที่ยาวใช้โทเคนเอาท์พุตและไม่บ่อยนักที่จะเปลี่ยนโค้ด หากโมเดลยังคงเพิ่มข้อความบรรยายหลังบล็อก ให้ส่งลำดับ stop หรือตัดทุกสิ่งที่อยู่นอก fence ออกเหมือนที่ regex ทำ
เวิร์กโฟลว์ 2: ให้โมเดลรันและแก้ไขโค้ดของตัวเอง
ความก้าวกระโดดในเรื่องความน่าเชื่อถือมักมาจากการเรียกใช้เครื่องมือ แทนที่จะขอโค้ดแล้วหวังว่าโค้ดจะทำงาน คุณให้โมเดลมีฟังก์ชันที่รันสคริปต์และส่งผลลัพธ์กลับ โมเดลจะเขียนโค้ด รันโค้ด อ่าน traceback และแก้ไขตัวเอง ผลลัพธ์จากเครื่องมือจะส่งกลับเป็นข้อความที่มี role: "tool" ซึ่งจับคู่ด้วย tool_call_id
import json
import os
import subprocess
import sys
import tempfile
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
def run_python(code):
with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
f.write(code)
try:
r = subprocess.run([sys.executable, f.name], capture_output=True, text=True, timeout=10)
return (r.stdout + r.stderr)[-3000:] or "(no output)"
except subprocess.TimeoutExpired:
return "timeout after 10 seconds"
tools = [{
"type": "function",
"function": {
"name": "run_python",
"description": "Run a Python script and return stdout and stderr.",
"parameters": {
"type": "object",
"properties": {"code": {"type": "string"}},
"required": ["code"],
},
},
}]
messages = [
{"role": "system", "content": "You write Python 3. Test your code with run_python before the final answer."},
{"role": "user", "content": "Write parse_duration(s) for strings like '1h30m' or '45s'. Include asserts."},
]
for _ in range(5):
resp = client.chat.completions.create(
model="uncensored",
messages=messages,
tools=tools,
tool_choice="auto",
temperature=0.2,
)
msg = resp.choices[0].message
messages.append(msg.model_dump(exclude_none=True))
if not msg.tool_calls:
print(msg.content)
break
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": run_python(args["code"]),
})
ใช้ฟังก์ชัน run_python อย่างระมัดระวัง มันรันโค้ดที่โมเดลเขียนบนเครื่องของคุณ ด้วยสิทธิ์ของคุณ สำหรับงานที่เกินกว่าการทดลองแบบทิ้งได้ ให้รันใน container หรือ virtual machine แบบชั่วคราว โดยไม่มีเครือข่าย มีเวลาจำกัด และไม่สามารถเข้าถึงข้อมูลรับรองของคุณได้ เวลาหมดอายุ 10 วินาทีและเอาท์พุตที่ตัดในตัวอย่างเป็นค่าต่ำสุด
ลูปถูกจำกัดไว้ที่ห้ารอบ เพื่อให้โมเดลที่สับสนไม่สามารถหมุนไปเรื่อยๆ ได้ ในทางปฏิบัติ ฟังก์ชันง่ายๆ ส่วนใหญ่ต้องการการรันเพียงหนึ่งหรือสองครั้ง หากคุณเห็นโมเดลทำซ้ำคำขอที่ล้มเหลวเดิม ให้เพิ่ม traceback เป็นข้อความในคำขอผู้ใช้ถัดไป หรือลดอุณหภูมิลง โปรดทราบว่าคำขอสตรีมมิงที่มีการเรียกใช้ฟังก์ชันจะครอบครองช่อง concurrent ไว้จนกว่าสตรีมจะสิ้นสุด และคีย์เต็มอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอ ดังนั้นทีมที่แชร์คีย์เดียวกันควรจัดคิวการรันของ agent
เวิร์กโฟลว์ 3: การทบทวนโค้ดแบบมีโครงสร้างด้วยโหมด JSON
การตรวจสอบมีประโยชน์เมื่อสคริปต์สามารถอ่านค่าได้ โหมด JSON บังคับให้ใช้ JSON ที่ถูกต้อง และข้อความระบบกำหนดโครงสร้าง ด้วย temperature 0 และ seed ที่คงที่ ไฟล์เดียวกันจะผลิตผลการตรวจสอบเดียวกันในการรันซ้ำ ซึ่งทำให้การเปรียบเทียบความแตกต่างระหว่างการรันมีความหมาย
import json
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
source = open("service.py").read()
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
temperature=0,
seed=7,
messages=[
{
"role": "system",
"content": (
"Review the Python file. Reply with a JSON object with the key issues, "
"a list of objects with keys line, severity (low, medium or high), "
"problem and fix. Return an empty list if you find nothing."
),
},
{"role": "user", "content": source},
],
)
for issue in json.loads(resp.choices[0].message.content)["issues"]:
print(issue["severity"], issue["line"], issue["problem"])
ใช้สิ่งนี้จาก pre-commit hook หรือขั้นตอน CI และพิมพ์ผลลัพธ์เป็นคำอธิบายประกอบ คาดการณ์ผลบวกปลอมและผลลบปลอม ผู้ตรวจสอบโมเดลคือตาคู่ที่สองที่รวดเร็วและไม่มีวันเหนื่อย แต่ไม่ได้แทนที่การทดสอบ type checker หรือ linter ให้รันสิ่งเหล่านั้นก่อนแล้วใช้โมเดลสำหรับสิ่งที่พวกเขาไม่สามารถเห็นได้ เช่น การตั้งชื่อที่ไม่ชัดเจน กรณีขอบเขตที่ขาดหายไป และการจัดการข้อผิดพลาดที่กลืนข้อยกเว้น
หน้าต่าง 100,000 โทเคนอนุญาตให้ใช้ไฟล์ทั้งหมดและบางครั้งแพ็กเกจขนาดเล็กในหนึ่งคำขอ ข้อจำกัด body คือ 8 MB ซึ่งคุณจะไม่ถึงด้วยซอร์สโค้ด หากการทบทวนถูกตัดออก ให้ตรวจสอบว่าคุณตั้งค่า max_tokens ต่ำเกินไปหรือไม่ พารามิเตอร์นี้เป็นตัวเลือกและการสร้างข้อความอาจใช้สิ่งที่เหลือของหน้าต่าง
ทดสอบโมเดลกับงานของคุณเอง
นี่คือชุดทดสอบขนาดเล็กที่ทำสิ่งที่ลีดเดอร์บอร์ดทำไม่ได้: รันงานของคุณกับเทสต์ของคุณ งานแต่ละงานมีพรอมต์และโค้ดเทสต์ สคริปต์จะขอโค้ดจากโมเดลหลายครั้ง แล้วเพิ่มเทสต์ลงในโค้ด รันผลลัพธ์ และนับจำนวนที่ผ่าน เปลี่ยน URL พื้นฐานและชื่อโมเดลเพื่อเปรียบเทียบผู้ให้บริการอื่นในลักษณะเดียวกัน
import os
import re
import subprocess
import sys
import tempfile
from openai import OpenAI
client = OpenAI(
base_url="https://api.visionllmapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
TASKS = [
{
"prompt": "Write is_palindrome(s) that ignores case and non-alphanumeric characters.",
"test": "assert is_palindrome('A man, a plan, a canal: Panama')\nassert not is_palindrome('abc')",
},
{
"prompt": "Write chunk(items, n) that yields lists of at most n items.",
"test": "assert list(chunk([1,2,3,4,5], 2)) == [[1,2],[3,4],[5]]",
},
]
SAMPLES = 3
def extract(text):
m = re.search(r"```(?:python)?\n(.*?)```", text, re.S)
return m.group(1) if m else text
def passes(code, test):
with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
f.write(code + "\n\n" + test + "\n")
try:
r = subprocess.run([sys.executable, f.name], capture_output=True, timeout=10)
return r.returncode == 0
except subprocess.TimeoutExpired:
return False
total = ok = 0
for task in TASKS:
for _ in range(SAMPLES):
resp = client.chat.completions.create(
model="uncensored",
temperature=0.4,
messages=[
{"role": "system", "content": "Reply with one fenced python block and nothing else."},
{"role": "user", "content": task["prompt"]},
],
)
total += 1
ok += passes(extract(resp.choices[0].message.content), task["test"])
print(f"{ok}/{total} passed")
เพิ่มรายการงานเป็น 30 หรือ 50 รายการจากงานจริง: บั๊กที่คุณแก้ไขเมื่อเดือนที่แล้ว parser ที่คุณเขียน ฟังก์ชันที่มีกรณีขอบเขตที่แปลกๆ รวมงานที่เครื่องมืออื่นปฏิเสธหรือลังเลไว้ด้วย รันแต่ละงานสามถึงห้าครั้งเพราะตัวอย่างหนึ่งตัวบอกได้น้อย บันทึกอัตราการผ่าน ความยาวผลลัพธ์เฉลี่ย และต้นทุนต่องาน และเก็บผลลัพธ์ไว้ในไฟล์เพื่อที่คุณจะได้รันใหม่หลังจากเปลี่ยนพรอมต์ รันโค้ดที่สร้างใน sandbox ตามที่ระบุไว้ข้างต้น
ดูความล้มเหลว ไม่ใช่เพียงเปอร์เซ็นต์ หากการพลาดส่วนใหญ่มาจากไลบรารีเดียว ให้เพิ่มคำแนะนำในข้อความระบบ หากมาจากโมเดลที่สร้างชื่อฟังก์ชันขึ้นมา ให้ใส่ลายเซ็นที่เกี่ยวข้องในพรอมต์ หากมาจากอินพุตที่ยาว ให้ทดสอบพรอมต์ที่สั้นลงก่อนที่คุณจะโทษโมเดล
ต้นทุนงานเขียนโค้ด
ราคาอยู่ที่ $0.15 ต่อ 1M โทเคนอินพุตและ $0.50 ต่อ 1M โทเคนเอาท์พุต และคำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน สามตัวอย่างพร้อมคณิตศาสตร์:
- การรันการประเมินผล 50 งาน x 3 ตัวอย่าง คือ 150 คำขอ ที่ 400 โทเคนอินพุตและ 600 โทเคนเอาท์พุตต่อคำขอ อินพุตคือ 60,000 โทเคน ($0.009) และเอาท์พุตคือ 90,000 โทเคน ($0.045) รวม: $0.054
- การตรวจสอบไฟล์ ไฟล์ประมาณ 600 บรรทัดมีประมาณ 8,000 โทเคน พร้อมการตรวจสอบ 1,200 โทเคน อินพุตมีค่าใช้จ่าย $0.0012 เอาท์พุตมีค่าใช้จ่าย $0.0006 รวม $0.0018 การตรวจสอบ 500 ครั้งมีค่าใช้จ่าย $0.90
- Agent loop. การแก้ไขที่มีหกขั้นตอนที่ส่ง 18,000 input tokens ทั้งหมดและรับ 1,500 output tokens มีค่าใช้จ่าย $0.0027 บวก $0.00075 ดังนั้น $0.00345
Agent loops ครอบงำเพราะแต่ละรอบส่งการสนทนาที่เติบโตใหม่ ออกแบบ tool output ตามตัวอย่าง และคุณควบคุมค่าใช้จ่าย เติมเงินจำนวนเต็ม $20-$500 พร้อมโบนัส +5% จาก $50, +10% จาก $100 และ +15% จาก $200 จ่ายด้วย USDT บน TRC20 หรือ USDC บน Base เครดิตไม่หมดอายุ ดู pricing บัญชีใหม่ขอเครดิตทดลอง $0.50 ได้คลิกเดียว ใช้รันประเมินได้ไม่กี่ครั้ง คีย์ทดลองอนุญาตคำขอพร้อมกัน 2 คำขอ และ 60 คำขอต่อนาที
เมื่อตัวเลือกอื่นดีกว่า
คุณต้องเป็นจริงใจเกี่ยวกับข้อจำกัดของเอนด์พอยต์ใดเอนด์พอยต์หนึ่ง หากคุณต้องการปลั๊กอิน editor พร้อมการเติมข้อความแบบ inline ตัวแทนเขียนโค้ดที่สร้างโดยผู้ขาย หรือการผสานรวมอย่างใกล้ชิดกับเครื่องมือของคลาวด์หนึ่งๆ ผลิตภัณฑ์ที่สร้างสำหรับจุดประสงค์นั้นอาจเหมาะกับคุณมากกว่า และคุณควรตรวจสอบราคาและเงื่อนไขปัจจุบันของพวกเขา หากโค้ดของคุณไม่เคยทำให้เกิดการปฏิเสธ พฤติกรรมการปฏิเสธของโมเดลนี้ไม่ได้ให้คุณได้เปรียบ และผลการทดสอบของคุณควรตัดสินใจ หากคุณต้องการ embeddings หรืออินพุตภาพ คุณต้องการบริการอื่นสำหรับส่วนเหล่านั้น API นี้เหมาะเมื่อคุณต้องการเอนด์พอยต์มาตรฐานที่เข้ากันได้กับ OpenAI ที่คุณสามารถเรียกจากสคริปต์และเครื่องมือ พร้อมหน้าต่างขนาดใหญ่ การเรียกใช้ฟังก์ชันและราคาต่ำ API docs ระบุชุดพารามิเตอร์เต็มรูปแบบ
คู่มือเพิ่มเติม
ถาม-ตอบ
โมเดลนี้เหมาะกับงาน Python หรือไม่?
ไม่มีโมเดลใดที่ดีที่สุดสำหรับทุกงาน API นี้มีโมเดลแบบเปิดน้ำหนักหนึ่งตัวพร้อมการเรียกใช้ฟังก์ชัน โหมด JSON และหน้าต่างบริบทขนาด 100,000 โทเคน พร้อมฮาร์เนสที่กล่าวถึงด้านบนให้คุณวัดผลเทียบกับชุดทดสอบของคุณเอง
โมเดลสามารถรันโค้ด Python ของฉันได้หรือไม่?
ไม่ได้ด้วยตัวเอง คุณกำหนดเครื่องมือ เช่น run_python แล้วโค้ดของคุณจะรันเครื่องมือนั้นและส่งผลลัพธ์กลับเป็นข้อความเครื่องมือ รันในแซนด์บ็อกซ์
โค้ดเบสขนาดใหญ่เพียงใดจึงจะพอดีกับคำขอหนึ่งครั้ง?
หน้าต่างบริบทมีขนาด 100,000 โทเคนสำหรับพรอมต์รวมกับการสร้างผลลัพธ์ ซึ่งครอบคลุมไฟล์จำนวนมากได้ในครั้งเดียว แต่ไม่ครอบคลุมคลังโค้ดขนาดใหญ่ทั้งหมด
ใช้งานกับแพ็กเกจ Python ของ OpenAI ได้หรือไม่?
ได้ ตั้งค่า base_url เป็น URL ของ API ส่งคีย์ของคุณ และใช้โมเดล ID uncensored
การรันทดสอบหนึ่งครั้งมีค่าใช้จ่ายเท่าใด?
การรัน 150 การเรียกใช้โค้ด ที่ 400 โทเคนสำหรับอินพุตและ 600 โทเคนสำหรับเอาต์พุตต่อการเรียกใช้แต่ละครั้ง มีค่าใช้จ่ายประมาณ $0.054
เพียงกรอกแบบฟอร์มก็ได้รับคีย์ของคุณ
สร้างบัญชี คัดลอกคีย์ และกำหนดค่า base URL นั่นคือการตั้งค่าทั้งหมด
Base URLhttps://api.visionllmapi.com/v1