Accueil / Guides / LLM gratuit pour LlamaIndex

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èles gratuits avec les plus grandes fenêtres de contexte
ModèleGratuit surContexteLimites gratuites (meilleure offre)OutilsVision
OpenAI: GPT-6 LunaElectronHub1.1M$0.25/week shared free creditsNonNon
Gemini 3.8 FlashAPINex, Google AI Studio1M5 req/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
OuiOui
Gemini 3.7 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 req/min
50 req/jour
Shared rate limit
OuiNon
DeepSeek V4 Flash 0731ElectronHub, Router91M10,000 credits/month (~$1), shared; account-anniversary resetNonNon
Gemini 3.6 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui
GLM-5.2ModelScope, Router91M100 req/jour
Daily login: 200 credits + 50 for linked Alibaba Cloud; 24h expiry; shared; noncommercial experience
NonNon
Gemini 3.5 FlashGoogle AI Studio1M10 req/min
20 req/jour
250,000 jetons/min
~3M
OuiOui

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))
Important : gardez une seule famille d'embeddings pour tout l'index. FreeLLMAPI ne change jamais de modèle d'embeddings pendant un basculement. Il passe seulement entre les fournisseurs qui servent la même famille. Si vous changez de famille, supprimez ./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è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.

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èles gratuits avec appel d'outils et contexte de 128K+
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.

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_size sur 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. OpenAILikeEmbedding relance 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èmeCauseSolution
Unknown model 'auto'Vous avez utilisé la classe OpenAIUtilisez OpenAILike
Les requêtes vont vers /v1/completionsis_chat_model n'est pas définiDéfinissez is_chat_model=True
L'agent n'appelle pas d'outilsis_function_calling_model est désactivé, ou le modèle ne prend pas en charge l'appel d'outilsDéfinissez-le sur True et utilisez un profil d'outils
Erreur 429 pendant l'ingestionLa famille d'embeddings a atteint sa limite chez tous les fournisseursUtilisez des lots plus grands, attendez Retry-After et relancez
Mauvaises réponses après un changement de modèle d'embeddingsVecteurs de deux familles dans un même indexSupprimez l'index enregistré et recréez-le
Erreur de longueur de contextecontext_window est plus grand que le modèle qui a réponduDé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.

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 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

Sources

Tous les guides · Parcourir tous les modèles gratuits