API LLM gratuita para RAG
A geração aumentada por recuperação (RAG) precisa de duas APIs: um modelo de embedding para encontrar o texto relevante, e um modelo de chat para escrever a resposta. As duas estão disponíveis em níveis gratuitos. O FreeLLMAPI oferece uma única chave compatível com OpenAI para 41 modelos de embedding gratuitos e 487 modelos de chat gratuitos, com failover entre provedores. Este guia mostra os modelos gratuitos de cada etapa e um pipeline Python completo.
O código, os nomes dos modelos e os rótulos do catálogo ao vivo são exibidos em inglês.
O pipeline de RAG em níveis gratuitos
| Etapa | API | Ponto de atenção do nível gratuito |
|---|---|---|
| 1. Divida os documentos em trechos | Nenhuma (código local) | Nenhum |
| 2. Gere o embedding de cada trecho | /v1/embeddings | Muitas requisições no início. Alguns níveis gratuitos de embedding permitem 10 requisições por minuto. |
| 3. Gere o embedding da pergunta | /v1/embeddings | Uma requisição por pergunta |
| 4. Encontre os melhores trechos | Nenhuma (busca vetorial local) | Nenhum |
| 5. Reordene os trechos (opcional) | /v1/chat/completions | Uma requisição extra de chat por pergunta |
| 6. Escreva a resposta | /v1/chat/completions | Prompts grandes. Os limites de tokens por minuto se aplicam. |
A etapa 2 é a mais cara. Você a faz uma vez para cada documento. Salve os vetores e gere embeddings apenas dos documentos novos ou alterados depois.
Instale o FreeLLMAPI e os pacotes Python
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai numpy
export FREELLMAPI_API_KEY=<unified-key>Escolha um modelo de embedding gratuito
Escolha uma família de embedding e mantenha-a para o índice inteiro. Vetores de dois modelos não são compatíveis. O FreeLLMAPI protege você contra vetores misturados: o failover de embedding nunca troca o modelo. Ele só passa entre provedores que oferecem a mesma família.
| Modelo | Provedor | Dimensões | Entrada máx. | 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) |
Dados ao vivo do catálogo FreeLLMAPI (versão 2026.11.19, verificado em 2026-11-19). Os limites gratuitos mudam com frequência. O catálogo é verificado todos os dias.
- Vários provedores para uma família: uma família como
bge-m3é gratuita em mais de um provedor. Assim, o failover tem para onde ir. - Entrada máxima: trechos maiores que a entrada máxima são cortados ou rejeitados. Faça os trechos menores que este valor.
- Idiomas: para textos que não estão em inglês, use uma família multilíngue como
bge-m3. As famílias com-en-no nome são para inglês. - Dimensões: vetores maiores ocupam mais armazenamento. Para um índice pequeno, isso não é um problema.
Código RAG completo em Python
O script divide arquivos de texto em trechos, gera os embeddings em lotes e salva os vetores com NumPy. Depois responde a uma pergunta com os melhores trechos e informa as fontes. Ele tenta de novo quando um limite bloqueia uma requisição.
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?"))Para mais de alguns milhares de trechos, substitua a busca NumPy por um banco de dados vetorial. As chamadas de embedding e de chat continuam iguais.
Os usuários costumam fazer a mesma pergunta de novo. O FreeLLMAPI tem um cache de respostas opcional para requisições idênticas. Um acerto no cache não usa nenhuma cota do provedor. Você pode ligar ou desligar o cache de uma requisição com o cabeçalho X-FreeLLM-Cache: on ou off. Use temperature=0, para que a mesma pergunta gere a mesma requisição.
Adicione uma etapa de rerank
A busca vetorial encontra textos semelhantes, mas o primeiro trecho nem sempre é a melhor resposta. Uma etapa de rerank ordena os candidatos de novo. A documentação do FreeLLMAPI não descreve um endpoint de rerank próprio. Você pode usar um modelo de chat rápido como reordenador. Recupere 15 candidatos e mantenha os 5 melhores.
Rerank por LLM com 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]A etapa de rerank adiciona uma requisição de chat por pergunta. Se seus limites gratuitos forem apertados, pule essa etapa. Uma divisão melhor dos trechos costuma ajudar mais que uma etapa de rerank.
Contexto longo: quando você não precisa de recuperação
Hoje, 56 ofertas de modelos gratuitos têm uma janela de contexto de 1 milhão de tokens ou mais. Se seus documentos forem pequenos, você pode enviar todos no prompt e pular o índice vetorial. Isso é mais simples, mas cada pergunta envia muitos tokens.
| Modelo | Gratuito em | Contexto | Limites gratuitos (melhor oferta) | Ferramentas | Visão |
|---|---|---|---|---|---|
| OpenAI: GPT-6 Luna | ElectronHub | 1.1M | $0.25/week shared free credits | Não | Não |
| Gemini 3.8 Flash | APINex, Google AI Studio | 1M | 5 req/min 10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account | Sim | Sim |
| Gemini 3.7 Flash | Google AI Studio | 1M | 10 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 req/min 50 req/dia Shared rate limit | Sim | Não |
| DeepSeek V4 Flash 0731 | ElectronHub, Router9 | 1M | 10,000 credits/month (~$1), shared; account-anniversary reset | Não | Não |
| Gemini 3.6 Flash | Google AI Studio | 1M | 10 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
| GLM 5.2 | Router9 | 1M | 10,000 credits/month (~$1), shared; account-anniversary reset | Não | Não |
| Gemini 3.5 Flash | Google AI Studio | 1M | 10 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
| DeepSeek V4 Pro | APINex, Router9 | 1M | 5 req/min 10M weighted tokens/day shared across APINex free routes; 3x token multiplier; 5 requests/minute/account | Não | Não |
| Nemotron 3 Ultra 550B | Gizmo, Kilo Gateway, LLMTR +3 a mais | 1M | 200 req/dia 200 rpd | Sim | Não |
Mostrando 10 de 35 modelos gratuitos correspondentes. Ver todos os modelos.
Dados ao vivo do catálogo FreeLLMAPI (versão 2026.11.19, verificado em 2026-11-19). Os limites gratuitos mudam com frequência. O catálogo é verificado todos os dias.
- Use contexto longo para poucos documentos, para perguntas que precisam do texto completo, ou para um único relatório.
- Use recuperação para muitos documentos, para perguntas frequentes, ou quando os limites gratuitos de tokens por minuto forem baixos.
- Combine as duas: recupere 20 ou mais trechos e envie-os a um modelo de contexto longo.
Um prompt grande pode falhar em um provedor com limite baixo de tokens por minuto. O FreeLLMAPI então tenta o próximo provedor. Para controlar quais modelos recebem prompts grandes, crie um perfil de cadeia de fallback só com modelos de contexto longo. Use-o como auto:<profile>.
Limites e solução de problemas
| Problema | Causa | Correção |
|---|---|---|
| A ingestão para com 429 | A família de embedding atingiu o limite em todos os provedores | Use lotes maiores, aguarde o Retry-After, faça a ingestão em partes |
| Resultados ruins depois de uma mudança | O índice tem vetores de duas famílias | Gere de novo o embedding de todos os trechos com uma família |
| Erro sobre o tamanho da entrada | Um trecho é maior que a entrada máxima da família | Use trechos menores |
| A resposta ignora as fontes | O modelo responde com o próprio conhecimento | Use temperature=0 e um prompt de sistema rigoroso |
| Erro de tamanho de contexto na resposta | Trechos demais ou longos demais | Diminua k ou use um perfil de contexto longo |
| As respostas mudam de estilo | O roteador escolheu outro modelo | Envie um cabeçalho X-Session-Id ou fixe um modelo |
Os níveis gratuitos não têm SLA. Os modelos mais fortes atingem primeiro os limites diários, e muitos limites são reiniciados à meia-noite UTC. Teste seu pipeline com os modelos que sua cadeia realmente usará.
Perguntas frequentes
Existe uma API gratuita para RAG?
Sim. Vários provedores têm níveis gratuitos de embedding e de chat. O FreeLLMAPI oferece os dois por uma única chave compatível com OpenAI, com failover entre provedores.
Qual modelo de embedding gratuito é o melhor para RAG?
Escolha uma família que seja gratuita em vários provedores e que atenda aos seus idiomas. Para textos multilíngues, o bge-m3 é uma escolha comum. Mantenha uma família para o índice inteiro.
Existe uma API de rerank gratuita?
A documentação do FreeLLMAPI não descreve um endpoint de rerank. Você pode reordenar com um modelo de chat rápido, como mostrado nesta página, ou pular a etapa de rerank.
Preciso de RAG se um modelo gratuito tem 1 milhão de tokens de contexto?
Não, para alguns documentos pequenos. Para muitos documentos ou perguntas frequentes, a recuperação envia menos tokens por requisição e fica dentro dos limites gratuitos.
Posso trocar o modelo de embedding depois?
Sim, mas você precisa gerar de novo o embedding de todos os trechos. Vetores de dois modelos não são compatíveis, então não os misture no mesmo índice.
Guias relacionados
- API gratuita de embeddings
- API LLM gratuita com contexto de 1 milhão de tokens
- LLM gratuito para LlamaIndex
- API LLM gratuita para LangChain
- LLM gratuito em Python
Fontes
- FreeLLMAPI docs: embeddings (families and failover rules) (verificado em 20 November 2026)
- FreeLLMAPI docs: routing strategies and response headers (verificado em 20 November 2026)
- OpenAI Python SDK: embeddings, errors and retries (verificado em 20 November 2026)