API LLM gratuita per RAG
La retrieval-augmented generation (RAG) richiede due API: un modello di embedding per trovare il testo pertinente, e un modello di chat per scrivere la risposta. Entrambi sono disponibili sui piani gratuiti. FreeLLMAPI fornisce una sola chiave compatibile con OpenAI per 41 modelli di embedding gratuiti e 487 modelli di chat gratuiti, con failover tra provider. Questa guida mostra i modelli gratuiti per ogni passo e una pipeline Python completa.
Codice, nomi dei modelli ed etichette del catalogo in tempo reale sono mostrati in inglese.
La pipeline RAG sui piani gratuiti
| Passo | API | Aspetto da considerare sul piano gratuito |
|---|---|---|
| 1. Dividi i documenti in blocchi | Nessuna (codice locale) | Nessuno |
| 2. Crea l'embedding di ogni blocco | /v1/embeddings | Molte richieste all'inizio. Alcuni piani gratuiti di embedding consentono 10 richieste al minuto. |
| 3. Crea l'embedding della domanda | /v1/embeddings | Una richiesta per domanda |
| 4. Trova i blocchi migliori | Nessuna (ricerca vettoriale locale) | Nessuno |
| 5. Riordina i blocchi (facoltativo) | /v1/chat/completions | Una richiesta di chat in più per domanda |
| 6. Scrivi la risposta | /v1/chat/completions | Prompt grandi. Si applicano i limiti di token al minuto. |
Il passo 2 è quello più costoso. Lo fai una volta per ogni documento. Salva i vettori e, in seguito, crea l'embedding solo dei documenti nuovi o modificati.
Installa FreeLLMAPI e i pacchetti Python
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai numpy
export FREELLMAPI_API_KEY=<unified-key>Scegli un modello di embedding gratuito
Scegli una famiglia di embedding e mantienila per tutto l'indice. I vettori di due modelli non sono compatibili. FreeLLMAPI ti protegge dai vettori misti: il failover degli embedding non cambia mai il modello. Si sposta solo tra provider che offrono la stessa 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.
- Più provider per una famiglia: una famiglia come
bge-m3è gratuita su più di un provider. Così il failover ha una destinazione. - Input massimo: i blocchi più lunghi dell'input massimo vengono tagliati o rifiutati. Rendi i blocchi più piccoli di questo valore.
- Lingue: per testi non inglesi, usa una famiglia multilingua come
bge-m3. Le famiglie con-en-nel nome sono per l'inglese. - Dimensioni: vettori più grandi occupano più spazio. Per un indice piccolo, questo non è un problema.
Codice RAG completo in Python
Lo script divide i file di testo in blocchi, crea gli embedding a lotti e salva i vettori con NumPy. Poi risponde a una domanda con i blocchi migliori e indica le fonti. Riprova quando un limite blocca una richiesta.
rag.py
import json
import os
import pathlib
import time
import numpy as np
import openai
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=3,
timeout=90,
)
EMBED_MODEL = "bge-m3" # keep one family for the whole index
CHAT_MODEL = "auto" # or a long-context profile: auto:<profile>
INDEX = pathlib.Path("index")
def with_retry(fn, *args, **kwargs):
for attempt in range(6):
try:
return fn(*args, **kwargs)
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
time.sleep(min(int(header) if header.isdigit() else 2 ** attempt, 120))
raise RuntimeError("Rate limited on every provider")
def chunk(text: str, size: int = 1500, overlap: int = 200) -> list[str]:
step = size - overlap
return [text[i:i + size] for i in range(0, max(len(text), 1), step)]
def embed(texts: list[str], batch: int = 32) -> np.ndarray:
out = []
for i in range(0, len(texts), batch):
resp = with_retry(client.embeddings.create, model=EMBED_MODEL, input=texts[i:i + batch])
out.extend(d.embedding for d in resp.data)
vecs = np.array(out, dtype=np.float32)
return vecs / np.linalg.norm(vecs, axis=1, keepdims=True)
def build(folder: str) -> None:
chunks = []
for path in sorted(pathlib.Path(folder).rglob("*.md")):
for part in chunk(path.read_text(encoding="utf-8")):
if part.strip():
chunks.append({"source": str(path), "text": part})
INDEX.mkdir(exist_ok=True)
np.save(INDEX / "vectors.npy", embed([c["text"] for c in chunks]))
(INDEX / "chunks.json").write_text(json.dumps(chunks))
def answer(question: str, k: int = 5) -> str:
vecs = np.load(INDEX / "vectors.npy")
chunks = json.loads((INDEX / "chunks.json").read_text())
q = embed([question])[0]
top = np.argsort(vecs @ q)[::-1][:k]
context = "\n\n".join(f"[{n + 1}] ({chunks[i]['source']})\n{chunks[i]['text']}" for n, i in enumerate(top))
resp = with_retry(
client.chat.completions.create,
model=CHAT_MODEL,
temperature=0,
messages=[
{"role": "system", "content": "Answer only from the sources. Cite them as [1], [2]. If the sources do not answer, say so."},
{"role": "user", "content": f"Sources:\n{context}\n\nQuestion: {question}"},
],
)
return resp.choices[0].message.content
if __name__ == "__main__":
if not (INDEX / "vectors.npy").exists():
build("docs")
print(answer("How do I rotate the API keys?"))Per più di qualche migliaio di blocchi, sostituisci la ricerca NumPy con un database vettoriale. Le chiamate di embedding e di chat restano le stesse.
Gli utenti spesso ripetono la stessa domanda. FreeLLMAPI ha una cache delle risposte attivabile per richieste identiche. Un riscontro in cache non usa quota del provider. Puoi attivare o disattivare la cache per una richiesta con l'intestazione X-FreeLLM-Cache: on oppure off. Usa temperature=0, così la stessa domanda produce la stessa richiesta.
Aggiungi un passo di rerank
La ricerca vettoriale trova testo simile, ma il blocco migliore non è sempre la risposta migliore. Un passo di rerank riordina di nuovo i candidati. La documentazione di FreeLLMAPI non descrive un endpoint dedicato al rerank. Puoi usare un modello di chat veloce come reranker. Recupera 15 candidati e tieni i migliori 5.
Rerank con LLM tramite auto:fast
def rerank(question: str, candidates: list[str], keep: int = 5) -> list[int]:
listing = "\n".join(f"{n}: {c[:400]}" for n, c in enumerate(candidates))
resp = with_retry(
client.chat.completions.create,
model="auto:fast",
temperature=0,
messages=[{
"role": "user",
"content": (
f"Question: {question}\n\nPassages:\n{listing}\n\n"
f"Return the numbers of the {keep} most useful passages, best first, "
"as a JSON list of integers. Return only the list."
),
}],
)
try:
ids = json.loads(resp.choices[0].message.content.strip())
return [i for i in ids if isinstance(i, int) and 0 <= i < len(candidates)][:keep]
except (json.JSONDecodeError, AttributeError):
return list(range(min(keep, len(candidates)))) # fall back to vector order
# Use it in answer(): take 15 candidates, keep the best 5
# top = np.argsort(vecs @ q)[::-1][:15]
# best = rerank(question, [chunks[i]["text"] for i in top])
# top = [top[i] for i in best]Il passo di rerank aggiunge una richiesta di chat per domanda. Se i tuoi limiti gratuiti sono stretti, saltalo. Una suddivisione migliore in blocchi spesso aiuta più di un passo di rerank.
Contesto lungo: quando non serve il retrieval
Oggi, 56 offerte di modelli gratuiti hanno una finestra di contesto di 1 milione di token o più. Se i tuoi documenti sono piccoli, puoi inviarli tutti nel prompt e saltare l'indice vettoriale. È più semplice, ma ogni domanda invia molti token.
| 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 | Router9 | 1M | 10,000 credits/month (~$1), shared; account-anniversary reset | No | No |
| Gemini 3.5 Flash | Google AI Studio | 1M | 10 richieste/min 20 richieste/giorno 250,000 token/min ~3M | Sì | Sì |
| DeepSeek V4 Pro | APINex, Router9 | 1M | 5 richieste/min 10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account | No | No |
| Nemotron 3 Ultra 550B | Gizmo, Kilo Gateway, LLMTR +3 altri | 1M | 200 richieste/giorno 200 rpd | Sì | No |
Mostrati 10 di 35 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.
- Usa il contesto lungo per pochi documenti, per domande che richiedono il testo completo, o per un singolo report.
- Usa il retrieval per molti documenti, per domande frequenti, o quando i limiti gratuiti di token al minuto sono bassi.
- Combinali: recupera 20 o più blocchi e inviali a un modello a contesto lungo.
Un prompt grande può fallire su un provider con un basso limite di token al minuto. FreeLLMAPI prova allora il provider successivo. Per controllare quali modelli ricevono prompt grandi, crea un profilo di catena di fallback con solo modelli a contesto lungo. Usalo come auto:<profile>.
Limiti e risoluzione dei problemi
| Problema | Causa | Soluzione |
|---|---|---|
| L'indicizzazione si blocca con 429 | La famiglia di embedding ha raggiunto il limite su tutti i provider | Usa lotti più grandi, attendi Retry-After, indicizza a parti |
| Risultati scarsi dopo una modifica | L'indice contiene vettori di due famiglie | Crea di nuovo l'embedding di tutti i blocchi con una sola famiglia |
| Errore sulla lunghezza dell'input | Un blocco è più lungo dell'input massimo della famiglia | Usa blocchi più piccoli |
| La risposta ignora le fonti | Il modello risponde con la sua conoscenza | Usa temperature=0 e un prompt di sistema rigoroso |
| Errore di lunghezza del contesto nella risposta | Troppi blocchi, o blocchi troppo lunghi | Riduci k oppure usa un profilo a contesto lungo |
| Le risposte cambiano stile | Il router ha scelto un altro modello | Invia un'intestazione X-Session-Id oppure fissa un modello |
I piani gratuiti non hanno SLA. I modelli più forti raggiungono per primi i limiti giornalieri, e molti limiti si azzerano a mezzanotte UTC. Verifica la tua pipeline con i modelli che la tua catena userà davvero.
Domande frequenti
Esiste un'API gratuita per la RAG?
Sì. Diversi provider hanno piani gratuiti di embedding e di chat. FreeLLMAPI li offre entrambi con una sola chiave compatibile con OpenAI, con failover tra provider.
Qual è il modello di embedding gratuito migliore per la RAG?
Scegli una famiglia gratuita su più provider e adatta alle tue lingue. Per testi multilingua, bge-m3 è una scelta comune. Mantieni una sola famiglia per tutto l'indice.
Esiste un'API di rerank gratuita?
La documentazione di FreeLLMAPI non descrive un endpoint di rerank. Puoi fare il rerank con un modello di chat veloce, come mostrato in questa pagina, oppure saltare il passo di rerank.
Mi serve la RAG se un modello gratuito ha 1 milione di token di contesto?
Non per pochi documenti piccoli. Per molti documenti o domande frequenti, il retrieval invia meno token per richiesta e resta entro i limiti gratuiti.
Posso cambiare il modello di embedding in seguito?
Sì, ma devi creare di nuovo l'embedding di tutti i blocchi. I vettori di due modelli non sono compatibili, quindi non mescolarli in un solo indice.
Guide correlate
- API gratuita per embedding
- API LLM gratuita con contesto da 1 milione di token
- LLM gratuito per LlamaIndex
- API LLM gratuita per LangChain
- API LLM gratuita in Python
Fonti
- FreeLLMAPI docs: embeddings (families and failover rules) (verificato il 20 November 2026)
- FreeLLMAPI docs: routing strategies and response headers (verificato il 20 November 2026)
- OpenAI Python SDK: embeddings, errors and retries (verificato il 20 November 2026)