Home / Gidsen / Gratis LLM-API voor LangChain

Gratis LLM-API voor LangChain

LangChain verbindt met OpenAI-compatibele API's via ChatOpenAI en OpenAIEmbeddings. U wijzigt de basis-URL en de sleutel. Deze gids richt beide klassen op FreeLLMAPI. FreeLLMAPI combineert 45 gratis aanbiedersniveaus achter één sleutel. De onderstaande code werkt in Python en JavaScript en verwerkt snelheidslimieten.

Code, modelnamen en labels uit de live catalogus worden in het Engels getoond.

De gateway en de pakketten instellen

Installeer FreeLLMAPI en voeg op de pagina Keys van het dashboard gratis sleutels van twee of meer aanbieders toe. Kopieer de gecombineerde sleutel. Uw code gebruikt alleen deze sleutel. De sleutels van de aanbieders blijven in FreeLLMAPI.

FreeLLMAPI en de LangChain-pakketten installeren

curl -fsSL https://freellmapi.co/install.sh | bash

# Python
pip install -U langchain langchain-openai

# JavaScript
npm install @langchain/openai @langchain/core zod

Omgevingsvariabelen

export FREELLMAPI_BASE_URL=http://localhost:3001/v1
export FREELLMAPI_API_KEY=<unified-key>

Gebruik model="auto" zodat de router een model kiest. U kunt ook een routeringsstrategie gebruiken, bijvoorbeeld auto:fast of auto:smart. Een benoemd profiel zoals auto:coding en een vast model-ID uit de catalogus werken ook.

Om te zien welke modellen uw sleutels nu kunnen aanroepen, vraagt u GET /v1/models?execution_status=ready op. De volledige lijst bevat ook modellen zonder sleutel. Een model met de status exhausted heeft sleutels, maar al die sleutels hebben op dit moment hun limiet bereikt. Die status verdwijnt wanneer de cooldowns eindigen.

Toon de modellen die nu kunnen antwoorden

curl "http://localhost:3001/v1/models?execution_status=ready" \
  -H "Authorization: Bearer <unified-key>"

Chatten met ChatOpenAI

Stel in Python base_url en api_key in. De waarde max_retries gaat naar de OpenAI-client, die 429- en 5xx-fouten opnieuw probeert met exponentieel uitstel.

Python: chat en streaming

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="auto",
    base_url=os.environ["FREELLMAPI_BASE_URL"],
    api_key=os.environ["FREELLMAPI_API_KEY"],
    temperature=0.2,
    max_retries=3,
    timeout=60,
    include_response_headers=True,
)

msg = llm.invoke("Explain retrieval-augmented generation in two sentences.")
print(msg.content)
print("Served by:", msg.response_metadata["headers"].get("x-routed-via"))

for chunk in llm.stream("Write a haiku about SQLite."):
    print(chunk.content, end="", flush=True)

Zet in JavaScript de basis-URL in configuration.baseURL. Het object configuration gaat naar de officiële OpenAI SDK-client.

JavaScript: chat en streaming

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "auto",
  apiKey: process.env.FREELLMAPI_API_KEY,
  temperature: 0.2,
  maxRetries: 3,
  configuration: { baseURL: process.env.FREELLMAPI_BASE_URL },
});

const msg = await llm.invoke("Explain retrieval-augmented generation in two sentences.");
console.log(msg.content);

for await (const chunk of await llm.stream("Write a haiku about SQLite.")) {
  process.stdout.write(String(chunk.content));
}

De header x-routed-via toont de aanbieder en het model dat heeft geantwoord. Als de router van aanbieder is gewisseld, toont x-fallback-trail elke mislukte poging en de reden.

Tools en agents

FreeLLMAPI geeft OpenAI-achtige tools door aan elke aanbieder en geeft tool_calls terug in OpenAI-formaat. Voor Gemini vertaalt het de aanvraag naar het formaat van Google en weer terug. Gebruik bind_tools voor één aanroep, of create_agent voor een lus die de tools uitvoert.

Python: bind_tools en create_agent

from langchain.agents import create_agent
from langchain_core.tools import tool

@tool
def get_weather(city: str) -> str:
    """Return the current weather for a city."""
    return f"It is 18 C and cloudy in {city}."

# One call: the model returns the tool call, your code runs it
msg = llm.bind_tools([get_weather]).invoke("What is the weather in Dublin?")
print(msg.tool_calls)

# Agent loop: LangChain runs the tool and sends the result back
agent = create_agent(
    model=llm,
    tools=[get_weather],
    system_prompt="You answer weather questions. Use the tool.",
)
result = agent.invoke({"messages": [{"role": "user", "content": "Weather in Dublin?"}]})
print(result["messages"][-1].content)

JavaScript: bindTools

import { tool } from "@langchain/core/tools";
import { z } from "zod";

const getWeather = tool(
  async ({ city }) => `It is 18 C and cloudy in ${city}.`,
  {
    name: "get_weather",
    description: "Return the current weather for a city.",
    schema: z.object({ city: z.string() }),
  },
);

const reply = await llm.bindTools([getWeather]).invoke("What is the weather in Dublin?");
console.log(reply.tool_calls);

Alleen sommige gratis modellen ondersteunen tool-aanroepen. Met auto houdt u modellen met tool-aanroepen in uw fallbackketen, of maakt u een profiel voor agents. Deze gratis modellen ondersteunen nu tools:

Gratis modellen met tool-aanroepen en 128K+ context
ModelGratis opContextGratis limieten (beste aanbod)ToolsVision
GLM 5.3UnoRouter1M1 aanvragen/min
1 req/min per model
JaNee
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 aanvragen/min
40 RPM
JaJa
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaJaJa
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceJaNee
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditJaJa
Gemini 3.7 FlashGoogle AI Studio1M10 aanvragen/min
20 aanvragen/dag
250,000 tokens/min
~3M
JaJa
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditJaJa
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 aanvragen/min
50 aanvragen/dag
50 req/day account-wide (1,000 after a $10 purchase)
JaJa
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 aanvragen/min
50 aanvragen/dag
Shared rate limit
JaNee
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 aanvragen/min
250 aanvragen/dag
70,000 tokens/min
~6M
JaJa

Toont 10 van 109 overeenkomende gratis modellen. Bekijk alle modellen.

Actuele gegevens uit de FreeLLMAPI-catalogus (versie 2026.11.19, gecontroleerd 2026-11-19). Gratis limieten veranderen vaak. De catalogus wordt elke dag gecontroleerd.

Embeddings met OpenAIEmbeddings

Standaard splitst OpenAIEmbeddings in Python de tekst met een OpenAI-tokenizer en stuurt tokens. De meeste andere aanbieders hebben ruwe tekst nodig. Stel check_embedding_ctx_length=False in om tekst te sturen.

Python: embeddings

from langchain_openai import OpenAIEmbeddings

emb = OpenAIEmbeddings(
    model="bge-m3",  # one embedding family, 1024 dimensions
    base_url=os.environ["FREELLMAPI_BASE_URL"],
    api_key=os.environ["FREELLMAPI_API_KEY"],
    check_embedding_ctx_length=False,
)
vectors = emb.embed_documents(["FreeLLMAPI pools free tiers.", "LangChain builds LLM apps."])
print(len(vectors), len(vectors[0]))

JavaScript: embeddings

import { OpenAIEmbeddings } from "@langchain/openai";

const emb = new OpenAIEmbeddings({
  model: "bge-m3",
  apiKey: process.env.FREELLMAPI_API_KEY,
  configuration: { baseURL: process.env.FREELLMAPI_BASE_URL },
});
const vector = await emb.embedQuery("What does FreeLLMAPI do?");
console.log(vector.length);

Embedding-failover in FreeLLMAPI wijzigt het model nooit. Het schakelt alleen tussen aanbieders die dezelfde familie leveren. Zo blijven alle vectoren in één vectoropslag compatibel. Kies een familie en houd die. De gratis embeddingmodellen van nu zijn:

ModelAanbiederAfmetingenMax invoerGratis limiet
Gemini Embedding
gemini-embedding-001
Google AI Studio30722048100 rpm · 1K req/day
Nemotron Embed VL 1B
nvidia/llama-nemotron-embed-vl-1b-v2
NVIDIA NIM20488192~40 rpm
Nemotron 3 Embed 1B (OR free)
nvidia/nemotron-3-embed-1b:free
OpenRouter20483276820 rpm · shared free daily cap
SEA-LION E5 Embedding 600M
aisingapore/SEA-LION-E5-Embedding-600M
SEA-LION10248192free · 10 rpm
SEA-LION ModernBERT Embedding 300M
aisingapore/SEA-LION-ModernBERT-Embedding-300M
SEA-LION10248192free · 10 rpm
SEA-LION ModernBERT Embedding 600M
aisingapore/SEA-LION-ModernBERT-Embedding-600M
SEA-LION10248192free · 10 rpm
BGE-M3
@cf/baai/bge-m3
Cloudflare Workers AI1024819210K neurons/day (shared)
EmbeddingGemma 300M
@cf/google/embeddinggemma-300m
Cloudflare Workers AI768204810K neurons/day (shared)
Qwen3 Embedding 0.6B
@cf/qwen/qwen3-embedding-0.6b
Cloudflare Workers AI1024819210K neurons/day (shared)
Cohere Embed v4
embed-v4.0
Cohere15361280001K calls/mo (shared w/ chat)
Gemini Embedding 2
gemini-embedding-2
Google AI Studio30728192free-tier rate limited
Nemotron 3 Embed 1B
nvidia/nemotron-3-embed-1b
NVIDIA NIM20484096~40 rpm
PLaMo Embedding 1B (CF)
@cf/pfnet/plamo-embedding-1b
Cloudflare Workers AI2048409610K neurons/day (shared)
BGE Small EN v1.5 (CF)
@cf/baai/bge-small-en-v1.5
Cloudflare Workers AI38451210K neurons/day (shared)
BGE Base EN v1.5 (CF)
@cf/baai/bge-base-en-v1.5
Cloudflare Workers AI76851210K neurons/day (shared)
BGE Large EN v1.5 (CF)
@cf/baai/bge-large-en-v1.5
Cloudflare Workers AI102451210K neurons/day (shared)
Mistral Embed
mistral-embed
Mistral10248192free mode · monthly cap (shared)
Codestral Embed
codestral-embed
Mistral15368192free mode · monthly cap (shared)
Llama Text Embed v2 (Pinecone)
llama-text-embed-v2
Pinecone102420485M tokens/mo per model
Multilingual E5 Large (Pinecone)
multilingual-e5-large
Pinecone10245075M tokens/mo per model
Nemotron 3 Embed 1B (Speka)
nvidia/nemotron-3-embed-1b
Speka20488192$1/month shared across Speka models
OpenAI: Text Embedding 3 Small (ElectronHub)
text-embedding-3-small
ElectronHub15368192$0.25/week shared free credits
OpenAI: Text Embedding 3 Large (ElectronHub)
text-embedding-3-large
ElectronHub30728192$0.25/week shared free credits
Nemotron 3 Embed 8B (Inferbase)
nvidia-nemotron-3-embed-8b
Inferbase409681925,000 requests/month; 100 requests and $0.50 usage/day shared
Qwen 3 Embedding 0.6B (Inferbase)
qwen3-embedding-0-6b
Inferbase102481925,000 requests/month; 100 requests and $0.50 usage/day shared
Qwen 3 Embedding 4B (Inferbase)
qwen3-embedding-4b
Inferbase256081925,000 requests/month; 100 requests and $0.50 usage/day shared
Qwen 3 Embedding 8B (Inferbase)
qwen3-embedding-8b
Inferbase409681925,000 requests/month; 100 requests and $0.50 usage/day shared
LFM2.5 Embedding 350M (LLMTR)
liquid/lfm-2.5-embedding-350m-free
LLMTR1024512Ongoing zero-price route; provider terms apply
BGE-M3 (SEA-LION)
BAAI/bge-m3
SEA-LION10248192free · 10 rpm
Cohere Embed English v3
embed-english-v3.0
Cohere10245121K calls/mo (shared w/ chat)
Qwen3 Embedding 8B (OVH)
Qwen3-Embedding-8B
OVH AI Endpoints409632768free · anonymous 2 req/min per IP
BGE-M3 (OVH)
bge-m3
OVH AI Endpoints10248192free · anonymous 2 req/min per IP
BGE Multilingual Gemma2 (OVH)
bge-multilingual-gemma2
OVH AI Endpoints35848192free · anonymous 2 req/min per IP
Mistral: Codestral Embed (ElectronHub)
codestral-embed
ElectronHub15368192$0.25/week shared free credits
Mistral: Mistral Embed (ElectronHub)
mistral-embed
ElectronHub10248192$0.25/week shared free credits
Google: Gemini Embedding 2 (ElectronHub)
gemini-embedding-2
ElectronHub30728192$0.25/week shared free credits
Google: Gemini Embedding 001 (ElectronHub)
gemini-embedding-001
ElectronHub30722048$0.25/week shared free credits
OpenAI: Text Embedding Ada 002 (ElectronHub)
text-embedding-ada-002
ElectronHub15368192$0.25/week shared free credits
Cohere Embed English Light v3
embed-english-light-v3.0
Cohere3845121K calls/mo (shared w/ chat)
Cohere Embed Multilingual v3
embed-multilingual-v3.0
Cohere10245121K calls/mo (shared w/ chat)
Cohere Embed Multilingual Light v3
embed-multilingual-light-v3.0
Cohere3845121K calls/mo (shared w/ chat)

Actuele gegevens uit de FreeLLMAPI-catalogus (versie 2026.11.19, gecontroleerd 2026-11-19). Gratis limieten veranderen vaak. De catalogus wordt elke dag gecontroleerd.

Gestructureerde output, sessies en modelkeuze

with_structured_output geeft een Pydantic-object terug in plaats van tekst. Standaard gebruikt LangChain hiervoor function calling. Die methode werkt op elk gratis model dat tools ondersteunt.

Python: gestructureerde output

from pydantic import BaseModel, Field

class Ticket(BaseModel):
    category: str = Field(description="billing, bug or other")
    urgent: bool

classifier = llm.with_structured_output(Ticket)
ticket = classifier.invoke("The app crashes when I pay. Please fix it today.")
print(ticket.category, ticket.urgent)

Gebruik method="json_schema" niet met auto. Niet elke gratis aanbieder ondersteunt strikte JSON-schema-output, en de router kan bij elke aanvraag een andere aanbieder kiezen.

FreeLLMAPI houdt een gesprek 30 minuten op één model. Het vindt het gesprek via de header X-Session-Id. Als er geen header is, gebruikt het een hash van het eerste gebruikersbericht. Voor een chatapp met veel gebruikers stuurt u per gebruiker één sessie-ID:

Python: één sessie per gebruiker

def llm_for(user_id: str) -> ChatOpenAI:
    return ChatOpenAI(
        model="auto",
        base_url=os.environ["FREELLMAPI_BASE_URL"],
        api_key=os.environ["FREELLMAPI_API_KEY"],
        default_headers={"X-Session-Id": f"user-{user_id}"},
        max_retries=3,
    )

Kies de modelstring voor elk onderdeel van uw app:

Taak in uw appModelstringReden
Chatantwoorden voor gebruikersautoVolgt de keten die u op het dashboard hebt ingesteld
Agent met toolsauto:<profile>Een profiel met alleen modellen die tool-aanroepen ondersteunen
Classificatie, routering, korte samenvattingenauto:fastRangschikt modellen op gemeten snelheid
Moeilijke redeneerstappenauto:smartRangschikt modellen op intelligentie
Tests die herhaalbaar moeten zijnEen vast model-IDElke keer hetzelfde model, maar het stopt bij de limiet van dat model

Gratis niveaus hebben geen SLA. De latentie verandert gedurende de dag, en de sterkste modellen bereiken hun dagelijkse limieten het eerst. Test uw ketens met de modellen die uw keten daadwerkelijk gebruikt.

Snelheidslimieten en herhalingen

FreeLLMAPI probeert de volgende aanbieder wanneer er een 429 terugkomt. Uw code ziet alleen een 429 wanneer elke sleutel in de keten zijn limiet heeft bereikt. Dan heeft het antwoord een header Retry-After. Veel dagelijkse limieten worden om middernacht UTC gereset.

Voor batchtaken voegt u een tweede herhalingslaag toe met with_retry. Dat probeert de hele runnable opnieuw met exponentieel uitstel en jitter.

Python: een keten opnieuw proberen bij snelheidslimieten

import openai
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Summarize the text in one sentence."),
    ("user", "{text}"),
])

chain = (prompt | llm).with_retry(
    retry_if_exception_type=(openai.RateLimitError, openai.APITimeoutError),
    wait_exponential_jitter=True,
    stop_after_attempt=5,
)

# batch() runs requests in parallel; max_concurrency keeps the rate low
results = chain.batch(
    [{"text": t} for t in ["First document.", "Second document."]],
    config={"max_concurrency": 4},
)
ProbleemOorzaakOplossing
openai.AuthenticationErrorVerkeerde gecombineerde sleutelKopieer de sleutel opnieuw van de pagina Keys
openai.NotFoundError bij elke aanroepDe basis-URL heeft geen /v1Gebruik http://localhost:3001/v1
openai.RateLimitErrorAlle sleutels in de keten hebben hun limiet bereiktVoeg aanbieders toe, verlaag max_concurrency of wacht op Retry-After
Embedding-fout over tokens of invoertypeLangChain stuurt tokens, geen tekstStel check_embedding_ctx_length=False in
tool_calls is leegHet model ondersteunt geen toolsGebruik een model uit de tabel met tools, of een profiel voor tools
Redeneertekst ontbreektChatOpenAI houdt alleen standaard OpenAI-veldenLees het antwoord in content; extra velden van de aanbieder worden niet bewaard
Gebruik elk van deze met één sleutel. FreeLLMAPI is een open-source router die u zelf host. Die zet al deze gratis tarieven achter één eindpunt dat compatibel is met OpenAI. Bij een snelheidslimiet schakelt de router automatisch over. Bekijk de catalogus of live gaan.

Veelgestelde vragen

Kan ik een gratis LLM-API met LangChain gebruiken?

Ja. Elke OpenAI-compatibele API werkt met ChatOpenAI. Stel base_url in op http://localhost:3001/v1 en api_key op uw gecombineerde FreeLLMAPI-sleutel. De router gebruikt gratis niveaus van aanbieders.

Hoe stel ik een eigen basis-URL in bij LangChain ChatOpenAI?

In Python geeft u base_url door aan ChatOpenAI. In JavaScript geeft u configuration: { baseURL } door aan de constructor. De omgevingsvariabele OPENAI_BASE_URL werkt in Python ook.

Werken LangChain-agents met gratis modellen?

Ja, als het model tool-aanroepen ondersteunt. Gebruik create_agent met een ChatOpenAI-model en houd modellen met tool-aanroepen in uw FreeLLMAPI-keten.

Waarom mislukt OpenAIEmbeddings bij een aanbieder die geen OpenAI is?

Standaard stuurt het token-ID's. De meeste andere aanbieders hebben ruwe tekst nodig. Stel in Python check_embedding_ctx_length=False in.

Hoe verwerk ik 429-fouten in LangChain?

Stel max_retries in op ChatOpenAI en voeg with_retry toe aan de keten voor batchtaken. FreeLLMAPI gaat al naar de volgende aanbieder voordat uw code een 429 ziet.

Gerelateerde gidsen

Bronnen

Alle gidsen · Bekijk alle gratis modellen