ಪೈಥಾನ್ನಲ್ಲಿ ಉಚಿತ LLM API
ಅಧಿಕೃತ openai ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಯಾವುದೇ OpenAI-ಹೊಂದಾಣಿಕೆಯ API ಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ನೀವು ಬೇಸ್ URL ಮತ್ತು ಕೀಯನ್ನು ಬದಲಿಸುತ್ತೀರಿ. ಈ ಮಾರ್ಗದರ್ಶಿ FreeLLMAPI ಬಳಸುತ್ತದೆ. ಇದು ಒಂದು ಕೀ ಹಿಂದೆ 45 ಉಚಿತ ಪ್ರೊವೈಡರ್ ಶ್ರೇಣಿಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ಮಿತಿ ವಿನಂತಿಯನ್ನು ನಿಲ್ಲಿಸಿದಾಗ ಮುಂದಿನ ಪ್ರೊವೈಡರ್ಗೆ ಹೋಗುತ್ತದೆ. ಕೆಳಗಿನ ಪ್ರತಿ ಉದಾಹರಣೆ ಸಂಪೂರ್ಣವಾಗಿದ್ದು ಹಾಗೆಯೇ ಚಲಿಸುತ್ತದೆ.
ಕೋಡ್, ಮಾದರಿ ಹೆಸರುಗಳು ಮತ್ತು ನೇರ ಕ್ಯಾಟಲಾಗ್ ಲೇಬಲ್ಗಳನ್ನು ಇಂಗ್ಲಿಷ್ನಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ.
ಸೆಟಪ್
FreeLLMAPI ಸ್ಥಾಪಿಸಿ. ಇದು Docker ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ. http://localhost:3001 ನಲ್ಲಿ ಡ್ಯಾಶ್ಬೋರ್ಡ್ ತೆರೆಯಿರಿ, Keys ಪುಟದಲ್ಲಿ ಎರಡು ಅಥವಾ ಹೆಚ್ಚು ಪ್ರೊವೈಡರ್ಗಳಿಂದ ಉಚಿತ ಕೀಗಳನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಏಕೀಕೃತ ಕೀಯನ್ನು ನಕಲಿಸಿ. ನಂತರ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಸ್ಥಾಪಿಸಿ.
ನಿಮ್ಮ ಪೈಥಾನ್ ಕೋಡ್ ಏಕೀಕೃತ ಕೀ ಮಾತ್ರ ಬಳಸುತ್ತದೆ. ಪ್ರೊವೈಡರ್ ಕೀಗಳು FreeLLMAPI ನಲ್ಲಿ ಉಳಿಯುತ್ತವೆ, ಅದರ ಡೇಟಾಬೇಸ್ನಲ್ಲಿ ಎನ್ಕ್ರಿಪ್ಟ್ ಆಗಿ. ನೀವು ಪ್ರೊವೈಡರ್ ಕೀಯನ್ನು ಬದಲಿಸಿದರೆ ಅಥವಾ ಸೇರಿಸಿದರೆ, ನಿಮ್ಮ ಕೋಡ್ ಬದಲಾಗುವುದಿಲ್ಲ.
ಸ್ಥಾಪಿಸಿ
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai
export FREELLMAPI_API_KEY=<unified-key>client.py
import os
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=3, # the SDK retries 429, 408, 409 and 5xx errors
timeout=60,
)
resp = client.chat.completions.create(
model="auto",
messages=[{"role": "user", "content": "Name three uses of Python in one line."}],
)
print(resp.choices[0].message.content)ಮಾಡೆಲ್ auto ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿರುವ ನಿಮ್ಮ ಫಾಲ್ಬ್ಯಾಕ್ ಸರಣಿಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ. ನೀವು auto:fast, auto:smart ಅಥವಾ auto:reliable, auto:coding ನಂತಹ ಪ್ರೊಫೈಲ್, ಅಥವಾ ನಿಗದಿತ ಮಾಡೆಲ್ ID ಅನ್ನೂ ಬಳಸಬಹುದು.
ಸ್ಟ್ರೀಮಿಂಗ್ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಹೆಡರ್ಗಳು
ಉತ್ತರವನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡಿ
from client import client
stream = client.chat.completions.create(
model="auto:fast",
messages=[{"role": "user", "content": "Write a haiku about Python."}],
stream=True,
)
for chunk in stream:
if chunk.choices:
print(chunk.choices[0].delta.content or "", end="", flush=True)
print()ಪ್ರತಿ ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ ಉತ್ತರಿಸಿದ ಪ್ರೊವೈಡರ್ ಮತ್ತು ಮಾಡೆಲ್ ಇರುವ X-Routed-Via ಹೆಡರ್ ಇರುತ್ತದೆ. SDK ಮೂಲಕ ಹೆಡರ್ಗಳನ್ನು ಓದಲು, with_raw_response ಬಳಸಿ ಮತ್ತು ಸಾಮಾನ್ಯ ಆಬ್ಜೆಕ್ಟ್ ಪಡೆಯಲು parse() ಕರೆ ಮಾಡಿ.
ರೂಟಿಂಗ್ ಹೆಡರ್ಗಳನ್ನು ಓದಿ
from client import client
raw = client.chat.completions.with_raw_response.create(
model="auto",
messages=[{"role": "user", "content": "hi"}],
)
print("Served by:", raw.headers.get("x-routed-via"))
print("Failed attempts:", raw.headers.get("x-fallback-attempts", "0"))
print(raw.parse().choices[0].message.content)ಟೂಲ್ ಕರೆ
OpenAI ಶೈಲಿಯ tools ಕಳುಹಿಸಿ. ರೂಟರ್ ಅವುಗಳನ್ನು OpenAI-ಹೊಂದಾಣಿಕೆಯ ಪ್ರೊವೈಡರ್ಗಳಿಗೆ ರವಾನಿಸುತ್ತದೆ ಮತ್ತು Gemini ಗಾಗಿ ಅನುವಾದಿಸುತ್ತದೆ. ಉತ್ತರ ಪ್ರತಿ ಪ್ರೊವೈಡರ್ಗೆ ಒಂದೇ ಸ್ವರೂಪದಲ್ಲಿ ಬರುತ್ತದೆ.
ಒಂದು ಟೂಲ್ ಕರೆ ಮತ್ತು ಅಂತಿಮ ಉತ್ತರ
import json
from client import client
tools = [{
"type": "function",
"function": {
"name": "get_exchange_rate",
"description": "Get the exchange rate between two currencies.",
"parameters": {
"type": "object",
"properties": {
"base": {"type": "string"},
"quote": {"type": "string"},
},
"required": ["base", "quote"],
},
},
}]
messages = [{"role": "user", "content": "How many euros is 250 US dollars?"}]
first = client.chat.completions.create(model="auto", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"base": args["base"], "quote": args["quote"], "rate": 0.92} # your real lookup
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
final = client.chat.completions.create(model="auto", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)ಕೆಲವು ಪ್ರೊವೈಡರ್ಗಳು ಟೂಲ್ ಕರೆಯನ್ನು ಸರಳ ಪಠ್ಯವಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತವೆ. FreeLLMAPI ಈ ಉತ್ತರಗಳನ್ನು ನಿಜವಾದ tool_calls ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ ಒಂದೇ ಸ್ವರೂಪವನ್ನು ಓದುತ್ತದೆ. ಯಾವಾಗಲೂ msg.tool_calls ಪರಿಶೀಲಿಸಿ, msg.content ಓದುವ ಮೊದಲು, ಏಕೆಂದರೆ ಮಾಡೆಲ್ ಟೂಲ್ ಇಲ್ಲದೆಯೂ ಉತ್ತರಿಸಬಹುದು.
ಟೂಲ್ ಕರೆ ಇರುವ ಮಾಡೆಲ್ ಬಳಸಿ. ಈ ಉಚಿತ ಮಾಡೆಲ್ಗಳು ಟೂಲ್ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ ಮತ್ತು ಇಂದು ಅಳೆಯಲಾದ ಅತ್ಯಂತ ವೇಗದ ವೇಗವನ್ನು ಹೊಂದಿವೆ:
| ಮಾದರಿ | ಉಚಿತ | ಸಂದರ್ಭ | ಉಚಿತ ಮಿತಿಗಳು (ಅತ್ಯುತ್ತಮ ಕೊಡುಗೆ) | ಉಪಕರಣಗಳು | ದೃಷ್ಟಿ |
|---|---|---|---|---|---|
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 ವಿನಂತಿ/ನಿಮಿಷ 250 ವಿನಂತಿ/ದಿನ 70,000 ಟೋಕನ್/ನಿಮಿಷ ~6M | ಹೌದು | ಹೌದು |
| Nemotron 3.5 Lightning | ElectronHub, Kilo Gateway, OpenRouter | 1M | 20 ವಿನಂತಿ/ನಿಮಿಷ 50 ವಿನಂತಿ/ದಿನ 50 req/day account-wide (1,000 after a $10 purchase) | ಹೌದು | ಇಲ್ಲ |
| GPT-OSS 120B | Cloudflare Workers AI, ElectronHub, Groq +1 ಇನ್ನೂ | 131K | 30 ವಿನಂತಿ/ನಿಮಿಷ 1,000 ವಿನಂತಿ/ದಿನ 8,000 ಟೋಕನ್/ನಿಮಿಷ 200,000 ಟೋಕನ್/ದಿನ ~6M | ಹೌದು | ಇಲ್ಲ |
| GPT-OSS 20B | Cloudflare Workers AI, Groq, NVIDIA NIM +1 ಇನ್ನೂ | 131K | 30 ವಿನಂತಿ/ನಿಮಿಷ 1,000 ವಿನಂತಿ/ದಿನ 8,000 ಟೋಕನ್/ನಿಮಿಷ 200,000 ಟೋಕನ್/ದಿನ ~6M | ಹೌದು | ಇಲ್ಲ |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 ವಿನಂತಿ/ನಿಮಿಷ 1,000 ವಿನಂತಿ/ದಿನ 8,000 ಟೋಕನ್/ನಿಮಿಷ 200,000 ಟೋಕನ್/ದಿನ ~6M | ಹೌದು | ಇಲ್ಲ |
| Gemini 3.5 Flash Lite | ElectronHub, Google AI Studio | 1M | 15 ವಿನಂತಿ/ನಿಮಿಷ 20 ವಿನಂತಿ/ದಿನ 250,000 ಟೋಕನ್/ನಿಮಿಷ ~3M | ಹೌದು | ಹೌದು |
| Step 3.7 Flash | ElectronHub | 256K | $0.25/week shared recurring credit | ಹೌದು | ಹೌದು |
| Gemini 3.1 Flash-Lite | DreamPrompting, Google AI Studio | 1M | 100 ವಿನಂತಿ/ನಿಮಿಷ 5,000 ವಿನಂತಿ/ದಿನ 500,000 ಟೋಕನ್/ದಿನ 500K tokens/day · 5,000 req/day | ಹೌದು | ಹೌದು |
| Nemotron 3.5 Lightning 30B | Requesty | 1M | 200 ವಿನಂತಿ/ದಿನ 200 rpd | ಹೌದು | ಇಲ್ಲ |
| Gemini 2.5 Flash-Lite | ElectronHub, Google AI Studio | 1M | 15 ವಿನಂತಿ/ನಿಮಿಷ 20 ವಿನಂತಿ/ದಿನ 250,000 ಟೋಕನ್/ನಿಮಿಷ ~3M | ಹೌದು | ಹೌದು |
ಹೊಂದಾಣಿಕೆಯಾಗುವ 146 ಉಚಿತ ಮಾದರಿಗಳಲ್ಲಿ 10 ಅನ್ನು ತೋರಿಸಲಾಗುತ್ತಿದೆ. ಎಲ್ಲಾ ಮಾದರಿಗಳನ್ನು ನೋಡಿ.
FreeLLMAPI ಕ್ಯಾಟಲಾಗ್ನಿಂದ ನೇರ ಡೇಟಾ (ಆವೃತ್ತಿ 2026.11.19, 2026-11-19 ರಂದು ಪರಿಶೀಲಿಸಲಾಗಿದೆ). ಉಚಿತ ಮಿತಿಗಳು ಆಗಾಗ್ಗೆ ಬದಲಾಗುತ್ತವೆ. ಕ್ಯಾಟಲಾಗ್ ಪ್ರತಿದಿನ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ.
ಉಚಿತ ಮಿತಿಗಳೊಳಗೆ ಅಸಿಂಕ್ ಬ್ಯಾಚ್ಗಳು
AsyncOpenAI ಅನೇಕ ವಿನಂತಿಗಳನ್ನು ಒಂದೇ ಸಮಯದಲ್ಲಿ ಕಳುಹಿಸುತ್ತದೆ. ಉಚಿತ ಶ್ರೇಣಿಗಳು ನಿಮಿಷಕ್ಕೆ ವಿನಂತಿಗಳನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ semaphore ಜೊತೆ ಏಕಕಾಲೀನತೆಯನ್ನು ಮಿತಿಗೊಳಿಸಿ. ಈ ಉದಾಹರಣೆ ಪ್ರತಿ ಪ್ರೊವೈಡರ್ ಮಿತಿಯಲ್ಲಿದ್ದಾಗಲೂ ಮರುಪ್ರಯತ್ನಿಸುತ್ತದೆ.
batch.py
import asyncio
import os
import openai
from openai import AsyncOpenAI
client = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
)
limit = asyncio.Semaphore(4) # at most 4 requests at a time
async def summarize(text: str) -> str:
async with limit:
for attempt in range(5):
try:
resp = await client.chat.completions.create(
model="auto:fast",
messages=[
{"role": "system", "content": "Summarize in one sentence."},
{"role": "user", "content": text},
],
)
return resp.choices[0].message.content
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
await asyncio.sleep(min(wait, 60))
return "ERROR: rate limited"
async def main():
docs = [f"Document {i}: Python is a programming language." for i in range(20)]
results = await asyncio.gather(*(summarize(d) for d in docs))
for r in results:
print(r)
await client.close()
asyncio.run(main())ರೂಟರ್ ಸರಣಿಯ ಪ್ರತಿ ಕೀ ಮಿತಿಯಲ್ಲಿದ್ದಾಗ ಮಾತ್ರ 429 ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಆಗ ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ Retry-After ಹೆಡರ್ ಇರುತ್ತದೆ. ಚಿಕ್ಕ semaphore ಮೌಲ್ಯ ಮತ್ತು ಹೆಚ್ಚು ಪ್ರೊವೈಡರ್ ಕೀಗಳು ದೊಡ್ಡ ಬ್ಯಾಚ್ಗಳಿಗೆ ಉತ್ತಮ ಫಲಿತಾಂಶ ನೀಡುತ್ತವೆ.
ಪ್ರತಿ ಕೆಲಸಕ್ಕೆ ಮಾಡೆಲ್ ಸ್ಟ್ರಿಂಗ್ ಆರಿಸಿ
ಮಾಡೆಲ್ ಸ್ಟ್ರಿಂಗ್ ರೂಟರ್ಗೆ ಮಾಡೆಲ್ ಅನ್ನು ಹೇಗೆ ಆರಿಸಬೇಕು ಎಂದು ಹೇಳುತ್ತದೆ. ಪ್ರತಿ ಕರೆಯಲ್ಲೂ ವಿಭಿನ್ನ ಸ್ಟ್ರಿಂಗ್ ಬಳಸಬಹುದು. ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಬದಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
| ಕೆಲಸ | ಮಾಡೆಲ್ ಸ್ಟ್ರಿಂಗ್ | ಕಾರಣ |
|---|---|---|
| ಬಳಕೆದಾರರಿಗೆ ಚಾಟ್ ಉತ್ತರಗಳು | auto | ನೀವು ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿ ಹೊಂದಿಸಿದ ಫಾಲ್ಬ್ಯಾಕ್ ಸರಣಿಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ |
| ವರ್ಗೀಕರಣ, ಹೊರತೆಗೆಯುವಿಕೆ, ಚಿಕ್ಕ ಸಾರಾಂಶಗಳು | auto:fast | ಸಕ್ರಿಯ ಮಾಡೆಲ್ಗಳನ್ನು ಅಳೆಯಲಾದ ವೇಗದ ಪ್ರಕಾರ ಶ್ರೇಣೀಕರಿಸುತ್ತದೆ |
| ಕಠಿಣ ಪ್ರಶ್ನೆಗಳು, ಕೋಡ್ ವಿಮರ್ಶೆ, ಯೋಜನೆ | auto:smart | ಸಕ್ರಿಯ ಮಾಡೆಲ್ಗಳನ್ನು ಬುದ್ಧಿಮತ್ತೆಯ ಪ್ರಕಾರ ಶ್ರೇಣೀಕರಿಸುತ್ತದೆ |
| ಮುಗಿಯಬೇಕಾದ ನಿಗದಿತ ಕೆಲಸಗಳು | auto:reliable | ಸಕ್ರಿಯ ಮಾಡೆಲ್ಗಳನ್ನು ಇತ್ತೀಚಿನ ಯಶಸ್ಸಿನ ದರದ ಪ್ರಕಾರ ಶ್ರೇಣೀಕರಿಸುತ್ತದೆ |
| ಒಂದು ಆ್ಯಪ್ಗಾಗಿ ಪ್ರತ್ಯೇಕ ಸರಣಿ | auto:<profile> | ಹೆಸರಿಸಲಾದ ಫಾಲ್ಬ್ಯಾಕ್ ಸರಣಿಯನ್ನು ಬಳಸುತ್ತದೆ |
| ಪುನರಾವರ್ತಿಸಬಹುದಾದ ಪರೀಕ್ಷೆಗಳು | ನಿಗದಿತ ಮಾಡೆಲ್ ID | ಪ್ರತಿ ಬಾರಿ ಅದೇ ಮಾಡೆಲ್, ಆದರೆ ಆ ಮಾಡೆಲ್ನ ಮಿತಿ ತಲುಪಿದಾಗ ನಿಲ್ಲುತ್ತದೆ |
ನಿಮ್ಮ ಕೀಗಳು ಈಗ ಯಾವ ಮಾಡೆಲ್ಗಳನ್ನು ಕರೆ ಮಾಡಬಹುದು ಎಂದು ನೋಡಲು, ಫಿಲ್ಟರ್ನೊಂದಿಗೆ ಮಾಡೆಲ್ ಪಟ್ಟಿಯನ್ನು ವಿನಂತಿಸಿ. ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯಲ್ಲಿ ಇನ್ನೂ ಕೀ ಇಲ್ಲದ ಮಾಡೆಲ್ಗಳೂ ಇರುತ್ತವೆ.
ಈಗ ಉತ್ತರಿಸಬಹುದಾದ ಮಾಡೆಲ್ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ
import os
import httpx
r = httpx.get(
"http://localhost:3001/v1/models",
params={"execution_status": "ready"},
headers={"Authorization": f"Bearer {os.environ['FREELLMAPI_API_KEY']}"},
timeout=30,
)
r.raise_for_status()
for m in r.json()["data"]:
print(m["id"])exhausted ಸ್ಥಿತಿಯ ಮಾಡೆಲ್ಗೆ ಕೀಗಳಿವೆ, ಆದರೆ ಎಲ್ಲವೂ ಈಗ ಮಿತಿಯಲ್ಲಿವೆ. ಕೂಲ್ಡೌನ್ಗಳು ಮುಗಿದಾಗ ಸ್ಥಿತಿ ತೆರವಾಗುತ್ತದೆ. needsKey ಸ್ಥಿತಿಯ ಮಾಡೆಲ್ಗೆ ಸಕ್ರಿಯ ಕೀ ಇಲ್ಲ.
ಸಂಭಾಷಣೆಗೆ, X-Session-Id ಹೆಡರ್ ಅನ್ನು extra_headers ಜೊತೆ ಕಳುಹಿಸಿ. ಆಗ FreeLLMAPI ಆ ಸಂಭಾಷಣೆಯನ್ನು 30 ನಿಮಿಷಗಳ ಕಾಲ ಒಂದೇ ಮಾಡೆಲ್ನಲ್ಲಿ ಇಡುತ್ತದೆ. ಹೆಡರ್ ಇಲ್ಲದಿದ್ದರೆ, ಮೊದಲ ಬಳಕೆದಾರ ಸಂದೇಶದ ಹ್ಯಾಶ್ ಅನ್ನು ಸೆಷನ್ ಕೀಯಾಗಿ ಬಳಸುತ್ತದೆ.
ಎಂಬೆಡಿಂಗ್ಸ್
ಪಠ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡಿ
from client import client
resp = client.embeddings.create(
model="bge-m3", # one embedding family
input=["Python is a programming language.", "A snake is a reptile."],
)
print(len(resp.data), "vectors of", len(resp.data[0].embedding), "dimensions")ಎಂಬೆಡಿಂಗ್ ಫೇಲ್ಓವರ್ ಎಂದಿಗೂ ಮಾಡೆಲ್ ಅನ್ನು ಬದಲಿಸುವುದಿಲ್ಲ. ಅದು ಒಂದೇ ಕುಟುಂಬವನ್ನು ನೀಡುವ ಪ್ರೊವೈಡರ್ಗಳ ನಡುವೆ ಮಾತ್ರ ಚಲಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ವೆಕ್ಟರ್ಗಳು ಹೊಂದಾಣಿಕೆಯಾಗಿ ಉಳಿಯುತ್ತವೆ. auto ಮೌಲ್ಯವು ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿ ನೀವು ಹೊಂದಿಸಿದ ಡೀಫಾಲ್ಟ್ ಕುಟುಂಬವನ್ನು ಬಳಸುತ್ತದೆ.
ಒಂದೇ input ಪಟ್ಟಿಯಲ್ಲಿ ಅನೇಕ ಪಠ್ಯಗಳನ್ನು ಕಳುಹಿಸಿ. 32 ಪಠ್ಯಗಳ ಒಂದು ವಿನಂತಿ ಉಚಿತ ಮಿತಿಯಿಂದ ಒಂದು ವಿನಂತಿಯನ್ನು ಬಳಸುತ್ತದೆ, 32 ಅಲ್ಲ. ಪ್ರತಿ ಪಠ್ಯವನ್ನು ಕುಟುಂಬದ ಗರಿಷ್ಠ ಇನ್ಪುಟ್ಗಿಂತ ಕೆಳಗೆ ಇರಿಸಿ. ಕುಟುಂಬದ ಹೆಸರನ್ನು ನಿಮ್ಮ ವೆಕ್ಟರ್ಗಳೊಂದಿಗೆ ಸಂಗ್ರಹಿಸಿ, ಇದರಿಂದ ನಂತರ ಪ್ರಶ್ನೆಗಳನ್ನು ಅದೇ ಕುಟುಂಬದೊಂದಿಗೆ ಎಂಬೆಡ್ ಮಾಡಬಹುದು.
ದೋಷಗಳು ಮತ್ತು ಪರಿಹಾರಗಳು
| ಅಪವಾದ | ಕಾರಣ | ಪರಿಹಾರ |
|---|---|---|
openai.AuthenticationError | ತಪ್ಪು ಏಕೀಕೃತ ಕೀ | Keys ಪುಟದಿಂದ ಕೀಯನ್ನು ಮತ್ತೆ ನಕಲಿಸಿ |
openai.APIConnectionError | FreeLLMAPI ಚಾಲನೆಯಲ್ಲಿಲ್ಲ, ಅಥವಾ ತಪ್ಪು ಪೋರ್ಟ್ | ಬ್ರೌಸರ್ನಲ್ಲಿ http://localhost:3001 ತೆರೆಯಿರಿ |
openai.NotFoundError | ಬೇಸ್ URL ನಲ್ಲಿ /v1 ಇಲ್ಲ | http://localhost:3001/v1 ಬಳಸಿ |
openai.RateLimitError | ಸರಣಿಯ ಎಲ್ಲಾ ಕೀಗಳು ತಮ್ಮ ಮಿತಿಯಲ್ಲಿವೆ | ಪ್ರೊವೈಡರ್ಗಳನ್ನು ಸೇರಿಸಿ, ಏಕಕಾಲೀನತೆ ಕಡಿಮೆ ಮಾಡಿ, Retry-After ಗಾಗಿ ಕಾಯಿರಿ |
openai.BadRequestError ಜೊತೆ auto:name | ಪ್ರೊಫೈಲ್ ಹೆಸರು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ | ಡ್ಯಾಶ್ಬೋರ್ಡ್ನಲ್ಲಿ ಪ್ರೊಫೈಲ್ ಹೆಸರು ಪರಿಶೀಲಿಸಿ |
ಚಿತ್ರಗಳೊಂದಿಗೆ openai.UnprocessableEntityError (422) | ನಿಮ್ಮ ಸರಣಿಯಲ್ಲಿ ದೃಷ್ಟಿ ಮಾಡೆಲ್ ಇಲ್ಲ | ಫಾಲ್ಬ್ಯಾಕ್ ಸರಣಿಯಲ್ಲಿ ದೃಷ್ಟಿ ಮಾಡೆಲ್ ಸಕ್ರಿಯಗೊಳಿಸಿ |
ಉಚಿತ ಶ್ರೇಣಿಗಳಿಗೆ SLA ಇಲ್ಲ. ಲೇಟೆನ್ಸಿ ದಿನದ ವೇಳೆ ಬದಲಾಗುತ್ತದೆ. ಅತ್ಯಂತ ಪ್ರಬಲ ಮಾಡೆಲ್ಗಳು ತಮ್ಮ ದೈನಂದಿನ ಮಿತಿಗಳನ್ನು ಮೊದಲು ತಲುಪುತ್ತವೆ, ಮತ್ತು ಅನೇಕ ಮಿತಿಗಳು UTC ಮಧ್ಯರಾತ್ರಿಗೆ ಮರುಹೊಂದುತ್ತವೆ. ನಿಗದಿತ ಸಮಯದಲ್ಲಿ ಉತ್ತರಿಸಬೇಕಾದ ಸೇವೆಗೆ ಉಚಿತ ಗೇಟ್ವೇ ಬಳಸಬೇಡಿ.
ಪದೇ ಪದೇ ಕೇಳುವ ಪ್ರಶ್ನೆಗಳು
ಪೈಥಾನ್ಗಾಗಿ ಉಚಿತ LLM API ಇದೆಯೇ?
ಹೌದು. ಅನೇಕ ಪ್ರೊವೈಡರ್ಗಳು openai ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಉಚಿತ ಶ್ರೇಣಿಗಳನ್ನು ಹೊಂದಿವೆ. FreeLLMAPI ಅವುಗಳನ್ನು ಒಂದೇ ಬೇಸ್ URL ಮತ್ತು ಒಂದೇ ಕೀ ಹಿಂದೆ ಸೇರಿಸುತ್ತದೆ, ಪ್ರೊವೈಡರ್ಗಳ ನಡುವೆ ಫೇಲ್ಓವರ್ ಜೊತೆ.
ಬೇರೆ ಬೇಸ್ URL ಜೊತೆ openai ಪೈಥಾನ್ ಲೈಬ್ರರಿಯನ್ನು ಹೇಗೆ ಬಳಸುವುದು?
OpenAI() ಅಥವಾ AsyncOpenAI() ಗೆ base_url ಕಳುಹಿಸಿ, ಉದಾಹರಣೆಗೆ base_url="http://localhost:3001/v1". ನಿಮ್ಮ ಗೇಟ್ವೇ ಕೀಯನ್ನು api_key ಆಗಿ ಕಳುಹಿಸಿ.
ಪೈಥಾನ್ನಲ್ಲಿ ರೇಟ್ ಮಿತಿ ದೋಷಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು?
ಕ್ಲೈಂಟ್ನಲ್ಲಿ max_retries ಹೊಂದಿಸಿ. openai.RateLimitError ಅನ್ನು ಹಿಡಿಯಿರಿ, Retry-After ಹೆಡರ್ ಓದಿ ಕಾಯಿರಿ. asyncio semaphore ಜೊತೆ ಏಕಕಾಲೀನತೆಯನ್ನು ಮಿತಿಗೊಳಿಸಿ.
ಪೈಥಾನ್ನಲ್ಲಿ ಉಚಿತ LLM API ಗಳೊಂದಿಗೆ ಸ್ಟ್ರೀಮಿಂಗ್ ಕೆಲಸ ಮಾಡುತ್ತದೆಯೇ?
ಹೌದು. stream=True ಕಳುಹಿಸಿ ಮತ್ತು chunk.choices[0].delta.content ಓದಿ. FreeLLMAPI ಪ್ರತಿ ಪ್ರೊವೈಡರ್ಗೆ OpenAI ಸ್ವರೂಪದಲ್ಲಿ ಸ್ಟ್ರೀಮ್ ಮಾಡುತ್ತದೆ.
ಉಚಿತ LLM API ಜೊತೆ ಪೈಥಾನ್ ಅಸಿಂಕ್ ಬಳಸಬಹುದೇ?
ಹೌದು. ಅದೇ base_url ಮತ್ತು ಕೀ ಜೊತೆ AsyncOpenAI ಬಳಸಿ. ಸಮಾನಾಂತರ ವಿನಂತಿಗಳನ್ನು ಚಿಕ್ಕದಾಗಿ ಇಡಿ, ಏಕೆಂದರೆ ಉಚಿತ ಶ್ರೇಣಿಗಳು ನಿಮಿಷಕ್ಕೆ ವಿನಂತಿಗಳನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತವೆ.
ಸಂಬಂಧಿತ ಮಾರ್ಗದರ್ಶಿಗಳು
- ಉಚಿತ OpenAI-ಹೊಂದಾಣಿಕೆಯ API Base URL ಗಳು
- LangChain ಗಾಗಿ ಉಚಿತ LLM API
- ಏಜೆಂಟ್ಗಳಿಗಾಗಿ ಉಚಿತ LLM API
- ಫಂಕ್ಷನ್ ಕರೆಯೊಂದಿಗೆ ಉಚಿತ LLM API
- ಉಚಿತ LLM API ಮಿತಿಗಳು
ಮೂಲಗಳು
- OpenAI Python SDK README (async, retries, raw responses, errors) (20 November 2026 ರಂದು ಪರಿಶೀಲಿಸಲಾಗಿದೆ)
- FreeLLMAPI docs: REST API (chat, streaming, tool calling, embeddings, headers) (20 November 2026 ರಂದು ಪರಿಶೀಲಿಸಲಾಗಿದೆ)
- FreeLLMAPI docs: degraded mode and failover (20 November 2026 ರಂದು ಪರಿಶೀಲಿಸಲಾಗಿದೆ)