API LLM gratuita para RAG
La generación aumentada por recuperación (RAG) necesita dos APIs: un modelo de embeddings para encontrar el texto relevante, y un modelo de chat para escribir la respuesta. Las dos están disponibles en niveles gratuitos. FreeLLMAPI ofrece una clave única compatible con OpenAI para 41 modelos de embeddings gratuitos y 487 modelos de chat gratuitos, con conmutación por error entre proveedores. Esta guía muestra los modelos gratuitos para cada paso y una canalización completa en Python.
El código, los nombres de los modelos y las etiquetas del catálogo en vivo se muestran en inglés.
La canalización RAG en niveles gratuitos
| Paso | API | Aspecto a tener en cuenta en el nivel gratuito |
|---|---|---|
| 1. Divida los documentos en fragmentos | Ninguna (código local) | Ninguno |
| 2. Genere el embedding de cada fragmento | /v1/embeddings | Muchas solicitudes al principio. Algunos niveles gratuitos de embeddings permiten 10 solicitudes por minuto. |
| 3. Genere el embedding de la pregunta | /v1/embeddings | Una solicitud por pregunta |
| 4. Busque los fragmentos principales | Ninguna (búsqueda vectorial local) | Ninguno |
| 5. Reordene los fragmentos (opcional) | /v1/chat/completions | Una solicitud de chat adicional por pregunta |
| 6. Escriba la respuesta | /v1/chat/completions | Prompts grandes. Se aplican los límites de tokens por minuto. |
El paso 2 es el más costoso. Hágalo una vez por cada documento. Guarde los vectores y, después, genere embeddings solo de los documentos nuevos o modificados.
Instale FreeLLMAPI y los paquetes de Python
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai numpy
export FREELLMAPI_API_KEY=<unified-key>Elija un modelo de embeddings gratuito
Seleccione una familia de embeddings y manténgala para todo el índice. Los vectores de dos modelos no son compatibles. FreeLLMAPI le protege de los vectores mezclados: la conmutación por error de embeddings nunca cambia el modelo. Solo pasa entre proveedores que ofrecen la misma familia.
| Modelo | Proveedor | Dimensiones | Entrada máx. | Límite 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) |
Datos en vivo del catálogo de FreeLLMAPI (versión 2026.11.19, revisado 2026-11-19). Los límites gratuitos cambian con frecuencia. El catálogo se revisa todos los días.
- Varios proveedores para una familia: una familia como
bge-m3es gratuita en más de un proveedor. Así la conmutación por error tiene adónde ir. - Entrada máxima: los fragmentos más largos que la entrada máxima se cortan o se rechazan. Haga los fragmentos más pequeños que este valor.
- Idiomas: para textos que no están en inglés, use una familia multilingüe como
bge-m3. Las familias con-en-en el nombre son para inglés. - Dimensiones: los vectores más grandes ocupan más almacenamiento. Para un índice pequeño, esto no es un problema.
Código RAG completo en Python
El script divide los archivos de texto en fragmentos, genera sus embeddings por lotes y guarda los vectores con NumPy. Después responde a una pregunta con los fragmentos principales e indica las fuentes. Reintenta cuando un límite detiene una solicitud.
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 más de unos pocos miles de fragmentos, sustituya la búsqueda con NumPy por una base de datos vectorial. Las llamadas de embeddings y de chat siguen igual.
Los usuarios suelen repetir la misma pregunta. FreeLLMAPI tiene una caché de respuestas opcional para solicitudes idénticas. Un acierto de caché no usa ninguna cuota del proveedor. Puede activar o desactivar la caché en una solicitud con el encabezado X-FreeLLM-Cache: on u off. Use temperature=0, para que la misma pregunta genere la misma solicitud.
Añada un paso de reordenación
La búsqueda vectorial encuentra texto similar, pero el fragmento principal no siempre es la mejor respuesta. Un paso de reordenación vuelve a ordenar los candidatos. La documentación de FreeLLMAPI no describe un endpoint de reordenación específico. Puede usar un modelo de chat rápido como reordenador. Recupere 15 candidatos y conserve los 5 mejores.
Reordenación con LLM mediante 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]El paso de reordenación añade una solicitud de chat por pregunta. Si sus límites gratuitos son estrictos, omítalo. Una mejor fragmentación suele ayudar más que un paso de reordenación.
Contexto largo: cuándo no necesita recuperación
Hoy, 56 ofertas de modelos gratuitos tienen una ventana de contexto de 1 millón de tokens o más. Si sus documentos son pequeños, puede enviarlos todos en el prompt y omitir el índice vectorial. Es más sencillo, pero cada pregunta envía entonces muchos tokens.
| Modelo | Gratis en | Contexto | Límites gratuitos (mejor oferta) | Herramientas | Visión |
|---|---|---|---|---|---|
| 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 solicitudes/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 solicitudes/min 20 solicitudes/día 250,000 tokens/min ~3M | Sí | Sí |
| DeepSeek V4 Flash | AMD Radeon Cloud, BazaarLink, ElectronHub | 1M | 10 solicitudes/min 50 solicitudes/día 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 solicitudes/min 20 solicitudes/día 250,000 tokens/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 solicitudes/min 20 solicitudes/día 250,000 tokens/min ~3M | Sí | Sí |
| DeepSeek V4 Pro | APINex, Router9 | 1M | 5 solicitudes/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 más | 1M | 200 solicitudes/día 200 rpd | Sí | No |
Se muestran 10 de 35 modelos gratuitos que coinciden. Ver todos los modelos.
Datos en vivo del catálogo de FreeLLMAPI (versión 2026.11.19, revisado 2026-11-19). Los límites gratuitos cambian con frecuencia. El catálogo se revisa todos los días.
- Use contexto largo para pocos documentos, para preguntas que necesitan el texto completo o para un solo informe.
- Use recuperación para muchos documentos, para preguntas frecuentes o cuando los límites gratuitos de tokens por minuto son bajos.
- Combínelos: recupere 20 fragmentos o más y envíelos a un modelo de contexto largo.
Un prompt grande puede fallar en un proveedor con un límite bajo de tokens por minuto. FreeLLMAPI entonces prueba el siguiente proveedor. Para controlar qué modelos reciben prompts grandes, cree un perfil de cadena de respaldo solo con modelos de contexto largo. Úselo como auto:<profile>.
Límites y solución de problemas
| Problema | Causa | Solución |
|---|---|---|
| La ingesta se detiene con 429 | La familia de embeddings alcanzó su límite en todos los proveedores | Use lotes más grandes, espere a Retry-After e ingiera por partes |
| Malos resultados tras un cambio | El índice tiene vectores de dos familias | Genere de nuevo los embeddings de todos los fragmentos con una sola familia |
| Error sobre la longitud de la entrada | Un fragmento supera la entrada máxima de la familia | Use fragmentos más pequeños |
| La respuesta ignora las fuentes | El modelo responde con su propio conocimiento | Use temperature=0 y un prompt de sistema estricto |
| Error de longitud de contexto en la respuesta | Demasiados fragmentos o fragmentos demasiado largos | Reduzca k o use un perfil de contexto largo |
| Las respuestas cambian de estilo | El enrutador seleccionó otro modelo | Envíe un encabezado X-Session-Id o fije un modelo |
Los niveles gratuitos no tienen SLA. Los modelos más potentes alcanzan primero sus límites diarios, y muchos límites se reinician a medianoche UTC. Pruebe su canalización con los modelos que su cadena usará realmente.
Preguntas frecuentes
¿Existe una API gratuita para RAG?
Sí. Varios proveedores tienen niveles gratuitos de embeddings y de chat. FreeLLMAPI sirve los dos con una clave única compatible con OpenAI, con conmutación por error entre proveedores.
¿Cuál es el mejor modelo de embeddings gratuito para RAG?
Seleccione una familia que sea gratuita en varios proveedores y que se adapte a sus idiomas. Para textos multilingües, bge-m3 es una opción habitual. Mantenga una sola familia para todo el índice.
¿Existe una API de reordenación gratuita?
La documentación de FreeLLMAPI no describe un endpoint de reordenación. Puede reordenar con un modelo de chat rápido, como se muestra en esta página, u omitir el paso de reordenación.
¿Necesito RAG si un modelo gratuito tiene 1 millón de tokens de contexto?
No para unos pocos documentos pequeños. Para muchos documentos o preguntas frecuentes, la recuperación envía menos tokens por solicitud y se mantiene dentro de los límites gratuitos.
¿Puedo cambiar el modelo de embeddings más adelante?
Sí, pero debe generar de nuevo los embeddings de todos los fragmentos. Los vectores de dos modelos no son compatibles, así que no los mezcle en un mismo índice.
Guías relacionadas
- API gratuita de embeddings
- API LLM gratuita con contexto de 1 millón de tokens
- LLM gratuito para LlamaIndex
- API LLM gratuita para LangChain
- API de LLM gratuita en Python
Fuentes
- FreeLLMAPI docs: embeddings (families and failover rules) (revisado 20 November 2026)
- FreeLLMAPI docs: routing strategies and response headers (revisado 20 November 2026)
- OpenAI Python SDK: embeddings, errors and retries (revisado 20 November 2026)