# 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 la capa optimizada para API de la familia Gemini 3.1, diseñada para cargas de trabajo de alto rendimiento y sensibles al costo, como chatbots en tiempo real, canales de clasificación y capas de recuperación RAG. Aloja el modelo por tu cuenta mediante Ollama o vLLM en GPUs de Clore.ai para un control máximo 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 parte de la profundidad de razonamiento a cambio de una latencia y un costo drásticamente menores. Es la respuesta de Google al nivel de "rápido y barato", compitiendo directamente con las variantes mini de GPT-5.4 y Claude Sonnet en relación precio-rendimiento.

**Especificaciones clave:**

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

> **Nota:** Gemini 3.1 Flash Lite es un modelo **solo de la API de Google** — los pesos no se publican. Esta guía cubre (a) el uso de la API de Google Gemini en la infraestructura de Clore.ai, y (b) alternativas de código abierto comparables que puedes alojar tú mismo 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, canales 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
# RTX 3060 (~$0.25/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 ~$0.001 por 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 POSITIVE, NEGATIVE o NEUTRAL. Responde solo con una 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 (autoalojar en Clore.ai)

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

### Gemma 3 4B (modelo ligero abierto de Google)

```bash
# Se ejecuta en cualquier GPU con 6 GB+ de VRAM — incluso 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 simple."
```

### Qwen3.5 7B (más rápido, 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/s (RTX 4090) | Costo/1M tokens (Clore.ai)                   |
| --------------------------- | ----- | ------------------- | -------------------------------------------- |
| Gemini 3.1 Flash Lite (API) | N/D   | \~200 (API)         | \~$0.25 entrada / $1.50 salida por 1M tokens |
| Gemma 3 4B (local)          | 4 GB  | 95 tok/s            | \~$0.002 (a $2/h)                            |
| Qwen3.5 7B (local)          | 8 GB  | 78 tok/s            | \~$0.005 (a $2/h)                            |
| Gemma 3 12B (local)         | 12 GB | 55 tok/s            | \~$0.008 (a $2/h)                            |
| Gemma 3 27B (local)         | 20 GB | 32 tok/s            | \~$0.014 (a $2/h)                            |

> **Conclusión:** Para cargas de trabajo de gran volumen (>100M tokens/mes), autoalojar Gemma 3 / Qwen3.5 en Clore.ai es **35–50× más barato** que la API de Gemini.

## Desplegar en Clore.ai

### GPU recomendada para cargas de trabajo de 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 de 4B            | RTX 3060 12GB                     | \~$0.25/h          |
| Modelo local de 7B            | RTX 3080 10GB                     | \~$0.35/h          |
| Modelo local de 27B           | RTX 4090 24GB                     | \~$1.20/h (spot)   |

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

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

```bash
# O manualmente mediante 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. **Canales de traducción** — traduce contenido por lotes a bajo costo
6. **Moderación de contenido** — clasifica contenido de usuarios a 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.

## Monitoreo del uso de la API

```python
# 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 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) — 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) — canal RAG que funciona bien con modelos rápidos
* [Servicio 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: 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:

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

The question should be specific, self-contained, and written in natural language.
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.