API LLM gratuite pour LangChain
LangChain se connecte aux API compatibles OpenAI via ChatOpenAI et OpenAIEmbeddings. Vous modifiez l'URL de base et la clé. Ce guide dirige les deux classes vers FreeLLMAPI, qui regroupe 45 offres gratuites de fournisseurs derrière une seule clé. Le code ci-dessous fonctionne en Python et en JavaScript, et gère les limites de débit.
Le code, les noms de modèles et les libellés du catalogue en direct sont affichés en anglais.
Configurer la passerelle et les paquets
Installez FreeLLMAPI et ajoutez des clés gratuites de deux fournisseurs ou plus sur la page Keys du tableau de bord. Copiez la clé unifiée. Votre code n'utilise que cette clé. Les clés des fournisseurs restent dans FreeLLMAPI.
Installer FreeLLMAPI et les paquets LangChain
curl -fsSL https://freellmapi.co/install.sh | bash
# Python
pip install -U langchain langchain-openai
# JavaScript
npm install @langchain/openai @langchain/core zodVariables d'environnement
export FREELLMAPI_BASE_URL=http://localhost:3001/v1
export FREELLMAPI_API_KEY=<unified-key>Utilisez model="auto" pour laisser le routeur choisir un modèle. Vous pouvez aussi utiliser une stratégie de routage, par exemple auto:fast ou auto:smart. Un profil nommé, comme auto:coding, et un identifiant de modèle fixe du catalogue fonctionnent aussi.
Pour voir quels modèles vos clés peuvent appeler maintenant, envoyez GET /v1/models?execution_status=ready. La liste complète contient aussi des modèles sans clé. Un modèle au statut exhausted a des clés, mais toutes sont à leur limite pour le moment. Ce statut disparaît lorsque les délais d'attente se terminent.
Lister les modèles qui peuvent répondre maintenant
curl "http://localhost:3001/v1/models?execution_status=ready" \
-H "Authorization: Bearer <unified-key>"Discuter avec ChatOpenAI
En Python, définissez base_url et api_key. La valeur max_retries est transmise au client OpenAI, qui relance les erreurs 429 et 5xx avec un délai exponentiel.
Python : chat et 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)En JavaScript, placez l'URL de base dans configuration.baseURL. L'objet configuration est transmis au client du SDK OpenAI officiel.
JavaScript : chat et 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));
}L'en-tête x-routed-via indique le fournisseur et le modèle qui ont répondu. Si le routeur a changé de fournisseur, x-fallback-trail indique chaque tentative échouée et sa raison.
Outils et agents
FreeLLMAPI transmet les tools au format OpenAI à chaque fournisseur, et renvoie les tool_calls au format OpenAI. Pour Gemini, il convertit la requête au format de Google, puis reconvertit la réponse. Utilisez bind_tools pour un seul appel, ou create_agent pour une boucle qui exécute les outils.
Python : bind_tools et 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);Seuls certains modèles gratuits prennent en charge l'appel d'outils. Avec auto, gardez les modèles qui appellent des outils dans votre chaîne de secours, ou créez un profil pour les agents. Ces modèles gratuits prennent actuellement en charge les outils :
| Modèle | Gratuit sur | Contexte | Limites gratuites (meilleure offre) | Outils | Vision |
|---|---|---|---|---|---|
| GLM 5.3 | UnoRouter | 1M | 1 req/min 1 req/min per model | Oui | Non |
| GLM 5.3 Flash | NVIDIA NIM, UnoRouter | 1M | 40 req/min 40 RPM | Oui | Oui |
| Gemini 3.8 Flash | Google AI Studio | 1M | Recurring provider quota | Oui | Oui |
| Qwen3.8 Flash Next | AMD Radeon Cloud | 262K | Recurring daily account allowance | Oui | Non |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Oui | Oui |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Oui | Oui |
| Dots3 Note Preview | Kilo Gateway, OpenRouter | 512K | 20 req/min 50 req/jour 50 req/day account-wide (1,000 after a $10 purchase) | Oui | Oui |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 req/min 50 req/jour Shared rate limit | Oui | Non |
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 req/min 250 req/jour 70,000 jetons/min ~6M | Oui | Oui |
Affichage de 10 modèles gratuits sur 109 correspondants. Voir tous les modèles.
Données en direct du catalogue FreeLLMAPI (version 2026.11.19, vérifié le 2026-11-19). Les limites gratuites changent souvent. Le catalogue est vérifié chaque jour.
Embeddings avec OpenAIEmbeddings
Par défaut, OpenAIEmbeddings en Python découpe le texte avec un tokenizer OpenAI et envoie des jetons. La plupart des autres fournisseurs attendent du texte brut. Définissez check_embedding_ctx_length=False pour envoyer du texte.
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);Le basculement des embeddings dans FreeLLMAPI ne change jamais de modèle. Il passe seulement entre les fournisseurs qui proposent la même famille. Ainsi, tous les vecteurs d'un même magasin restent compatibles. Choisissez une famille et conservez-la. Les modèles d'embeddings gratuits actuels sont :
| Modèle | Fournisseur | Dimensions | Entrée max | Limite gratuite |
|---|---|---|---|---|
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) |
Données en direct du catalogue FreeLLMAPI (version 2026.11.19, vérifié le 2026-11-19). Les limites gratuites changent souvent. Le catalogue est vérifié chaque jour.
Sortie structurée, sessions et choix du modèle
with_structured_output renvoie un objet Pydantic à la place du texte. Par défaut, LangChain utilise l'appel de fonctions pour cela. Cette méthode fonctionne avec chaque modèle gratuit qui prend en charge les outils.
Python : sortie structurée
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)N'utilisez pas method="json_schema" avec auto. Tous les fournisseurs gratuits ne prennent pas en charge la sortie JSON schema stricte, et le routeur peut choisir un fournisseur différent pour chaque requête.
FreeLLMAPI garde une conversation sur un même modèle pendant 30 minutes. Il retrouve la conversation grâce à l'en-tête X-Session-Id. S'il n'y a pas d'en-tête, il utilise un hachage du premier message utilisateur. Pour une application de chat avec de nombreux utilisateurs, envoyez un identifiant de session par utilisateur :
Python : une session par utilisateur
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,
)Choisissez la chaîne de modèle pour chaque partie de votre application :
| Tâche dans votre application | Chaîne de modèle | Raison |
|---|---|---|
| Réponses de chat pour les utilisateurs | auto | Suit la chaîne que vous avez définie sur le tableau de bord |
| Agent avec outils | auto:<profile> | Un profil qui ne contient que des modèles qui appellent des outils |
| Classification, routage, résumés courts | auto:fast | Classe les modèles selon leur vitesse mesurée |
| Étapes de raisonnement complexes | auto:smart | Classe les modèles par intelligence |
| Tests qui doivent être reproductibles | Un identifiant de modèle fixe | Le même modèle à chaque fois, mais il s'arrête à la limite de ce modèle |
Les offres gratuites n'ont pas de SLA. La latence varie au cours de la journée, et les modèles les plus performants atteignent d'abord leurs limites quotidiennes. Testez vos chaînes avec les modèles que votre chaîne utilisera réellement.
Limites de débit et nouvelles tentatives
FreeLLMAPI essaie le fournisseur suivant lorsqu'un fournisseur renvoie une erreur 429. Votre code ne voit une erreur 429 que lorsque toutes les clés de la chaîne ont atteint leur limite. La réponse contient alors un en-tête Retry-After. De nombreuses limites quotidiennes se réinitialisent à minuit UTC.
Pour les travaux par lots, ajoutez une seconde couche de nouvelles tentatives avec with_retry. Elle relance l'exécutable complet avec un délai exponentiel et une gigue.
Python : relancer une chaîne en cas de limite de débit
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},
)| Problème | Cause | Solution |
|---|---|---|
openai.AuthenticationError | Clé unifiée incorrecte | Copiez de nouveau la clé depuis la page Keys |
openai.NotFoundError à chaque appel | L'URL de base ne contient pas /v1 | Utilisez http://localhost:3001/v1 |
openai.RateLimitError | Toutes les clés de la chaîne ont atteint leur limite | Ajoutez des fournisseurs, réduisez max_concurrency ou attendez Retry-After |
| Erreur d'embedding concernant les jetons ou le type d'entrée | LangChain envoie des jetons, et non du texte | Définissez check_embedding_ctx_length=False |
tool_calls est vide | Le modèle ne prend pas en charge les outils | Utilisez un modèle du tableau des outils, ou un profil d'outils |
| Le texte de raisonnement est absent | ChatOpenAI ne conserve que les champs OpenAI standard | Lisez la réponse dans content ; les champs supplémentaires des fournisseurs ne sont pas conservés |
Questions fréquentes
Puis-je utiliser une API LLM gratuite avec LangChain ?
Oui. Toute API compatible OpenAI fonctionne avec ChatOpenAI. Définissez base_url sur http://localhost:3001/v1 et api_key sur votre clé unifiée FreeLLMAPI. Le routeur utilise les offres gratuites des fournisseurs.
Comment définir une URL de base personnalisée dans ChatOpenAI de LangChain ?
En Python, transmettez base_url à ChatOpenAI. En JavaScript, transmettez configuration: { baseURL } au constructeur. La variable d'environnement OPENAI_BASE_URL fonctionne aussi en Python.
Les agents LangChain fonctionnent-ils avec des modèles gratuits ?
Oui, si le modèle prend en charge l'appel d'outils. Utilisez create_agent avec un modèle ChatOpenAI, et gardez les modèles qui appellent des outils dans votre chaîne FreeLLMAPI.
Pourquoi OpenAIEmbeddings échoue-t-il avec un fournisseur autre qu'OpenAI ?
Par défaut, il envoie des identifiants de jetons. La plupart des autres fournisseurs attendent du texte brut. Définissez check_embedding_ctx_length=False en Python.
Comment gérer les erreurs 429 dans LangChain ?
Définissez max_retries sur ChatOpenAI, et ajoutez with_retry à la chaîne pour les travaux par lots. FreeLLMAPI passe déjà au fournisseur suivant avant que votre code ne voie une erreur 429.
Guides associés
- LLM gratuit pour LlamaIndex
- API LLM gratuite en Python
- API LLM gratuite pour RAG
- API d'embeddings gratuite
- API LLM gratuite avec appel de fonctions
- API LLM gratuite pour agents IA
Sources
- LangChain docs: ChatOpenAI integration (Python) (vérifié le 20 November 2026)
- LangChain docs: ChatOpenAI integration (JavaScript) (vérifié le 20 November 2026)
- LangChain docs: agents and create_agent (vérifié le 20 November 2026)
- LangChain source: OpenAIEmbeddings note on OpenAI-compatible APIs (vérifié le 20 November 2026)
- OpenAI Python SDK: retries and errors (vérifié le 20 November 2026)
- FreeLLMAPI docs: REST API (tool calling, embeddings, response headers) (vérifié le 20 November 2026)