Kostenlose LLM-API für LangChain
LangChain verbindet sich mit OpenAI-kompatiblen APIs über ChatOpenAI und OpenAIEmbeddings. Sie ändern die Basis-URL und den Schlüssel. Diese Anleitung richtet beide Klassen auf FreeLLMAPI aus. FreeLLMAPI bündelt 45 kostenlose Angebote von Anbietern hinter einem Schlüssel. Der Code unten funktioniert in Python und JavaScript und behandelt Rate Limits.
Code, Modellnamen und Bezeichnungen aus dem Live-Katalog werden auf Englisch angezeigt.
Gateway und Pakete einrichten
Installieren Sie FreeLLMAPI und fügen Sie auf der Seite Keys im Dashboard kostenlose Schlüssel von zwei oder mehr Anbietern hinzu. Kopieren Sie den einheitlichen Schlüssel. Ihr Code verwendet nur diesen Schlüssel. Die Anbieterschlüssel bleiben in FreeLLMAPI.
FreeLLMAPI und die LangChain-Pakete installieren
curl -fsSL https://freellmapi.co/install.sh | bash
# Python
pip install -U langchain langchain-openai
# JavaScript
npm install @langchain/openai @langchain/core zodUmgebungsvariablen
export FREELLMAPI_BASE_URL=http://localhost:3001/v1
export FREELLMAPI_API_KEY=<unified-key>Verwenden Sie model="auto", damit der Router ein Modell auswählt. Sie können auch eine Routing-Strategie verwenden, zum Beispiel auto:fast oder auto:smart. Ein benanntes Profil wie auto:coding und eine feste Modell-ID aus dem Katalog funktionieren ebenfalls.
Um zu sehen, welche Modelle Ihre Schlüssel jetzt aufrufen können, senden Sie GET /v1/models?execution_status=ready. Die vollständige Liste enthält auch Modelle ohne Schlüssel. Ein Modell mit dem Status exhausted hat Schlüssel, aber alle davon haben in diesem Moment ihr Limit erreicht. Dieser Status endet, wenn die Abkühlzeiten vorbei sind.
Modelle auflisten, die jetzt antworten können
curl "http://localhost:3001/v1/models?execution_status=ready" \
-H "Authorization: Bearer <unified-key>"Mit ChatOpenAI chatten
Setzen Sie in Python base_url und api_key. Der Wert max_retries geht an den OpenAI-Client, der Fehler 429 und 5xx mit exponentiellem Backoff wiederholt.
Python: Chat und 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)Setzen Sie in JavaScript die Basis-URL in configuration.baseURL. Das Objekt configuration geht an den offiziellen OpenAI-SDK-Client.
JavaScript: Chat und 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));
}Der Header x-routed-via zeigt den Anbieter und das Modell, die geantwortet haben. Hat der Router den Anbieter gewechselt, zeigt x-fallback-trail jeden fehlgeschlagenen Versuch und den Grund.
Tools und Agenten
FreeLLMAPI übergibt OpenAI-artige tools an jeden Anbieter und gibt tool_calls im OpenAI-Format zurück. Bei Gemini übersetzt es die Anfrage in das Format von Google und zurück. Verwenden Sie bind_tools für einen einzelnen Aufruf oder create_agent für eine Schleife, die die Tools ausführt.
Python: bind_tools und 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);Nur manche kostenlosen Modelle unterstützen Tool-Aufrufe. Bei auto halten Sie Modelle mit Tool-Aufrufen in Ihrer Fallback-Kette oder erstellen Sie ein Profil für Agenten. Diese kostenlosen Modelle unterstützen heute Tools:
| Modell | Kostenlos bei | Kontext | Kostenlose Limits (bestes Angebot) | Tools | Bildverarbeitung |
|---|---|---|---|---|---|
| GLM 5.3 | UnoRouter | 1M | 1 Anfragen/Min. 1 req/min per model | Ja | Nein |
| GLM 5.3 Flash | NVIDIA NIM, UnoRouter | 1M | 40 Anfragen/Min. 40 RPM | Ja | Ja |
| Gemini 3.8 Flash | Google AI Studio | 1M | Recurring provider quota | Ja | Ja |
| Qwen3.8 Flash Next | AMD Radeon Cloud | 262K | Recurring daily account allowance | Ja | Nein |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Ja | Ja |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 Anfragen/Min. 20 Anfragen/Tag 250,000 Token/Min. ~3M | Ja | Ja |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Ja | Ja |
| Dots3 Note Preview | Kilo Gateway, OpenRouter | 512K | 20 Anfragen/Min. 50 Anfragen/Tag 50 req/day account-wide (1,000 after a $10 purchase) | Ja | Ja |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 Anfragen/Min. 50 Anfragen/Tag Shared rate limit | Ja | Nein |
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 Anfragen/Min. 250 Anfragen/Tag 70,000 Token/Min. ~6M | Ja | Ja |
Es werden 10 von 109 passenden kostenlosen Modellen angezeigt. Alle Modelle ansehen.
Live-Daten aus dem FreeLLMAPI-Katalog (Version 2026.11.19, geprüft 2026-11-19). Kostenlose Limits ändern sich oft. Der Katalog wird jeden Tag geprüft.
Embeddings mit OpenAIEmbeddings
Standardmäßig teilt OpenAIEmbeddings in Python den Text mit einem OpenAI-Tokenizer auf und sendet Token. Die meisten anderen Anbieter benötigen Rohtext. Setzen Sie check_embedding_ctx_length=False, um Text zu senden.
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);Das Embedding-Failover in FreeLLMAPI wechselt das Modell nie. Es wechselt nur zwischen Anbietern, die dieselbe Familie bereitstellen. So bleiben alle Vektoren in einem Vektorspeicher kompatibel. Wählen Sie eine Familie und behalten Sie sie bei. Die kostenlosen Embedding-Modelle sind heute:
| Modell | Anbieter | Dimensionen | Max. Eingabe | Kostenloses Limit |
|---|---|---|---|---|
Gemini Embeddinggemini-embedding-001 | Google AI Studio | 3072 | 2048 | 100 rpm · 1K req/day |
Nemotron Embed VL 1Bnvidia/llama-nemotron-embed-vl-1b-v2 | NVIDIA NIM | 2048 | 8192 | ~40 rpm |
Nemotron 3 Embed 1B (OR free)nvidia/nemotron-3-embed-1b:free | OpenRouter | 2048 | 32768 | 20 rpm · shared free daily cap |
SEA-LION E5 Embedding 600Maisingapore/SEA-LION-E5-Embedding-600M | SEA-LION | 1024 | 8192 | free · 10 rpm |
SEA-LION ModernBERT Embedding 300Maisingapore/SEA-LION-ModernBERT-Embedding-300M | SEA-LION | 1024 | 8192 | free · 10 rpm |
SEA-LION ModernBERT Embedding 600Maisingapore/SEA-LION-ModernBERT-Embedding-600M | SEA-LION | 1024 | 8192 | free · 10 rpm |
BGE-M3@cf/baai/bge-m3 | Cloudflare Workers AI | 1024 | 8192 | 10K neurons/day (shared) |
EmbeddingGemma 300M@cf/google/embeddinggemma-300m | Cloudflare Workers AI | 768 | 2048 | 10K neurons/day (shared) |
Qwen3 Embedding 0.6B@cf/qwen/qwen3-embedding-0.6b | Cloudflare Workers AI | 1024 | 8192 | 10K neurons/day (shared) |
Cohere Embed v4embed-v4.0 | Cohere | 1536 | 128000 | 1K calls/mo (shared w/ chat) |
Gemini Embedding 2gemini-embedding-2 | Google AI Studio | 3072 | 8192 | free-tier rate limited |
Nemotron 3 Embed 1Bnvidia/nemotron-3-embed-1b | NVIDIA NIM | 2048 | 4096 | ~40 rpm |
PLaMo Embedding 1B (CF)@cf/pfnet/plamo-embedding-1b | Cloudflare Workers AI | 2048 | 4096 | 10K neurons/day (shared) |
BGE Small EN v1.5 (CF)@cf/baai/bge-small-en-v1.5 | Cloudflare Workers AI | 384 | 512 | 10K neurons/day (shared) |
BGE Base EN v1.5 (CF)@cf/baai/bge-base-en-v1.5 | Cloudflare Workers AI | 768 | 512 | 10K neurons/day (shared) |
BGE Large EN v1.5 (CF)@cf/baai/bge-large-en-v1.5 | Cloudflare Workers AI | 1024 | 512 | 10K neurons/day (shared) |
Mistral Embedmistral-embed | Mistral | 1024 | 8192 | free mode · monthly cap (shared) |
Codestral Embedcodestral-embed | Mistral | 1536 | 8192 | free mode · monthly cap (shared) |
Llama Text Embed v2 (Pinecone)llama-text-embed-v2 | Pinecone | 1024 | 2048 | 5M tokens/mo per model |
Multilingual E5 Large (Pinecone)multilingual-e5-large | Pinecone | 1024 | 507 | 5M tokens/mo per model |
Nemotron 3 Embed 1B (Speka)nvidia/nemotron-3-embed-1b | Speka | 2048 | 8192 | $1/month shared across Speka models |
OpenAI: Text Embedding 3 Small (ElectronHub)text-embedding-3-small | ElectronHub | 1536 | 8192 | $0.25/week shared free credits |
OpenAI: Text Embedding 3 Large (ElectronHub)text-embedding-3-large | ElectronHub | 3072 | 8192 | $0.25/week shared free credits |
Nemotron 3 Embed 8B (Inferbase)nvidia-nemotron-3-embed-8b | Inferbase | 4096 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
Qwen 3 Embedding 0.6B (Inferbase)qwen3-embedding-0-6b | Inferbase | 1024 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
Qwen 3 Embedding 4B (Inferbase)qwen3-embedding-4b | Inferbase | 2560 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
Qwen 3 Embedding 8B (Inferbase)qwen3-embedding-8b | Inferbase | 4096 | 8192 | 5,000 requests/month; 100 requests and $0.50 usage/day shared |
LFM2.5 Embedding 350M (LLMTR)liquid/lfm-2.5-embedding-350m-free | LLMTR | 1024 | 512 | Ongoing zero-price route; provider terms apply |
BGE-M3 (SEA-LION)BAAI/bge-m3 | SEA-LION | 1024 | 8192 | free · 10 rpm |
Cohere Embed English v3embed-english-v3.0 | Cohere | 1024 | 512 | 1K calls/mo (shared w/ chat) |
Qwen3 Embedding 8B (OVH)Qwen3-Embedding-8B | OVH AI Endpoints | 4096 | 32768 | free · anonymous 2 req/min per IP |
BGE-M3 (OVH)bge-m3 | OVH AI Endpoints | 1024 | 8192 | free · anonymous 2 req/min per IP |
BGE Multilingual Gemma2 (OVH)bge-multilingual-gemma2 | OVH AI Endpoints | 3584 | 8192 | free · anonymous 2 req/min per IP |
Mistral: Codestral Embed (ElectronHub)codestral-embed | ElectronHub | 1536 | 8192 | $0.25/week shared free credits |
Mistral: Mistral Embed (ElectronHub)mistral-embed | ElectronHub | 1024 | 8192 | $0.25/week shared free credits |
Google: Gemini Embedding 2 (ElectronHub)gemini-embedding-2 | ElectronHub | 3072 | 8192 | $0.25/week shared free credits |
Google: Gemini Embedding 001 (ElectronHub)gemini-embedding-001 | ElectronHub | 3072 | 2048 | $0.25/week shared free credits |
OpenAI: Text Embedding Ada 002 (ElectronHub)text-embedding-ada-002 | ElectronHub | 1536 | 8192 | $0.25/week shared free credits |
Cohere Embed English Light v3embed-english-light-v3.0 | Cohere | 384 | 512 | 1K calls/mo (shared w/ chat) |
Cohere Embed Multilingual v3embed-multilingual-v3.0 | Cohere | 1024 | 512 | 1K calls/mo (shared w/ chat) |
Cohere Embed Multilingual Light v3embed-multilingual-light-v3.0 | Cohere | 384 | 512 | 1K calls/mo (shared w/ chat) |
Live-Daten aus dem FreeLLMAPI-Katalog (Version 2026.11.19, geprüft 2026-11-19). Kostenlose Limits ändern sich oft. Der Katalog wird jeden Tag geprüft.
Strukturierte Ausgabe, Sitzungen und Modellwahl
with_structured_output gibt ein Pydantic-Objekt anstelle von Text zurück. Standardmäßig verwendet LangChain dafür Funktionsaufrufe. Diese Methode funktioniert bei jedem kostenlosen Modell, das Tools unterstützt.
Python: strukturierte Ausgabe
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)Verwenden Sie method="json_schema" nicht zusammen mit auto. Nicht jeder kostenlose Anbieter unterstützt strikte JSON-Schema-Ausgaben, und der Router kann bei jeder Anfrage einen anderen Anbieter wählen.
FreeLLMAPI hält eine Unterhaltung 30 Minuten lang auf einem Modell. Die Unterhaltung wird über den Header X-Session-Id erkannt. Fehlt der Header, verwendet FreeLLMAPI einen Hash der ersten Nutzernachricht. Bei einer Chat-App mit vielen Nutzern senden Sie pro Nutzer eine Sitzungs-ID:
Python: eine Sitzung pro Nutzer
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,
)Wählen Sie die Modellangabe für jeden Teil Ihrer App:
| Aufgabe in Ihrer App | Modellangabe | Grund |
|---|---|---|
| Chat-Antworten für Nutzer | auto | Folgt der Kette, die Sie im Dashboard festlegen |
| Agent mit Tools | auto:<profile> | Ein Profil, das nur Modelle mit Tool-Aufrufen enthält |
| Klassifikation, Routing, kurze Zusammenfassungen | auto:fast | Ordnet Modelle nach gemessener Geschwindigkeit |
| Schwierige Schlussfolgerungsschritte | auto:smart | Ordnet Modelle nach Intelligenz |
| Tests, die wiederholbar sein müssen | Eine feste Modell-ID | Jedes Mal dasselbe Modell, aber es stoppt beim Limit dieses Modells |
Kostenlose Angebote haben kein SLA. Die Latenz ändert sich im Tagesverlauf, und die stärksten Modelle erreichen ihre Tageslimits zuerst. Testen Sie Ihre Ketten mit den Modellen, die Ihre Kette tatsächlich verwendet.
Rate Limits und Wiederholungen
FreeLLMAPI versucht den nächsten Anbieter, wenn einer den Fehler 429 zurückgibt. Ihr Code sieht einen 429-Fehler nur, wenn jeder Schlüssel in der Kette sein Limit erreicht hat. Dann enthält die Antwort einen Header Retry-After. Viele Tageslimits werden um Mitternacht UTC zurückgesetzt.
Für Batch-Jobs fügen Sie mit with_retry eine zweite Wiederholungsebene hinzu. Sie wiederholt die gesamte Runnable mit exponentiellem Backoff und Jitter.
Python: eine Kette bei Rate Limits wiederholen
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},
)| Problem | Ursache | Lösung |
|---|---|---|
openai.AuthenticationError | Falscher einheitlicher Schlüssel | Kopieren Sie den Schlüssel erneut von der Seite Keys |
openai.NotFoundError bei jedem Aufruf | Die Basis-URL hat kein /v1 | Verwenden Sie http://localhost:3001/v1 |
openai.RateLimitError | Alle Schlüssel in der Kette haben ihr Limit erreicht | Fügen Sie Anbieter hinzu, verringern Sie max_concurrency oder warten Sie auf Retry-After |
| Embedding-Fehler zu Tokens oder Eingabetyp | LangChain sendet Tokens, nicht Text | Setzen Sie check_embedding_ctx_length=False |
tool_calls ist leer | Das Modell unterstützt keine Tools | Verwenden Sie ein Modell aus der Tools-Tabelle oder ein Tools-Profil |
| Der Begründungstext fehlt | ChatOpenAI behält nur die Standardfelder von OpenAI | Lesen Sie die Antwort in content. Zusätzliche Felder des Anbieters werden nicht übernommen. |
Häufig gestellte Fragen
Kann ich eine kostenlose LLM-API mit LangChain verwenden?
Ja. Jede OpenAI-kompatible API funktioniert mit ChatOpenAI. Setzen Sie base_url auf http://localhost:3001/v1 und api_key auf Ihren einheitlichen FreeLLMAPI-Schlüssel. Der Router nutzt kostenlose Angebote von Anbietern.
Wie setze ich eine eigene Basis-URL in LangChain ChatOpenAI?
In Python übergeben Sie base_url an ChatOpenAI. In JavaScript übergeben Sie configuration: { baseURL } an den Konstruktor. Die Umgebungsvariable OPENAI_BASE_URL funktioniert in Python ebenfalls.
Funktionieren LangChain-Agenten mit kostenlosen Modellen?
Ja, wenn das Modell Tool-Aufrufe unterstützt. Verwenden Sie create_agent mit einem ChatOpenAI-Modell und halten Sie Modelle mit Tool-Aufrufen in Ihrer FreeLLMAPI-Kette.
Warum schlägt OpenAIEmbeddings bei einem Nicht-OpenAI-Anbieter fehl?
Standardmäßig sendet es Token-IDs. Die meisten anderen Anbieter benötigen Rohtext. Setzen Sie in Python check_embedding_ctx_length=False.
Wie behandle ich Fehler 429 in LangChain?
Setzen Sie max_retries bei ChatOpenAI und fügen Sie für Batch-Jobs with_retry zur Kette hinzu. FreeLLMAPI wechselt bereits zum nächsten Anbieter, bevor Ihr Code einen 429-Fehler sieht.
Verwandte Anleitungen
- Kostenloses LLM für LlamaIndex
- Kostenlose LLM-API in Python
- Kostenlose LLM-API für RAG
- Kostenlose Embeddings-API
- Kostenlose LLM API mit Function Calling
- Kostenlose LLM-API für KI-Agenten
Quellen
- LangChain docs: ChatOpenAI integration (Python) (geprüft 20 November 2026)
- LangChain docs: ChatOpenAI integration (JavaScript) (geprüft 20 November 2026)
- LangChain docs: agents and create_agent (geprüft 20 November 2026)
- LangChain source: OpenAIEmbeddings note on OpenAI-compatible APIs (geprüft 20 November 2026)
- OpenAI Python SDK: retries and errors (geprüft 20 November 2026)
- FreeLLMAPI docs: REST API (tool calling, embeddings, response headers) (geprüft 20 November 2026)