ಮುಖಪುಟ / ಮಾರ್ಗದರ್ಶಿಗಳು / ಪೈಥಾನ್‌ನಲ್ಲಿ ಉಚಿತ LLM API

ಪೈಥಾನ್‌ನಲ್ಲಿ ಉಚಿತ 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 27BElectronHub, Groq, OVH AI Endpoints262K30 ವಿನಂತಿ/ನಿಮಿಷ
250 ವಿನಂತಿ/ದಿನ
70,000 ಟೋಕನ್/ನಿಮಿಷ
~6M
ಹೌದುಹೌದು
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 ವಿನಂತಿ/ನಿಮಿಷ
50 ವಿನಂತಿ/ದಿನ
50 req/day account-wide (1,000 after a $10 purchase)
ಹೌದುಇಲ್ಲ
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 ಇನ್ನೂ131K30 ವಿನಂತಿ/ನಿಮಿಷ
1,000 ವಿನಂತಿ/ದಿನ
8,000 ಟೋಕನ್/ನಿಮಿಷ
200,000 ಟೋಕನ್/ದಿನ
~6M
ಹೌದುಇಲ್ಲ
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 ಇನ್ನೂ131K30 ವಿನಂತಿ/ನಿಮಿಷ
1,000 ವಿನಂತಿ/ದಿನ
8,000 ಟೋಕನ್/ನಿಮಿಷ
200,000 ಟೋಕನ್/ದಿನ
~6M
ಹೌದುಇಲ್ಲ
GPT-OSS Safeguard 20BGroq131K30 ವಿನಂತಿ/ನಿಮಿಷ
1,000 ವಿನಂತಿ/ದಿನ
8,000 ಟೋಕನ್/ನಿಮಿಷ
200,000 ಟೋಕನ್/ದಿನ
~6M
ಹೌದುಇಲ್ಲ
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 ವಿನಂತಿ/ನಿಮಿಷ
20 ವಿನಂತಿ/ದಿನ
250,000 ಟೋಕನ್/ನಿಮಿಷ
~3M
ಹೌದುಹೌದು
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditಹೌದುಹೌದು
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 ವಿನಂತಿ/ನಿಮಿಷ
5,000 ವಿನಂತಿ/ದಿನ
500,000 ಟೋಕನ್/ದಿನ
500K tokens/day · 5,000 req/day
ಹೌದುಹೌದು
Nemotron 3.5 Lightning 30BRequesty1M200 ವಿನಂತಿ/ದಿನ
200 rpd
ಹೌದುಇಲ್ಲ
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 ವಿನಂತಿ/ನಿಮಿಷ
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.APIConnectionErrorFreeLLMAPI ಚಾಲನೆಯಲ್ಲಿಲ್ಲ, ಅಥವಾ ತಪ್ಪು ಪೋರ್ಟ್ಬ್ರೌಸರ್‌ನಲ್ಲಿ http://localhost:3001 ತೆರೆಯಿರಿ
openai.NotFoundErrorಬೇಸ್ URL ನಲ್ಲಿ /v1 ಇಲ್ಲhttp://localhost:3001/v1 ಬಳಸಿ
openai.RateLimitErrorಸರಣಿಯ ಎಲ್ಲಾ ಕೀಗಳು ತಮ್ಮ ಮಿತಿಯಲ್ಲಿವೆಪ್ರೊವೈಡರ್‌ಗಳನ್ನು ಸೇರಿಸಿ, ಏಕಕಾಲೀನತೆ ಕಡಿಮೆ ಮಾಡಿ, Retry-After ಗಾಗಿ ಕಾಯಿರಿ
openai.BadRequestError ಜೊತೆ auto:nameಪ್ರೊಫೈಲ್ ಹೆಸರು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಪ್ರೊಫೈಲ್ ಹೆಸರು ಪರಿಶೀಲಿಸಿ
ಚಿತ್ರಗಳೊಂದಿಗೆ openai.UnprocessableEntityError (422)ನಿಮ್ಮ ಸರಣಿಯಲ್ಲಿ ದೃಷ್ಟಿ ಮಾಡೆಲ್ ಇಲ್ಲಫಾಲ್‌ಬ್ಯಾಕ್ ಸರಣಿಯಲ್ಲಿ ದೃಷ್ಟಿ ಮಾಡೆಲ್ ಸಕ್ರಿಯಗೊಳಿಸಿ

ಉಚಿತ ಶ್ರೇಣಿಗಳಿಗೆ SLA ಇಲ್ಲ. ಲೇಟೆನ್ಸಿ ದಿನದ ವೇಳೆ ಬದಲಾಗುತ್ತದೆ. ಅತ್ಯಂತ ಪ್ರಬಲ ಮಾಡೆಲ್‌ಗಳು ತಮ್ಮ ದೈನಂದಿನ ಮಿತಿಗಳನ್ನು ಮೊದಲು ತಲುಪುತ್ತವೆ, ಮತ್ತು ಅನೇಕ ಮಿತಿಗಳು UTC ಮಧ್ಯರಾತ್ರಿಗೆ ಮರುಹೊಂದುತ್ತವೆ. ನಿಗದಿತ ಸಮಯದಲ್ಲಿ ಉತ್ತರಿಸಬೇಕಾದ ಸೇವೆಗೆ ಉಚಿತ ಗೇಟ್‌ವೇ ಬಳಸಬೇಡಿ.

ಇವೆಲ್ಲವನ್ನೂ ಒಂದೇ ಕೀ ಮೂಲಕ ಬಳಸಿ. FreeLLMAPI ಒಂದು ಮುಕ್ತ ಮೂಲದ, ಸ್ವಯಂ-ಹೋಸ್ಟ್ ಮಾಡಿದ ರೂಟರ್ ಆಗಿದೆ. ಇದು ಈ ಎಲ್ಲಾ ಉಚಿತ ಶ್ರೇಣಿಗಳನ್ನು ಒಂದೇ OpenAI-ಹೊಂದಾಣಿಕೆಯ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಹಿಂದೆ ಇಡುತ್ತದೆ ಮತ್ತು ಒಂದು ಮಿತಿಗೆ ಒಳಪಟ್ಟಾಗ ಬದಲಾಯಿಸುತ್ತದೆ. ಕ್ಯಾಟಲಾಗ್ ನೋಡಿ ಅಥವಾ ಲೈವ್ ಆಗಿ.

ಪದೇ ಪದೇ ಕೇಳುವ ಪ್ರಶ್ನೆಗಳು

ಪೈಥಾನ್‌ಗಾಗಿ ಉಚಿತ 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 ಬಳಸಿ. ಸಮಾನಾಂತರ ವಿನಂತಿಗಳನ್ನು ಚಿಕ್ಕದಾಗಿ ಇಡಿ, ಏಕೆಂದರೆ ಉಚಿತ ಶ್ರೇಣಿಗಳು ನಿಮಿಷಕ್ಕೆ ವಿನಂತಿಗಳನ್ನು ಮಿತಿಗೊಳಿಸುತ್ತವೆ.

ಸಂಬಂಧಿತ ಮಾರ್ಗದರ್ಶಿಗಳು

ಮೂಲಗಳು

ಎಲ್ಲಾ ಮಾರ್ಗದರ್ಶಿಗಳು · ಎಲ್ಲಾ ಉಚಿತ ಮಾದರಿಗಳನ್ನು ನೋಡಿ