Acasă / Ghiduri / API LLM gratuit pentru RAG

API LLM gratuit pentru RAG

Generarea augmentată prin recuperare (RAG) are nevoie de două API-uri: un model de embeddings care găsește textul relevant și un model de chat care scrie răspunsul. Ambele sunt disponibile pe niveluri gratuite. FreeLLMAPI oferă o singură cheie compatibilă cu OpenAI pentru 41 modele gratuite de embeddings și 487 modele gratuite de chat, cu rezervă între furnizori. Acest ghid arată modelele gratuite pentru fiecare pas și un flux complet în Python.

Codul, numele modelelor și etichetele live din catalog sunt afișate în engleză.

Fluxul RAG pe niveluri gratuite

PasAPIProblema nivelului gratuit
1. Împărțiți documentele în fragmenteNiciunul (cod local)Nu există
2. Transformați în embeddings fiecare fragment/v1/embeddingsMulte cereri la început. Unele niveluri gratuite de embeddings permit 10 cereri pe minut.
3. Transformați în embedding întrebarea/v1/embeddingsO cerere pentru fiecare întrebare
4. Găsiți cele mai bune fragmenteNiciunul (căutare vectorială locală)Nu există
5. Reordonați fragmentele (opțional)/v1/chat/completionsO cerere de chat în plus pentru fiecare întrebare
6. Scrieți răspunsul/v1/chat/completionsPrompturi mari. Se aplică limitele de tokeni pe minut.

Pasul 2 este cel mai costisitor. Îl faceți o dată pentru fiecare document. Salvați vectorii și transformați ulterior în embeddings doar documentele noi sau modificate.

Instalați FreeLLMAPI și pachetele Python

curl -fsSL https://freellmapi.co/install.sh | bash

python3 -m pip install -U openai numpy
export FREELLMAPI_API_KEY=<unified-key>

Alegeți un model gratuit de embeddings

Alegeți o singură familie de embeddings și păstrați-o pentru tot indexul. Vectorii de la două modele nu sunt compatibili. FreeLLMAPI vă protejează de vectorii amestecați: rezerva de embeddings nu schimbă niciodată modelul. Trece doar între furnizorii care servesc aceeași familie.

ModelFurnizorDimensiuniIntrare maximăLimită gratuită
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)

Date live din catalogul FreeLLMAPI (versiunea 2026.11.19, verificat 2026-11-19). Limitele gratuite se schimbă des. Catalogul este verificat în fiecare zi.

  • Mai mulți furnizori pentru o familie: o familie precum bge-m3 este gratuită la mai mulți furnizori. Rezerva are atunci unde să meargă.
  • Intrare maximă: fragmentele mai lungi decât intrarea maximă sunt tăiate sau respinse. Faceți fragmentele mai mici decât această valoare.
  • Limbi: pentru text care nu este în engleză, folosiți o familie multilingvă, precum bge-m3. Familiile cu -en- în nume sunt pentru engleză.
  • Dimensiuni: vectorii mai mari folosesc mai mult spațiu de stocare. Pentru un index mic, aceasta nu este o problemă.

Cod RAG complet în Python

Scriptul împarte fișierele text în fragmente, le transformă în embeddings pe loturi și salvează vectorii cu NumPy. Apoi răspunde la o întrebare cu cele mai bune fragmente și oferă sursele. Reîncearcă atunci când o limită oprește o cerere.

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?"))

Pentru mai mult de câteva mii de fragmente, înlocuiți căutarea NumPy cu o bază de date vectorială. Apelurile de embeddings și de chat rămân aceleași.

Utilizatorii pun adesea aceeași întrebare din nou. FreeLLMAPI are un cache de răspunsuri opțional pentru cereri identice. Un răspuns din cache nu folosește cota furnizorului. Puteți activa sau dezactiva cache-ul pentru o cerere cu antetul X-FreeLLM-Cache: on sau off. Folosiți temperature=0, ca aceeași întrebare să dea aceeași cerere.

Adăugați un pas de reordonare

Căutarea vectorială găsește text similar, dar primul fragment nu este întotdeauna cel mai bun răspuns. Un pas de reordonare sortează din nou candidații. Documentația FreeLLMAPI nu descrie un punct final dedicat pentru reordonare. Puteți folosi un model rapid de chat ca reordonator. Recuperați 15 candidați și păstrați cei mai buni 5.

Reordonare LLM cu 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]

Pasul de reordonare adaugă o cerere de chat pentru fiecare întrebare. Dacă limitele dumneavoastră gratuite sunt strânse, săriți peste el. O segmentare mai bună ajută adesea mai mult decât un pas de reordonare.

Context lung: când nu aveți nevoie de recuperare

Astăzi, 56 oferte de modele gratuite au o fereastră de context de 1 milion de tokeni sau mai mult. Dacă documentele dumneavoastră sunt mici, le puteți trimite pe toate în prompt și puteți sări peste indexul vectorial. Este mai simplu, dar fiecare întrebare trimite atunci mulți tokeni.

Modele gratuite cu cele mai mari ferestre de context
ModelGratuit peContextLimite gratuite (cea mai bună ofertă)InstrumenteViziune
OpenAI: GPT-6 LunaElectronHub1.1M$0.25/week shared free creditsNuNu
Gemini 3.8 FlashAPINex, Google AI Studio1M5 cereri/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
DaDa
Gemini 3.7 FlashGoogle AI Studio1M10 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 cereri/min
50 cereri/zi
Shared rate limit
DaNu
DeepSeek V4 Flash 0731ElectronHub, Router91M10,000 credits/month (~$1), shared; account-anniversary resetNuNu
Gemini 3.6 FlashGoogle AI Studio1M10 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa
GLM 5.2Router91M10,000 credits/month (~$1), shared; account-anniversary resetNuNu
Gemini 3.5 FlashGoogle AI Studio1M10 cereri/min
20 cereri/zi
250,000 tokeni/min
~3M
DaDa
DeepSeek V4 ProAPINex, Router91M5 cereri/min
10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account
NuNu
Nemotron 3 Ultra 550BGizmo, Kilo Gateway, LLMTR +3 în plus1M200 cereri/zi
200 rpd
DaNu

Se afișează 10 din 35 modele gratuite care se potrivesc. Vezi toate modelele.

Date live din catalogul FreeLLMAPI (versiunea 2026.11.19, verificat 2026-11-19). Limitele gratuite se schimbă des. Catalogul este verificat în fiecare zi.

  • Folosiți context lung pentru câteva documente, pentru întrebări care au nevoie de textul complet sau pentru un singur raport.
  • Folosiți recuperarea pentru multe documente, pentru întrebări frecvente sau când limitele gratuite de tokeni pe minut sunt mici.
  • Combinați-le: recuperați 20 sau mai multe fragmente și trimiteți-le unui model cu context lung.

Un prompt mare poate eșua la un furnizor cu o limită mică de tokeni pe minut. FreeLLMAPI încearcă atunci următorul furnizor. Ca să controlați ce modele primesc prompturi mari, creați un profil de lanț de rezervă doar cu modele cu context lung. Folosiți-l ca auto:<profile>.

Limite și depanare

ProblemăCauzăRemediere
Ingestia se oprește cu 429Familia de embeddings este la limită la toți furnizoriiFolosiți loturi mai mari, așteptați Retry-After, ingerați în părți
Rezultate slabe după o schimbareIndexul are vectori din două familiiTransformați din nou în embeddings toate fragmentele, cu o singură familie
Eroare despre lungimea intrăriiUn fragment este mai lung decât intrarea maximă a familieiFolosiți fragmente mai mici
Răspunsul ignoră surseleModelul răspunde din cunoștințele saleFolosiți temperature=0 și un prompt de sistem strict
Eroare de lungime a contextului la răspunsPrea multe fragmente sau fragmente prea lungiMicșorați k sau folosiți un profil cu context lung
Răspunsurile își schimbă stilulRouterul a selectat alt modelTrimiteți un antet X-Session-Id sau fixați un model

Nivelurile gratuite nu au SLA. Cele mai puternice modele ating primele limitele zilnice, iar multe limite se resetează la miezul nopții UTC. Testați fluxul cu modelele pe care le va folosi efectiv lanțul dumneavoastră.

Folosiți fiecare dintre aceste modele printr-o singură cheie. FreeLLMAPI este un router open-source, găzduit de dumneavoastră, care pune toate aceste niveluri gratuite în spatele unui singur endpoint compatibil cu OpenAI și trece la alt furnizor când un furnizor este limitat la rată. Vezi catalogul sau trece live.

Întrebări frecvente

Există un API gratuit pentru RAG?

Da. Mai mulți furnizori au niveluri gratuite de embeddings și de chat. FreeLLMAPI servește ambele printr-o singură cheie compatibilă cu OpenAI, cu rezervă între furnizori.

Care model gratuit de embeddings este cel mai bun pentru RAG?

Alegeți o familie care este gratuită la mai mulți furnizori și se potrivește limbilor dumneavoastră. Pentru text multilingv, bge-m3 este o alegere frecventă. Păstrați o singură familie pentru tot indexul.

Există un API gratuit pentru reordonare?

Documentația FreeLLMAPI nu descrie un punct final de reordonare. Puteți reordona cu un model rapid de chat, așa cum se arată pe această pagină, sau puteți sări peste pasul de reordonare.

Am nevoie de RAG dacă un model gratuit are 1 milion de tokeni de context?

Nu pentru câteva documente mici. Pentru multe documente sau întrebări frecvente, recuperarea trimite mai puțini tokeni pe cerere și rămâne în limitele gratuite.

Pot schimba mai târziu modelul de embeddings?

Da, dar trebuie să transformați din nou în embeddings toate fragmentele. Vectorii de la două modele nu sunt compatibili, deci nu îi amestecați într-un singur index.

Ghiduri înrudite

Surse

Toate ghidurile · Vezi toate modelele gratuite