> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/gemini-3-1-flash-lite.md).

# Gemini 3.1 Flash Lite

> **Gemini 3.1 Flash Lite** es el modelo de producción más barato y rápido de Google a marzo de 2026, lanzado el 3 de marzo de 2026. Es el nivel optimizado para API de la familia Gemini 3.1, diseñado para cargas de trabajo de alto rendimiento y sensibles al costo, como chatbots en tiempo real, pipelines de clasificación y capas de recuperación RAG. Autoalójalo mediante Ollama o vLLM en GPUs de Clore.ai para tener el máximo control de costos.

## ¿Qué es Gemini 3.1 Flash Lite?

Lanzado el 3 de marzo de 2026 como la entrada ligera a la familia Gemini 3.1 (que también incluye Gemini 3.1 Pro del 19 de febrero de 2026), Flash Lite sacrifica algo de profundidad de razonamiento a cambio de una latencia y un costo drásticamente menores. Es la respuesta de Google al nivel "rápido y barato" — compitiendo directamente con las variantes mini de GPT-5.4 y Claude Sonnet en relación calidad-precio.

**Especificaciones clave:**

* **Multimodal**: entradas de texto, imagen, audio y video
* **Ventana de contexto**: 1M tokens (igual que Gemini 3.1 Pro)
* **Salida**: hasta 8K tokens por solicitud
* **Latencia**: \~120 ms hasta el primer token para solicitudes cortas (API)
* **Arquitectura**: destilado de Gemini 3.1 Pro con decodificación especulativa

> **Nota:** Gemini 3.1 Flash Lite es un **solo API de Google** modelo — los pesos no se han publicado públicamente. Esta guía cubre (a) usar la API de Google Gemini en la infraestructura de Clore.ai y (b) alternativas de código abierto comparables que puedes autoalojar por completo.

## Opción A: usar la API de Gemini 3.1 Flash Lite en un servidor de Clore.ai

Aunque no puedas ejecutar los pesos localmente, alojar tu aplicación que consume la API en los servidores baratos de Clore.ai tiene sentido para procesos de larga duración, pipelines de automatización y trabajos por lotes.

### Configuración: proxy de API + FastAPI en Clore.ai

```bash
# Alquila un servidor CPU o GPU ligera en Clore.ai
# Una RTX 3060 ($0.03–0.07/h) es más que suficiente para cargas de trabajo de proxy de API

pip install google-generativeai fastapi uvicorn

cat > gemini_proxy.py << 'EOF'
import google.generativeai as genai
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import os

genai.configure(api_key=os.environ["GOOGLE_API_KEY"])

model = genai.GenerativeModel("gemini-3.1-flash-lite")

app = FastAPI(title="Proxy de Gemini 3.1 Flash Lite")

class ChatRequest(BaseModel):
    message: str
    system_prompt: str = "Eres un asistente útil."
    max_tokens: int = 2048

@app.post("/chat")
async def chat(req: ChatRequest):
    try:
        response = model.generate_content(
            [req.system_prompt, req.message],
            generation_config=genai.GenerationConfig(
                max_output_tokens=req.max_tokens,
                temperature=0.7
            )
        )
        return {"response": response.text, "model": "gemini-3.1-flash-lite"}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.post("/vision")
async def vision_chat(image_url: str, prompt: str):
    import httpx
    async with httpx.AsyncClient() as client:
        img_data = await client.get(image_url)
    
    import PIL.Image
    import io
    image = PIL.Image.open(io.BytesIO(img_data.content))
    response = model.generate_content([prompt, image])
    return {"response": response.text}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)
EOF

GOOGLE_API_KEY=your-key uvicorn gemini_proxy:app --host 0.0.0.0 --port 8080
```

### Procesamiento por lotes de alto rendimiento

```python
import google.generativeai as genai
import asyncio
from typing import List

genai.configure(api_key="YOUR_API_KEY")

async def batch_classify(texts: List[str], batch_size: int = 50) -> List[str]:
    """Clasifica textos en lotes paralelos — cuesta aprox. ~$0.001 por cada 1K textos."""
    model = genai.GenerativeModel("gemini-3.1-flash-lite")
    
    results = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        tasks = [
            model.generate_content_async(
                f"Clasifica este texto como POSITIVO, NEGATIVO o NEUTRO. Responde con una sola palabra.\n\nTexto: {text}"
            )
            for text in batch
        ]
        responses = await asyncio.gather(*tasks, return_exceptions=True)
        results.extend([
            r.text.strip() if not isinstance(r, Exception) else "ERROR"
            for r in responses
        ])
    return results

# Ejemplo
texts = ["¡Gran producto!", "Servicio terrible.", "Supongo que está bien."]
labels = asyncio.run(batch_classify(texts))
print(list(zip(texts, labels)))
```

## Opción B: alternativas de código abierto (autoalojadas en Clore.ai)

Si quieres inferencia totalmente local sin costos de API, estos modelos igualan a Gemini 3.1 Flash Lite en el nivel "rápido/barato":

### Gemma 3 4B (el modelo ligero de código abierto de Google)

```bash
# Funciona en cualquier GPU con 6 GB+ de VRAM — incluso una RTX 3060
docker run --gpus all -d \\
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \\
  ollama/ollama

docker exec -it $(docker ps -q) ollama pull gemma3:4b
docker exec -it $(docker ps -q) ollama run gemma3:4b "Explica el entrelazamiento cuántico de forma sencilla."
```

### Qwen3.5 7B (más rápido, de mayor calidad para su tamaño)

```bash
docker exec -it $(docker ps -q) ollama pull qwen3.5:7b
# ~3.8 GB de VRAM, ~45 tok/s en RTX 3080
```

### Comparación de velocidad en hardware de Clore.ai

| Modelo                      | VRAM  | Tokens/seg (RTX 4090, flujo único) | Costo por 1M tokens de salida                      |
| --------------------------- | ----- | ---------------------------------- | -------------------------------------------------- |
| Gemini 3.1 Flash Lite (API) | N/A   | \~200 (API)                        | \~$0.25 de entrada / $1.50 de salida por 1M tokens |
| Gemma 3 4B (local)          | 4GB   | 95 tok/s                           | \~$0.58 (RTX 4090 a $0.20/h)                       |
| Qwen3.5 7B (local)          | 8GB   | 78 tok/s                           | \~$0.71                                            |
| Gemma 3 12B (local)         | 12GB  | 55 tok/s                           | \~$1.01                                            |
| Gemma 3 27B (local)         | 20 GB | 32 tok/s                           | \~$1.74                                            |

> **Conclusión:** una solicitud a la vez, el autoalojamiento cuesta aproximadamente lo mismo que la API. La ventaja viene de **procesamiento por lotes**: con vLLM o SGLang sirviendo solicitudes concurrentes, el rendimiento agregado en la misma 4090 aumenta varias veces y el costo por millón de tokens cae con ello. Autoalójate cuando tengas volumen estable y paralelo; usa la API para tráfico intermitente y de bajo volumen.

## Despliega en Clore.ai

### GPU recomendada para cargas de trabajo del nivel Flash Lite

| Caso de uso                   | GPU recomendada                   | Precio en Clore.ai  |
| ----------------------------- | --------------------------------- | ------------------- |
| Proxy de API / automatización | No se necesita GPU (servidor CPU) | \~$0,05/h           |
| Modelo local 4B               | RTX 3060 12GB                     | $0.03–0.07/h        |
| Modelo local 7B               | RTX 3080 10GB                     | $0,05–0,19/h        |
| Modelo local 27B              | RTX 4090 24GB                     | $0.14–0.42/h (spot) |

### Inicio de Ollama con un clic en Clore.ai

En el panel de Clore.ai, selecciona **Ollama** de las plantillas:

```bash
# O manualmente por SSH:
curl -fsSL https://ollama.com/install.sh | sh
ollama serve &
ollama pull gemma3:4b
ollama run gemma3:4b
```

## Casos de uso más adecuados para el nivel Flash Lite

1. **Capa de recuperación RAG** — clasificación rápida del contexto, no generación final
2. **Respuestas de chatbot en tiempo real** — menos de 200 ms para consultas cortas
3. **Clasificación de documentos** — procesa miles de documentos por minuto
4. **Autocompletado de código** — generación de sugerencias de baja latencia
5. **Pipelines de traducción** — traduce contenido por lotes a bajo costo
6. **Moderación de contenido** — clasifica contenido de usuario a gran escala

## Estimador de costos

| Volumen mensual | Costo de la API de Google | Clore.ai (Gemma 3 4B)       |
| --------------- | ------------------------- | --------------------------- |
| 10M tokens      | \~$8.75                   | \~$3.60 (50 h/mes RTX 3060) |
| 100M tokens     | \~$7.00                   | \~$3.60 (continuo)          |
| 1B tokens       | \~$70.00                  | \~$26 (RTX 3060 continuo)   |

> Para volúmenes superiores a \~200M tokens/mes, el autoalojamiento en Clore.ai supera el costo de la API de Gemini.

## Monitorización del uso de la API

```python
# Haz seguimiento del uso y los costos de la API de Gemini
import google.generativeai as genai
import json
from datetime import datetime

genai.configure(api_key="YOUR_API_KEY")

def tracked_generate(prompt: str, log_file: str = "usage.jsonl"):
    model = genai.GenerativeModel("gemini-3.1-flash-lite")
    response = model.generate_content(prompt)
    
    # Registrar el uso
    usage = {
        "timestamp": datetime.utcnow().isoformat(),
        "prompt_tokens": response.usage_metadata.prompt_token_count,
        "output_tokens": response.usage_metadata.candidates_token_count,
        "total_tokens": response.usage_metadata.total_token_count,
        "estimated_cost_usd": response.usage_metadata.total_token_count / 1_000_000 * 0.07
    }
    
    with open(log_file, "a") as f:
        f.write(json.dumps(usage) + "\n")
    
    return response.text

# Uso
result = tracked_generate("¿Cuál es la capital de Francia?")
print(result)
```

## Guías relacionadas

* [Gemma 3 en Clore.ai](/guides/guides_v2-es/modelos-de-lenguaje/gemma3.md) — la familia de modelos de código abierto de Google
* [Guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — ejecuta cualquier LLM localmente con un solo comando
* [RAGFlow](/guides/guides_v2-es/rag-y-bases-de-datos-vectoriales/ragflow.md) — pipeline RAG que funciona bien con modelos rápidos
* [Servicio de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — servidor compatible con OpenAI de alto rendimiento
* [Comparación de GPU](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md) — encuentra la GPU más barata para tus necesidades

***

*Última actualización: 16 de marzo de 2026 | Gemini 3.1 Flash Lite lanzado: 3 de marzo de 2026 | Pesos: solo API (Google)*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/gemini-3-1-flash-lite.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.