Home / Guide / API LLM gratuita per RAG

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

PassoAPIAspetto da considerare sul piano gratuito
1. Dividi i documenti in blocchiNessuna (codice locale)Nessuno
2. Crea l'embedding di ogni blocco/v1/embeddingsMolte richieste all'inizio. Alcuni piani gratuiti di embedding consentono 10 richieste al minuto.
3. Crea l'embedding della domanda/v1/embeddingsUna richiesta per domanda
4. Trova i blocchi miglioriNessuna (ricerca vettoriale locale)Nessuno
5. Riordina i blocchi (facoltativo)/v1/chat/completionsUna richiesta di chat in più per domanda
6. Scrivi la risposta/v1/chat/completionsPrompt 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.

ModelloProviderDimensioniInput massimoLimite gratuito
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)

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.

Modelli gratuiti con le finestre di contesto più grandi
ModelloGratis suContestoLimiti gratuiti (offerta migliore)StrumentiVisione
OpenAI: GPT-6 LunaElectronHub1.1M$0.25/week shared free creditsNoNo
Gemini 3.8 FlashAPINex, Google AI Studio1M5 richieste/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
SìSì
Gemini 3.7 FlashGoogle AI Studio1M10 richieste/min
20 richieste/giorno
250,000 token/min
~3M
SìSì
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 richieste/min
50 richieste/giorno
Shared rate limit
SìNo
DeepSeek V4 Flash 0731ElectronHub, Router91M10,000 credits/month (~$1), shared; account-anniversary resetNoNo
Gemini 3.6 FlashGoogle AI Studio1M10 richieste/min
20 richieste/giorno
250,000 token/min
~3M
SìSì
GLM 5.2Router91M10,000 credits/month (~$1), shared; account-anniversary resetNoNo
Gemini 3.5 FlashGoogle AI Studio1M10 richieste/min
20 richieste/giorno
250,000 token/min
~3M
SìSì
DeepSeek V4 ProAPINex, Router91M5 richieste/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
NoNo
Nemotron 3 Ultra 550BGizmo, Kilo Gateway, LLMTR +3 altri1M200 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

ProblemaCausaSoluzione
L'indicizzazione si blocca con 429La famiglia di embedding ha raggiunto il limite su tutti i providerUsa lotti più grandi, attendi Retry-After, indicizza a parti
Risultati scarsi dopo una modificaL'indice contiene vettori di due famiglieCrea di nuovo l'embedding di tutti i blocchi con una sola famiglia
Errore sulla lunghezza dell'inputUn blocco è più lungo dell'input massimo della famigliaUsa blocchi più piccoli
La risposta ignora le fontiIl modello risponde con la sua conoscenzaUsa temperature=0 e un prompt di sistema rigoroso
Errore di lunghezza del contesto nella rispostaTroppi blocchi, o blocchi troppo lunghiRiduci k oppure usa un profilo a contesto lungo
Le risposte cambiano stileIl router ha scelto un altro modelloInvia 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.

Usa ognuno di questi modelli con una sola chiave. FreeLLMAPI è un router open source self-hosted che mette tutti questi piani gratuiti dietro un unico endpoint compatibile con OpenAI e passa al successivo quando uno raggiunge il limite di frequenza. Sfoglia il catalogo oppure inizia.

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

Fonti

Tutte le guide · Sfoglia tutti i modelli gratuiti