Strona główna / Poradniki / Darmowe API LLM w Pythonie

Darmowe API LLM w Pythonie

Oficjalny pakiet Python openai działa z każdym API zgodnym z OpenAI. Zmieniasz base URL i klucz. Ten poradnik używa FreeLLMAPI, które łączy 45 darmowych poziomów dostawców za jednym kluczem i przechodzi do następnego dostawcy, gdy limit zatrzyma żądanie. Każdy przykład poniżej jest kompletny i działa bez zmian.

Kod, nazwy modeli i etykiety z katalogu na żywo są podane po angielsku.

Konfiguracja

Zainstaluj FreeLLMAPI. Działa w Dockerze. Otwórz panel pod adresem http://localhost:3001, dodaj darmowe klucze od dwóch lub więcej dostawców na stronie Keys i skopiuj ujednolicony klucz. Następnie zainstaluj pakiet Python.

Twój kod Pythona używa tylko ujednoliconego klucza. Klucze dostawców zostają w FreeLLMAPI, zaszyfrowane w jego bazie danych. Jeśli zmienisz lub dodasz klucz dostawcy, nie zmieniasz kodu.

Instalacja

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)

Model auto stosuje łańcuch zapasowy ustawiony w panelu. Możesz też użyć auto:fast, auto:smart lub auto:reliable, profilu, na przykład auto:coding, albo stałego identyfikatora modelu.

Streaming i nagłówki odpowiedzi

Strumieniuj odpowiedź

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()

Każda odpowiedź ma nagłówek X-Routed-Via z dostawcą i modelem, które odpowiedziały. Aby czytać nagłówki przez SDK, użyj with_raw_response i wywołaj parse(), aby dostać zwykły obiekt.

Odczytaj nagłówki routingu

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)

Wywoływanie narzędzi

Wysyłaj tools w stylu OpenAI. Router przekazuje je dostawcom zgodnym z OpenAI i tłumaczy dla Gemini. Odpowiedź wraca w tym samym formacie dla każdego dostawcy.

Jedno wywołanie narzędzia i końcowa odpowiedź

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)

Niektórzy dostawcy zwracają wywołanie narzędzia jako zwykły tekst. FreeLLMAPI zamienia takie odpowiedzi na prawdziwe tool_calls, więc Twój kod czyta jeden format. Zawsze sprawdź msg.tool_calls, zanim odczytasz msg.content, bo model może też odpowiedzieć bez narzędzia.

Użyj modelu z wywoływaniem narzędzi. Te darmowe modele obsługują narzędzia i mają dziś najszybszy zmierzony czas odpowiedzi:

Szybkie darmowe modele z wywoływaniem narzędzi
ModelZa darmo wKontekstDarmowe limity (najlepsza oferta)NarzędziaWizja
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 żądań/min
250 żądań/dzień
70,000 tokenów/min
~6M
TakTak
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 żądań/min
50 żądań/dzień
50 req/day account-wide (1,000 after a $10 purchase)
TakNie
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 więcej131K30 żądań/min
1,000 żądań/dzień
8,000 tokenów/min
200,000 tokenów/dzień
~6M
TakNie
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 więcej131K30 żądań/min
1,000 żądań/dzień
8,000 tokenów/min
200,000 tokenów/dzień
~6M
TakNie
GPT-OSS Safeguard 20BGroq131K30 żądań/min
1,000 żądań/dzień
8,000 tokenów/min
200,000 tokenów/dzień
~6M
TakNie
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 żądań/min
20 żądań/dzień
250,000 tokenów/min
~3M
TakTak
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditTakTak
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 żądań/min
5,000 żądań/dzień
500,000 tokenów/dzień
500K tokens/day · 5,000 req/day
TakTak
Nemotron 3.5 Lightning 30BRequesty1M200 żądań/dzień
200 rpd
TakNie
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 żądań/min
20 żądań/dzień
250,000 tokenów/min
~3M
TakTak

Pokazano 10 z 146 pasujących darmowych modeli. Zobacz wszystkie modele.

Dane na żywo z katalogu FreeLLMAPI (wersja 2026.11.19, sprawdzono 2026-11-19). Darmowe limity często się zmieniają. Katalog jest sprawdzany codziennie.

Partie async w darmowych limitach

AsyncOpenAI wysyła wiele żądań naraz. Darmowe poziomy ograniczają żądania na minutę, więc ogranicz równoległość semaforem. Przykład ponawia też żądanie, gdy każdy dostawca jest na limicie.

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())

Router zwraca 429 tylko wtedy, gdy każdy klucz w łańcuchu jest na limicie. Odpowiedź ma wtedy nagłówek Retry-After. Mała wartość semafora i więcej kluczy dostawców dają najlepsze wyniki przy dużych partiach.

Wybierz ciąg modelu dla każdego zadania

Ciąg modelu mówi routerowi, jak wybrać model. W każdym wywołaniu możesz użyć innego ciągu. Nie musisz zmieniać panelu.

ZadanieCiąg modeluPowód
Odpowiedzi czatu dla użytkownikówautoStosuje łańcuch zapasowy ustawiony w panelu
Klasyfikacja, ekstrakcja, krótkie streszczeniaauto:fastUkłada włączone modele według zmierzonej szybkości
Trudne pytania, przegląd kodu, planowanieauto:smartUkłada włączone modele według inteligencji
Zaplanowane zadania, które muszą się zakończyćauto:reliableUkłada włączone modele według ostatniego wskaźnika sukcesu
Osobny łańcuch dla jednej aplikacjiauto:<profile>Używa nazwanego łańcucha zapasowego
Testy, które muszą być powtarzalneStały identyfikator modeluZa każdym razem ten sam model, ale zatrzymuje się na limicie tego modelu

Aby zobaczyć, które modele Twoje klucze mogą teraz wywołać, zażądaj listy modeli z filtrem. Pełna lista zawiera też modele, dla których nie ma jeszcze klucza.

Wypisz modele, które mogą odpowiedzieć teraz

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"])

Model o statusie exhausted ma klucze, ale wszystkie są teraz na limicie. Status znika, gdy skończą się przerwy. Model o statusie needsKey nie ma włączonego klucza.

Dla rozmowy wyślij nagłówek X-Session-Id w extra_headers. FreeLLMAPI wtedy trzyma tę rozmowę na jednym modelu przez 30 minut. Bez nagłówka używa skrótu pierwszej wiadomości użytkownika jako klucza sesji.

Embeddingi

Osadź tekst

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")

Przełączanie awaryjne embeddingów nigdy nie zmienia modelu. Przełącza się tylko między dostawcami, którzy obsługują tę samą rodzinę, więc Twoje wektory pozostają zgodne. Wartość auto używa domyślnej rodziny, którą ustawiasz w panelu.

Wyślij wiele tekstów w jednej liście input. Jedno żądanie z 32 tekstami zużywa jedno żądanie z darmowego limitu, a nie 32. Trzymaj każdy tekst poniżej maksymalnego wejścia rodziny. Zapisz nazwę rodziny razem z wektorami, abyś później osadzał zapytania tą samą rodziną.

Błędy i poprawki

WyjątekPrzyczynaRozwiązanie
openai.AuthenticationErrorZły ujednolicony kluczSkopiuj klucz ponownie ze strony Keys
openai.APIConnectionErrorFreeLLMAPI nie działa albo zły portOtwórz http://localhost:3001 w przeglądarce
openai.NotFoundErrorBase URL nie zawiera /v1Użyj http://localhost:3001/v1
openai.RateLimitErrorWszystkie klucze w łańcuchu są na limicieDodaj dostawców, zmniejsz równoległość, poczekaj na Retry-After
openai.BadRequestError z auto:nameNazwa profilu nie istniejeSprawdź nazwę profilu w panelu
openai.UnprocessableEntityError (422) z obrazamiŻaden model wizji nie jest w Twoim łańcuchuWłącz model wizji w łańcuchu zapasowym

Darmowe poziomy nie mają SLA. Opóźnienie zmienia się w ciągu dnia. Najmocniejsze modele pierwsze osiągają dzienne limity, a wiele limitów resetuje się o północy UTC. Nie używaj darmowej bramy do usługi, która musi odpowiedzieć w określonym czasie.

Używaj wszystkich tych modeli przez jeden klucz. FreeLLMAPI to router o otwartym kodzie, uruchamiany na własnym serwerze. Łączy wszystkie te darmowe plany za jednym punktem końcowym zgodnym z OpenAI i przełącza się na inny dostawcę, gdy limit zostanie przekroczony. Przeglądaj katalog lub uruchom.

Najczęstsze pytania

Czy istnieje darmowe API LLM dla Pythona?

Tak. Wielu dostawców ma darmowe poziomy, które działają z pakietem Python openai. FreeLLMAPI łączy je za jednym base URL i jednym kluczem, z przełączaniem awaryjnym między dostawcami.

Jak użyć biblioteki openai w Pythonie z innym base URL?

Przekaż base_url do OpenAI() albo AsyncOpenAI(), na przykład base_url="http://localhost:3001/v1". Klucz bramy przekaż jako api_key.

Jak obsługiwać błędy limitu szybkości w Pythonie?

Ustaw max_retries w kliencie. Złap openai.RateLimitError, odczytaj nagłówek Retry-After i poczekaj. Ogranicz równoległość semaforem asyncio.

Czy streaming działa z darmowymi API LLM w Pythonie?

Tak. Przekaż stream=True i czytaj chunk.choices[0].delta.content. FreeLLMAPI strumieniuje w formacie OpenAI dla każdego dostawcy.

Czy mogę użyć async w Pythonie z darmowym API LLM?

Tak. Użyj AsyncOpenAI z tym samym base_url i kluczem. Trzymaj liczbę równoległych żądań małą, bo darmowe poziomy ograniczają żądania na minutę.

Powiązane poradniki

Źródła

Wszystkie poradniki · Przeglądaj wszystkie darmowe modele