Startseite / Anleitungen / Kostenlose LLM-API für LangChain

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 zod

Umgebungsvariablen

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:

Kostenlose Modelle mit Tool-Aufrufen und 128K+ Kontext
ModellKostenlos beiKontextKostenlose Limits (bestes Angebot)ToolsBildverarbeitung
GLM 5.3UnoRouter1M1 Anfragen/Min.
1 req/min per model
JaNein
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 Anfragen/Min.
40 RPM
JaJa
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaJaJa
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceJaNein
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditJaJa
Gemini 3.7 FlashGoogle AI Studio1M10 Anfragen/Min.
20 Anfragen/Tag
250,000 Token/Min.
~3M
JaJa
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditJaJa
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 Anfragen/Min.
50 Anfragen/Tag
50 req/day account-wide (1,000 after a $10 purchase)
JaJa
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 Anfragen/Min.
50 Anfragen/Tag
Shared rate limit
JaNein
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 Anfragen/Min.
250 Anfragen/Tag
70,000 Token/Min.
~6M
JaJa

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:

ModellAnbieterDimensionenMax. EingabeKostenloses Limit
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)

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 AppModellangabeGrund
Chat-Antworten für NutzerautoFolgt der Kette, die Sie im Dashboard festlegen
Agent mit Toolsauto:<profile>Ein Profil, das nur Modelle mit Tool-Aufrufen enthält
Klassifikation, Routing, kurze Zusammenfassungenauto:fastOrdnet Modelle nach gemessener Geschwindigkeit
Schwierige Schlussfolgerungsschritteauto:smartOrdnet Modelle nach Intelligenz
Tests, die wiederholbar sein müssenEine feste Modell-IDJedes 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},
)
ProblemUrsacheLösung
openai.AuthenticationErrorFalscher einheitlicher SchlüsselKopieren Sie den Schlüssel erneut von der Seite Keys
openai.NotFoundError bei jedem AufrufDie Basis-URL hat kein /v1Verwenden Sie http://localhost:3001/v1
openai.RateLimitErrorAlle Schlüssel in der Kette haben ihr Limit erreichtFügen Sie Anbieter hinzu, verringern Sie max_concurrency oder warten Sie auf Retry-After
Embedding-Fehler zu Tokens oder EingabetypLangChain sendet Tokens, nicht TextSetzen Sie check_embedding_ctx_length=False
tool_calls ist leerDas Modell unterstützt keine ToolsVerwenden Sie ein Modell aus der Tools-Tabelle oder ein Tools-Profil
Der Begründungstext fehltChatOpenAI behält nur die Standardfelder von OpenAILesen Sie die Antwort in content. Zusätzliche Felder des Anbieters werden nicht übernommen.
Nutzen Sie alle diese Modelle über einen einzigen Schlüssel. FreeLLMAPI ist ein Open-Source-Router, den Sie selbst hosten. Er stellt alle diese kostenlosen Angebote hinter einem einzigen OpenAI-kompatiblen Endpunkt bereit und wechselt zum nächsten Anbieter, wenn ein Anbieter das Limit erreicht. Katalog ansehen oder Jetzt starten.

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

Quellen

Alle Anleitungen · Alle kostenlosen Modelle ansehen