Accueil / Guides / API LLM gratuite pour LangChain

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 zod

Variables 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èles gratuits avec appel d'outils et 128K+ de contexte
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
GLM 5.3UnoRouter1M1 req/min
1 req/min per model
OuiNon
GLM 5.3 FlashNVIDIA NIM, UnoRouter1M40 req/min
40 RPM
OuiOui
Gemini 3.8 FlashGoogle AI Studio1MRecurring provider quotaOuiOui
Qwen3.8 Flash NextAMD Radeon Cloud262KRecurring daily account allowanceOuiNon
Qwen3.8 FlashElectronHub1M$0.25/week shared recurring creditOuiOui
Gemini 3.7 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
GPT-5.6 LunaElectronHub1M$0.25/week shared recurring creditOuiOui
Dots3 Note PreviewKilo Gateway, OpenRouter512K20 req/min
50 req/jour
50 req/day account-wide (1,000 after a $10 purchase)
OuiOui
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 req/min
50 req/jour
Shared rate limit
OuiNon
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 req/min
250 req/jour
70,000 jetons/min
~6M
OuiOui

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èleFournisseurDimensionsEntrée maxLimite gratuite
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)

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 applicationChaîne de modèleRaison
Réponses de chat pour les utilisateursautoSuit la chaîne que vous avez définie sur le tableau de bord
Agent avec outilsauto:<profile>Un profil qui ne contient que des modèles qui appellent des outils
Classification, routage, résumés courtsauto:fastClasse les modèles selon leur vitesse mesurée
Étapes de raisonnement complexesauto:smartClasse les modèles par intelligence
Tests qui doivent être reproductiblesUn identifiant de modèle fixeLe 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èmeCauseSolution
openai.AuthenticationErrorClé unifiée incorrecteCopiez de nouveau la clé depuis la page Keys
openai.NotFoundError à chaque appelL'URL de base ne contient pas /v1Utilisez http://localhost:3001/v1
openai.RateLimitErrorToutes les clés de la chaîne ont atteint leur limiteAjoutez des fournisseurs, réduisez max_concurrency ou attendez Retry-After
Erreur d'embedding concernant les jetons ou le type d'entréeLangChain envoie des jetons, et non du texteDéfinissez check_embedding_ctx_length=False
tool_calls est videLe modèle ne prend pas en charge les outilsUtilisez un modèle du tableau des outils, ou un profil d'outils
Le texte de raisonnement est absentChatOpenAI ne conserve que les champs OpenAI standardLisez la réponse dans content ; les champs supplémentaires des fournisseurs ne sont pas conservés
Utilisez chacun de ces modèles avec une seule clé. FreeLLMAPI est un routeur open source auto-hébergé. Il place toutes ces offres gratuites derrière un seul point de terminaison compatible OpenAI, et bascule vers une autre offre lorsqu'une limite de débit est atteinte. Parcourir le catalogue ou passer en production.

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

Sources

Tous les guides · Parcourir tous les modèles gratuits