LLM gratuito per LlamaIndex
LlamaIndex ha due classi per le API compatibili con OpenAI: OpenAILike per la chat e OpenAILikeEmbedding per gli embedding. Questa guida punta entrambe a FreeLLMAPI, che raccoglie 45 livelli gratuiti di provider dietro una sola chiave. Crea un indice di generazione aumentata dal recupero (RAG), lo interroga e aggiunge un agente. Il codice gestisce i limiti di frequenza.
Codice, nomi dei modelli ed etichette del catalogo in tempo reale sono mostrati in inglese.
Installi i pacchetti
Installi FreeLLMAPI e aggiunga chiavi gratuite di due o più provider nella pagina Keys della dashboard. Copi la chiave unificata. Poi installi i pacchetti di LlamaIndex.
Installazione
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>Non usi la classe semplice OpenAI da llama-index-llms-openai con nomi di modelli che OpenAI non conosce. Quella classe controlla i nomi dei modelli e le dimensioni del contesto con un elenco di modelli OpenAI. OpenAILike non lo fa, quindi questi valori li imposta Lei.
Configuri il LLM e il modello di embedding
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: senza questo valore, LlamaIndex invia le richieste all'endpoint legacy di completamento.
- context_window: LlamaIndex usa questo valore per decidere quanti blocchi recuperati entrano nel prompt. Con
auto, il router può scegliere modelli diversi. Usi la finestra di contesto più piccola della Sua catena. - is_function_calling_model=True: lo imposti solo se la Sua catena contiene modelli con chiamate di strumenti.
- embed_batch_size: ogni lotto è una richiesta. Lotti più grandi usano meno richieste al minuto.
Un prompt RAG contiene diversi blocchi recuperati, quindi il modello di chat ha bisogno di spazio per loro. Crei un profilo di catena di fallback con modelli a contesto lungo per RAG. Poi imposti model="auto:<profile>" e porti context_window alla finestra più piccola di quel profilo. Questi modelli gratuiti hanno oggi le finestre di contesto più grandi:
| Modello | Gratis su | Contesto | Limiti gratuiti (offerta migliore) | Strumenti | Visione |
|---|---|---|---|---|---|
| OpenAI: GPT-6 Luna | ElectronHub | 1.1M | $0.25/week shared free credits | No | No |
| Gemini 3.8 Flash | APINex, Google AI Studio | 1M | 5 richieste/min 10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account | Sì | Sì |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 richieste/min 50 richieste/giorno Shared rate limit | Sì | No |
| DeepSeek V4 Flash 0731 | ElectronHub, Router9 | 1M | 10,000 credits/month (~$1), shared; account-anniversary reset | No | No |
| Gemini 3.6 Flash | Google AI Studio | 1M | 10 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
| GLM-5.2 | ModelScope, Router9 | 1M | 100 richieste/giorno Daily login: 200 credits + 50 for linked Alibaba Cloud; 24h expiry; shared; noncommercial experience | No | No |
| Gemini 3.5 Flash | Google AI Studio | 1M | 10 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
Mostrati 8 di 115 modelli gratuiti corrispondenti. Vedi tutti i modelli.
Dati in tempo reale dal catalogo FreeLLMAPI (versione 2026.11.19, verificato il 2026-11-19). I limiti gratuiti cambiano spesso. Il catalogo viene verificato ogni giorno.
Per mantenere un utente sullo stesso modello, invii un'intestazione X-Session-Id. OpenAILike accetta default_headers, per esempio default_headers={"X-Session-Id": "user-42"}. FreeLLMAPI mantiene una sessione sullo stesso modello per 30 minuti. Questo dà risposte nello stesso stile durante una chat.
Crei e interroghi un indice RAG
Lo script legge i file da una cartella, calcola gli embedding, salva l'indice e risponde a una domanda. Lo esegua una volta per creare l'indice. Le esecuzioni successive caricano l'indice salvato e non calcolano di nuovo gli embedding dei file.
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 e crei di nuovo l'indice.Questi modelli di embedding sono gratuiti nel catalogo di oggi. La colonna delle dimensioni mostra la dimensione del vettore di ogni famiglia.
| Modello | Provider | Dimensioni | Input massimo | Limite gratuito |
|---|---|---|---|---|
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) |
Dati in tempo reale dal catalogo FreeLLMAPI (versione 2026.11.19, verificato il 2026-11-19). I limiti gratuiti cambiano spesso. Il catalogo viene verificato ogni giorno.
Aggiunga un agente con FunctionAgent
FunctionAgent usa le chiamate di strumenti. Gli può dare il query engine come strumento e aggiungere le Sue funzioni 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())Per il lavoro con agenti, scelga modelli con chiamate di strumenti. Crei un profilo di catena di fallback con solo questi modelli, e usi auto:<profile> come nome del modello.
| Modello | Gratis su | Contesto | Limiti gratuiti (offerta migliore) | Strumenti | Visione |
|---|---|---|---|---|---|
| GLM 5.3 | UnoRouter | 1M | 1 richieste/min 1 req/min per model | Sì | No |
| GLM 5.3 Flash | NVIDIA NIM, UnoRouter | 1M | 40 richieste/min 40 RPM | Sì | Sì |
| Gemini 3.8 Flash | Google AI Studio | 1M | Recurring provider quota | Sì | Sì |
| Qwen3.8 Flash Next | AMD Radeon Cloud | 262K | Recurring daily account allowance | Sì | No |
| Qwen3.8 Flash | ElectronHub | 1M | $0.25/week shared recurring credit | Sì | Sì |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
| GPT-5.6 Luna | ElectronHub | 1M | $0.25/week shared recurring credit | Sì | Sì |
| Dots3 Note Preview | Kilo Gateway, OpenRouter | 512K | 20 richieste/min 50 richieste/giorno 50 req/day account-wide (1,000 after a $10 purchase) | Sì | Sì |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 richieste/min 50 richieste/giorno Shared rate limit | Sì | No |
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 richieste/min 250 richieste/giorno 70,000 token/min ~6M | Sì | Sì |
Mostrati 10 di 109 modelli gratuiti corrispondenti. Vedi tutti i modelli.
Dati in tempo reale dal catalogo FreeLLMAPI (versione 2026.11.19, verificato il 2026-11-19). I limiti gratuiti cambiano spesso. Il catalogo viene verificato ogni giorno.
Mantenga l'indicizzazione nei limiti gratuiti
L'indicizzazione invia molte richieste di embedding in poco tempo. I livelli gratuiti di embedding hanno limiti bassi. Per esempio, alcuni consentono 10 richieste al minuto e altri contano le chiamate al mese. Pianifichi la prima indicizzazione prima di avviarla.
- Usi blocchi grandi. Meno blocchi significano meno vettori e meno richieste. Una dimensione del blocco vicina a 1.024 token è un buon punto di partenza.
- Usi lotti. Imposti
embed_batch_sizea 16 o più. Una sola richiesta porta così molti blocchi. - Salvi l'indice. Salvi in modo persistente l'indice dopo la prima esecuzione. Non calcoli di nuovo gli embedding degli stessi file.
- Mantenga attivi i tentativi.
OpenAILikeEmbeddingritenta fino a 10 volte per impostazione predefinita. Mantenga questo valore per i processi di indicizzazione lunghi. - Indicizzi a parti. Per migliaia di file, indicizzi una cartella alla volta.
Le query costano meno dell'indicizzazione. Ogni query usa una richiesta di embedding e una richiesta di chat. Una richiesta di chat con quattro blocchi da 1.024 token invia circa 5.000 token. I livelli gratuiti con limiti bassi di token al minuto possono rifiutarla. FreeLLMAPI allora prova il provider successivo.
Risoluzione dei problemi
| Problema | Causa | Soluzione |
|---|---|---|
Unknown model 'auto' | Ha usato la classe OpenAI | Usi OpenAILike |
Le richieste vanno a /v1/completions | is_chat_model non è impostato | Imposti is_chat_model=True |
| L'agente non chiama gli strumenti | is_function_calling_model è disattivo, oppure il modello non supporta le chiamate di strumenti | Lo imposti a True e usi un profilo con strumenti |
| Errore 429 durante l'indicizzazione | La famiglia di embedding ha raggiunto il limite su tutti i provider | Usi lotti più grandi, attenda Retry-After e riesegua |
| Risposte errate dopo un cambio del modello di embedding | Vettori di due famiglie nello stesso indice | Elimini l'indice salvato e lo crei di nuovo |
| Errore di lunghezza del contesto | context_window è più grande del modello che ha risposto | Imposti un valore più piccolo oppure usi un profilo a contesto lungo |
Per vedere quale provider ha risposto a una richiesta, usi la dashboard di FreeLLMAPI. La pagina Analytics mostra richieste, latenza ed errori per ogni provider e modello. Ogni risposta ha anche un'intestazione X-Routed-Via. Se il router ha cambiato provider, l'intestazione X-Fallback-Trail indica ogni tentativo fallito e il motivo.
Domande frequenti
Posso usare LlamaIndex con un LLM gratuito?
Sì. Usi OpenAILike con api_base impostato su un URL compatibile con OpenAI. FreeLLMAPI offre un solo URL per molti livelli gratuiti di provider. Ogni livello ha i propri limiti.
Qual è la differenza tra OpenAI e OpenAILike in LlamaIndex?
La classe OpenAI controlla i nomi dei modelli rispetto ai modelli OpenAI. OpenAILike accetta qualsiasi nome di modello. Lei imposta da solo la finestra di contesto e i flag di chat e di chiamata di funzioni.
Qual è il modello di embedding gratuito migliore per LlamaIndex?
Scelga una famiglia con abbastanza richieste gratuite per la Sua indicizzazione e la mantenga per tutto l'indice. La famiglia bge-m3 è gratuita presso diversi provider, quindi il failover può passare tra loro.
FunctionAgent funziona con modelli gratuiti?
Sì, se il modello supporta le chiamate di strumenti e Lei imposta is_function_calling_model=True. Usi un profilo di catena di fallback che contenga solo modelli con chiamate di strumenti.
Come evito i limiti di frequenza quando creo un indice LlamaIndex?
Usi blocchi grandi, imposti embed_batch_size a 16 o più, salvi in modo persistente l'indice e indicizzi le cartelle grandi a parti.
Guide correlate
- API LLM gratuita per RAG
- API gratuita per embedding
- API LLM gratuita per LangChain
- API LLM gratuita in Python
- API LLM gratuita con contesto da 1 milione di token
Fonti
- LlamaIndex: llama-index-llms-openai-like README (verificato il 20 November 2026)
- LlamaIndex: llama-index-embeddings-openai-like source (verificato il 20 November 2026)
- LlamaIndex: FunctionAgent (agent workflow) source (verificato il 20 November 2026)
- FreeLLMAPI docs: REST API (embeddings families, routing strategies) (verificato il 20 November 2026)