Inicio / Guías / API LLM gratuita para RAG

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

PasoAPIAspecto a tener en cuenta en el nivel gratuito
1. Divida los documentos en fragmentosNinguna (código local)Ninguno
2. Genere el embedding de cada fragmento/v1/embeddingsMuchas solicitudes al principio. Algunos niveles gratuitos de embeddings permiten 10 solicitudes por minuto.
3. Genere el embedding de la pregunta/v1/embeddingsUna solicitud por pregunta
4. Busque los fragmentos principalesNinguna (búsqueda vectorial local)Ninguno
5. Reordene los fragmentos (opcional)/v1/chat/completionsUna solicitud de chat adicional por pregunta
6. Escriba la respuesta/v1/chat/completionsPrompts 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.

ModeloProveedorDimensionesEntrada máx.Límite 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)

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-m3 es 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.

Modelos gratuitos con las ventanas de contexto más grandes
ModeloGratis enContextoLímites gratuitos (mejor oferta)HerramientasVisión
OpenAI: GPT-6 LunaElectronHub1.1M$0.25/week shared free creditsNoNo
Gemini 3.8 FlashAPINex, Google AI Studio1M5 solicitudes/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 solicitudes/min
20 solicitudes/día
250,000 tokens/min
~3M
SíSí
DeepSeek V4 FlashAMD Radeon Cloud, BazaarLink, ElectronHub1M10 solicitudes/min
50 solicitudes/día
Shared rate limit
SíNo
DeepSeek V4 Flash 0731ElectronHub, Router91M10,000 credits/month (~$1), shared; account-anniversary resetNoNo
Gemini 3.6 FlashGoogle AI Studio1M10 solicitudes/min
20 solicitudes/día
250,000 tokens/min
~3M
SíSí
GLM 5.2Router91M10,000 credits/month (~$1), shared; account-anniversary resetNoNo
Gemini 3.5 FlashGoogle AI Studio1M10 solicitudes/min
20 solicitudes/día
250,000 tokens/min
~3M
SíSí
DeepSeek V4 ProAPINex, Router91M5 solicitudes/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 más1M200 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

ProblemaCausaSolución
La ingesta se detiene con 429La familia de embeddings alcanzó su límite en todos los proveedoresUse lotes más grandes, espere a Retry-After e ingiera por partes
Malos resultados tras un cambioEl índice tiene vectores de dos familiasGenere de nuevo los embeddings de todos los fragmentos con una sola familia
Error sobre la longitud de la entradaUn fragmento supera la entrada máxima de la familiaUse fragmentos más pequeños
La respuesta ignora las fuentesEl modelo responde con su propio conocimientoUse temperature=0 y un prompt de sistema estricto
Error de longitud de contexto en la respuestaDemasiados fragmentos o fragmentos demasiado largosReduzca k o use un perfil de contexto largo
Las respuestas cambian de estiloEl enrutador seleccionó otro modeloEnví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.

Use cada uno de estos modelos con una sola clave. FreeLLMAPI es un enrutador de código abierto y autoalojado. Reúne todos estos niveles gratuitos detrás de un único endpoint compatible con OpenAI y cambia de proveedor cuando uno alcanza su límite. Explore el catálogo o ir en vivo.

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

Fuentes

Todas las guías · Ver todos los modelos gratuitos