Gratis LLM's voor Python: Lokale modellen vs. een gehost API

Twee manieren om een gratis LLM in een Python-script te krijgen

Wanneer mensen zoeken naar gratis llms voor python, bedoelen ze meestal een van twee dingen. De eerste is een open-weight model dat je downloadt en zelf draait, met bijvoorbeeld Ollama, llama.cpp of de Hugging Face transformers-bibliotheek. De tweede is een gehost endpoint dat zo weinig kost, of genoeg gratis proeftegoed heeft, dat het gratis aanvoelt voor een prototype. Beide zijn legitiem en passen bij verschillende taken.

Lokaal draaien betekent geen per-token-rekening en geen data die je machine verlaat. Het betekent ook dat je genoeg RAM of GPU-geheugen nodig hebt voor het gekozen model, je wacht op downloads en kleinere modellen die op een laptop passen, presteren slechter dan grote modellen. Een gehoste API neemt de hardwarevraag weg, maar je betaalt per token zodra het gratis proeftegoed op is. Deze pagina behandelt beide eerlijk en toont daarna de Python-code voor de gehoste optie op deze site, die OpenAI-compatible is en werkt met het standaard openai-pakket.

Lokale modellen en gehoste API naast elkaar

Vraag	Draai het zelf	Gehoste prepaid API
Kosten per token	Geen, maar je betaalt voor hardware en stroom	$0,15 per 1M input, $0,50 per 1M output
Insteltijd	Runtime installeren, gewichten downloaden, instellingen afstellen	Eén pakket installeren, sleutel plakken
Contextlengte	Beperkt door je geheugen	100.000 tokens, prompt plus voltooiing
Gelijktijdige verzoeken	Wat je machine aankan	8 gelijktijdige verzoeken op een volledige key, 2 op een trial key
Weigeringen	Hangt af van de gekozen weights	Afgestemd op antwoorden zonder inhoudsrefusies voor wettelijk volwassen gebruik
Offline gebruik	Ja	Nee

Als je een krachtige GPU hebt en je werk privé of offline is, is lokaal een prima antwoord en kun je hier stoppen met lezen. Als je een groter model wilt zonder de machine te bezitten, of als je wilt dat je script zich hetzelfde gedraagt op een laptop, een server en een CI-runner, is de gehoste route eenvoudiger. Veel projecten gebruiken beide: een klein lokaal model tijdens de ontwikkeling, het gehoste model in productie, geschakeld door één base URL te wijzigen.

Stel de gehoste endpoint in binnen vijf minuten

Je hebt eerst een sleutel nodig. Meld je aan met Google of met een e-mailadres en wachtwoord, en claim dan de $0,50 proefversie-credit met één klik op de API-sleutelpagina. De proefversie is 7 dagen geldig, één per persoon en vereist geen betaling. Installeer vervolgens de SDK en houd de sleutel buiten je broncode.

Copypip install openai
export NOTRACK_API_KEY="sk-your-key-here"

De client vereist twee wijzigingen ten opzichte van een standaard OpenAI-setup: de base URL en de sleutel. De model ID is uncensored en er wordt slechts één model aangeboden.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.nsfwvideogenerator.cc/v1",
    api_key=os.environ["NOTRACK_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise writing assistant."},
        {"role": "user", "content": "Give me three title ideas for a noir short story."},
    ],
    temperature=0.8,
)

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

Authenticatie is een standaard Authorization: Bearer-header, die de SDK voor je toevoegt. Er zijn twee methoden: POST /v1/chat/completions en GET /v1/models. Je kunt de verbinding bevestigen met client.models.list(), wat de beschikbare model ID teruggeeft. De volledige parameterlijst staat op de docs-pagina.

Streaming-antwoorden

Voor alles wat een persoon bekijkt, stream je. Stel stream=True in en doorloop de chunks naarmate server-sent events binnenkomen. Gebruik wordt aan het einde van de stream gerapporteerd, zodat je tokenaantallen nog steeds kunt loggen.

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem about rain on a tin roof."}],
    stream=True,
)

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

Eén detail kan voor verrassingen zorgen: een gestreamd verzoek houdt zijn concurrency-slot vast totdat de stream klaar is. Met een proefsleutel met 2 slots, betekenen twee open streams dat een derde aanroep een 429 retourneert met de code concurrency. Gebruik of sluit de stream altijd.

Tool calling en JSON-modus

De endpoint ondersteunt tools, tool_choice, gestreamde tool_calls en resultaten die terugkomen als role: "tool". Hier is een volledige round trip met één functie.

Copyimport json

tools = [{
    "type": "function",
    "function": {
        "name": "word_count",
        "description": "Count the words in a piece of text.",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in: the quick brown fox jumps"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
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 = len(args["text"].split())
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": str(result),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Parse arguments altijd defensief; het model retourneert het als een JSON-string en elk model kan af en toe een onjuiste string produceren. Gebruik voor gestructureerde output zonder tools de JSON-modus.

Copyresp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply with a JSON object with keys title and tags (list of strings)."},
        {"role": "user", "content": "Describe a lighthouse keeper's diary."},
    ],
    response_format={"type": "json_object"},
    temperature=0.2,
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Noem het woord JSON en de sleutels in je prompt, en houd de temperatuur laag. Wikkel json.loads in een try-block voor productiecode.

Snelheidslimieten, fouten en opnieuw proberen

Een volledige sleutel staat 8 gelijktijdige verzoeken en 300 verzoeken per minuut toe. Een proefversie-sleutel staat 2 en 60 toe. Ga daarboven en je krijgt HTTP 429 met de code rate_limited (te veel per minuut) of concurrency (te veel in één keer). Bij tijdelijke overbelasting retourneert de API ook 429, met een Retry-After: 5 header. De SDK probeert sommige fouten zelf op te lossen; voor een script dat veel verzoeken tegelijk uitvoert, is een kleine expliciete wrapper duidelijker.

Copyimport time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError

def ask(prompt, tries=4):
    for attempt in range(tries):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
                max_tokens=300,
            )
            return r.choices[0].message.content
        except RateLimitError:
            time.sleep(5 * (attempt + 1))
    raise RuntimeError("still rate limited")

prompts = [f"Summarize idea number {i} in one sentence." for i in range(20)]
with ThreadPoolExecutor(max_workers=2) as pool:   # 8 on a full key
    results = list(pool.map(ask, prompts))

Het afstemmen van max_workers op de concurrencylimiet van je sleutel voorkomt de meeste 429-fouten voordat ze ontstaan. Elk antwoord bevat ook X-Request-Id, X-Balance-USD en twee rate limit-headers, die je kunt lezen via client.chat.completions.with_raw_response.create(...) wanneer je ze nodig hebt voor foutopsporing of ondersteuning.

Kiezen tussen lokaal en gehost

Sla de ideologie over en beantwoord vier vragen over je project.

1. Moet de data op je machine blijven? Als een contract of gewoonte ja zegt, draai lokaal. Gehoste prompts worden hier niet gebruikt voor training, maar ze reizen wel over het netwerk.
2. Hoeveel geheugen heb je? De grootte van het model bepaalt de kwaliteit. Een laptop zonder eigen GPU beperkt je tot kleine modellen, en de antwoorden zullen dat tonen. Een gehost model geeft je een groot model met een contextvenster van 100.000 tokens, wat thuis moeilijk te evenaren is.
3. Hoeveel verzoeken stuur je? Een paar honderd per week is triviaal aan beide kanten. Honderdduizenden per maand maakt de gehoste rekening tot een reëel bedrag, en een lokale machine ziet er aantrekkelijk uit als deze anders leeg staat. Werk de som uit: 100.000 verzoeken van 1.000 input en 500 output tokens kosten 100.000 x $0,0004 = $40.
4. Moet je weigeringen op een bepaalde manier afhandelen? Veel open-weight modellen worden geleverd met ingebouwd gedrag voor weigeringen, en anderen zijn afgestemd om dit te verwijderen. Het gehoste model hier is afgestemd om te antwoorden zonder inhoudelijke weigeringen voor wettelijk volwassen gebruik, dus hoef je niet te zoeken naar de juiste weigeringen.

Als je antwoorden beide kanten op wijzen, begin dan gehost voor de eerste week. De trial kost niets en je leert wat je prompts nodig hebben voordat je hardware koopt of nog een multi-gigabyte bestand downloadt.

Veelgemaakte fouten in Python-scripts

De meeste problemen die mensen tegenkomen zijn klein en oplosbaar.

• Verkeerde base URL. Deze moet eindigen op /v1. Een ontbrekende suffix geeft een 404, geen behulpzame boodschap. Print client.base_url als je twijfelt.
• Sleutel in de code. Lees deze uit een omgevingsvariabele, zoals hierboven, en voeg je .env bestand toe aan .gitignore.
• Verkeerde modelnaam. De enige model-ID is uncensored. Namen van andere providers werken niet, dus pas ze aan wanneer je code importeert.
• Onbegrensde lussen. Een tool-calling lus die nooit eindigt is een dure bug. Beperk deze tot bijvoorbeeld vijf rondes.
• Het contextbudget negeren. Prompt en completion delen de 100.000 tokens. Als je elke beurt oneindig toevoegt, raak je de limiet uiteindelijk bereikt. Knip of vat oude berichten samen.
• Aannemen dat JSON altijd geldig is. Controleer zelfs in JSON-modus de sleutels die je nodig hebt voordat je ze gebruikt.

Als er aan de serverkant iets vreemd lijkt, citeer dan de X-Request-Id-waarde uit het antwoord wanneer je support schrijft. Dit stelt de operators in staat je exacte aanroep te vinden.

Wat de gehoste optie kost voor Python-werk

Een typische scriptaanroep met 1.000 input en 500 output tokens kost $0,00015 plus $0,00025, dus $0,0004. De $0,50 trial dekt ongeveer 1.250 daarvan. Een top-up van $20, het minimum, dekt 50.000. Credit verloopt nooit, mislukte of geweigerde verzoeken worden niet in rekening gebracht, en prompts worden niet gebruikt voor training. Top-ups gaan tot $500 met een bonus vanaf $50, en betaling is in crypto, USDT op TRC20 of USDC op Base. Zie de pricing-pagina voor de details.

Het is alleen tekst: geen afbeeldingen, audio, video, embeddings of fine-tuning. En de ene harde regel is geen seksuele inhoud met minderjarigen. Voor een Python-project dat tekstgeneratie nodig heeft met minder refusals, is dit het hele oppervlak.

Meer handleidingen

• LLM Gratis API-toegang: Wat de proefversie dekt en kost
• NSFW Video Script LLM API: Een Tekstworkflow
• Uncensored LLM API voor NSFW Pipelines