LLM gratuit pour LlamaIndex
LlamaIndex dispose de deux classes pour les API compatibles OpenAI : OpenAILike pour le chat et OpenAILikeEmbedding pour les embeddings. Ce guide dirige les deux vers FreeLLMAPI, qui regroupe les offres gratuites de 45 fournisseurs derrière une seule clé. Vous créez un index de génération augmentée par récupération (RAG), vous l'interrogez et vous ajoutez un agent. Le code 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.
Installer les paquets
Installez FreeLLMAPI et ajoutez des clés gratuites d'au moins deux fournisseurs sur la page Keys du tableau de bord. Copiez la clé unifiée. Installez ensuite les paquets LlamaIndex.
Installer
curl -fsSL https://freellmapi.co/install.sh | bash
pip install -U llama-index-core \
llama-index-llms-openai-like \
llama-index-embeddings-openai-like
export FREELLMAPI_BASE_URL=http://localhost:3001/v1
export FREELLMAPI_API_KEY=<unified-key>N'utilisez pas la classe simple OpenAI de llama-index-llms-openai avec des noms de modèles que OpenAI ne connaît pas. Cette classe vérifie les noms de modèles et les tailles de contexte par rapport à une liste de modèles OpenAI. OpenAILike ne le fait pas, donc vous définissez ces valeurs vous-même.
Configurer le LLM et le modèle d'embeddings
settings.py
import os
from llama_index.core import Settings
from llama_index.llms.openai_like import OpenAILike
from llama_index.embeddings.openai_like import OpenAILikeEmbedding
BASE = os.environ["FREELLMAPI_BASE_URL"]
KEY = os.environ["FREELLMAPI_API_KEY"]
Settings.llm = OpenAILike(
model="auto",
api_base=BASE,
api_key=KEY,
is_chat_model=True, # use /v1/chat/completions
is_function_calling_model=True, # needed for FunctionAgent
context_window=32000, # the smallest window in your chain
max_retries=5,
timeout=90,
)
Settings.embed_model = OpenAILikeEmbedding(
model_name="bge-m3", # one family, 1024 dimensions
api_base=BASE,
api_key=KEY,
embed_batch_size=16,
max_retries=10,
)- is_chat_model=True : sans cette valeur, LlamaIndex envoie les requêtes au point de terminaison de complétion historique.
- context_window : LlamaIndex utilise cette valeur pour décider combien de segments récupérés tiennent dans l'invite. Avec
auto, le routeur peut choisir des modèles différents. Utilisez la plus petite fenêtre de contexte de votre chaîne. - is_function_calling_model=True : ne le définissez que lorsque votre chaîne contient des modèles à appel d'outils.
- embed_batch_size : chaque lot correspond à une requête. Des lots plus grands utilisent moins de requêtes par minute.
Une invite RAG transporte plusieurs segments récupérés, donc le modèle de chat a besoin de place pour eux. Créez un profil de chaîne de repli avec des modèles à long contexte pour le RAG. Définissez ensuite model="auto:<profile>" et augmentez context_window jusqu'à la plus petite fenêtre de ce profil. Ces modèles gratuits ont aujourd'hui les plus grandes fenêtres de contexte :
| Modèle | Gratuit sur | Contexte | Limites gratuites (meilleure offre) | Outils | Vision |
|---|---|---|---|---|---|
| OpenAI: GPT-6 Luna | ElectronHub | 1.1M | $0.25/week shared free credits | Non | Non |
| Gemini 3.8 Flash | APINex, Google AI Studio | 1M | 5 req/min 10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account | Oui | Oui |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 req/min 50 req/jour Shared rate limit | Oui | Non |
| DeepSeek V4 Flash 0731 | ElectronHub, Router9 | 1M | 10,000 credits/month (~$1), shared; account-anniversary reset | Non | Non |
| Gemini 3.6 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
| GLM-5.2 | ModelScope, Router9 | 1M | 100 req/jour Daily login: 200 credits + 50 for linked Alibaba Cloud; 24h expiry; shared; noncommercial experience | Non | Non |
| Gemini 3.5 Flash | Google AI Studio | 1M | 10 req/min 20 req/jour 250,000 jetons/min ~3M | Oui | Oui |
Affichage de 8 modèles gratuits sur 115 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.
Pour garder un utilisateur sur un même modèle, envoyez un en-tête X-Session-Id. OpenAILike accepte default_headers, par exemple default_headers={"X-Session-Id": "user-42"}. FreeLLMAPI garde une session sur le même modèle pendant 30 minutes. Les réponses gardent ainsi le même style tout au long d'une conversation.
Créer et interroger un index RAG
Le script lit les fichiers d'un dossier, calcule les embeddings, enregistre l'index et répond à une question. Lancez-le une fois pour créer l'index. Les exécutions suivantes chargent l'index enregistré et ne recalculent pas les embeddings des fichiers.
rag.py
import os
import settings # noqa: F401 (sets Settings.llm and Settings.embed_model)
from llama_index.core import (
SimpleDirectoryReader,
StorageContext,
VectorStoreIndex,
load_index_from_storage,
)
PERSIST = "./storage"
def load_index() -> VectorStoreIndex:
if os.path.isdir(PERSIST):
return load_index_from_storage(StorageContext.from_defaults(persist_dir=PERSIST))
docs = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(docs, show_progress=True)
index.storage_context.persist(persist_dir=PERSIST)
return index
if __name__ == "__main__":
query_engine = load_index().as_query_engine(similarity_top_k=4, streaming=True)
response = query_engine.query("How do I rotate the API keys?")
response.print_response_stream()
for node in response.source_nodes:
print("\nSource:", node.metadata.get("file_name"), round(node.score or 0, 3))./storage et recréez l'index.Ces modèles d'embeddings sont gratuits dans le catalogue du jour. La colonne des dimensions indique la taille du vecteur de chaque famille.
| 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.
Ajouter un agent avec FunctionAgent
FunctionAgent utilise l'appel d'outils. Vous pouvez lui donner le moteur de requête comme outil et ajouter vos propres fonctions Python.
agent.py
import asyncio
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.core.tools import QueryEngineTool
from llama_index.core import Settings
from rag import load_index
docs_tool = QueryEngineTool.from_defaults(
query_engine=load_index().as_query_engine(similarity_top_k=4),
name="project_docs",
description="Answers questions about the project documentation.",
)
def open_tickets(team: str) -> int:
"""Return the number of open tickets for a team."""
return {"billing": 4, "platform": 11}.get(team, 0)
agent = FunctionAgent(
tools=[docs_tool, open_tickets],
llm=Settings.llm,
system_prompt="Use the tools. Cite the document name in each answer.",
)
async def main():
result = await agent.run("How many platform tickets are open, and how do we rotate keys?")
print(result)
asyncio.run(main())Pour le travail d'agent, sélectionnez des modèles avec appel d'outils. Créez un profil de chaîne de repli avec seulement ces modèles, et utilisez auto:<profile> comme nom de modèle.
| 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.
Rester dans les limites gratuites pendant l'ingestion
L'ingestion envoie de nombreuses requêtes d'embeddings en peu de temps. Les offres gratuites d'embeddings ont des limites faibles. Par exemple, certaines autorisent 10 requêtes par minute, et d'autres comptent les appels par mois. Planifiez la première ingestion avant de la lancer.
- Utilisez de gros segments. Moins de segments signifient moins de vecteurs et moins de requêtes. Une taille de segment proche de 1 024 jetons est un bon point de départ.
- Utilisez des lots. Réglez
embed_batch_sizesur 16 ou plus. Une seule requête transporte alors de nombreux segments. - Enregistrez l'index. Conservez l'index après la première exécution. Ne recalculez pas les embeddings des mêmes fichiers.
- Gardez les nouvelles tentatives activées.
OpenAILikeEmbeddingrelance jusqu'à 10 fois par défaut. Conservez cette valeur pour les longues tâches d'ingestion. - Ingérez par parties. Pour des milliers de fichiers, ingérez un dossier à la fois.
Les requêtes coûtent moins cher que l'ingestion. Chaque requête utilise une requête d'embeddings et une requête de chat. Une requête de chat avec quatre segments de 1 024 jetons envoie environ 5 000 jetons. Les offres gratuites à faible limite de jetons par minute peuvent la refuser. FreeLLMAPI essaie alors le fournisseur suivant.
Dépannage
| Problème | Cause | Solution |
|---|---|---|
Unknown model 'auto' | Vous avez utilisé la classe OpenAI | Utilisez OpenAILike |
Les requêtes vont vers /v1/completions | is_chat_model n'est pas défini | Définissez is_chat_model=True |
| L'agent n'appelle pas d'outils | is_function_calling_model est désactivé, ou le modèle ne prend pas en charge l'appel d'outils | Définissez-le sur True et utilisez un profil d'outils |
| Erreur 429 pendant l'ingestion | La famille d'embeddings a atteint sa limite chez tous les fournisseurs | Utilisez des lots plus grands, attendez Retry-After et relancez |
| Mauvaises réponses après un changement de modèle d'embeddings | Vecteurs de deux familles dans un même index | Supprimez l'index enregistré et recréez-le |
| Erreur de longueur de contexte | context_window est plus grand que le modèle qui a répondu | Définissez une valeur plus petite ou utilisez un profil à long contexte |
Pour voir quel fournisseur a répondu à une requête, utilisez le tableau de bord FreeLLMAPI. La page Analytics affiche les requêtes, la latence et les erreurs pour chaque fournisseur et chaque modèle. Chaque réponse a aussi un en-tête X-Routed-Via. Si le routeur a changé de fournisseur, l'en-tête X-Fallback-Trail nomme chaque tentative échouée et sa raison.
Questions fréquentes
Puis-je utiliser LlamaIndex avec un LLM gratuit ?
Oui. Utilisez OpenAILike avec api_base défini sur une URL compatible OpenAI. FreeLLMAPI fournit une seule URL pour de nombreuses offres gratuites. Chaque offre a ses propres limites.
Quelle est la différence entre OpenAI et OpenAILike dans LlamaIndex ?
La classe OpenAI vérifie les noms de modèles par rapport aux modèles OpenAI. OpenAILike accepte n'importe quel nom de modèle. Vous définissez vous-même la fenêtre de contexte et les indicateurs de chat et d'appel de fonctions.
Quel modèle d'embeddings gratuit est le meilleur pour LlamaIndex ?
Choisissez une famille avec assez de requêtes gratuites pour votre ingestion, et gardez-la pour tout l'index. La famille bge-m3 est gratuite chez plusieurs fournisseurs, donc le basculement peut passer de l'un à l'autre.
FunctionAgent fonctionne-t-il avec des modèles gratuits ?
Oui, si le modèle prend en charge l'appel d'outils et que vous définissez is_function_calling_model=True. Utilisez un profil de chaîne de repli qui ne contient que des modèles à appel d'outils.
Comment éviter les limites de débit lors de la création d'un index LlamaIndex ?
Utilisez de gros segments, réglez embed_batch_size sur 16 ou plus, enregistrez l'index et ingérez les grands dossiers par parties.
Guides associés
- API LLM gratuite pour RAG
- API d'embeddings gratuite
- API LLM gratuite pour LangChain
- API LLM gratuite en Python
- API LLM gratuite avec un contexte d'un million de tokens
Sources
- LlamaIndex: llama-index-llms-openai-like README (vérifié le 20 November 2026)
- LlamaIndex: llama-index-embeddings-openai-like source (vérifié le 20 November 2026)
- LlamaIndex: FunctionAgent (agent workflow) source (vérifié le 20 November 2026)
- FreeLLMAPI docs: REST API (embeddings families, routing strategies) (vérifié le 20 November 2026)