> 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-fr/modeles-de-langage/gemini-3-1-flash-lite.md).

# Gemini 3.1 Flash Lite

> **Gemini 3.1 Flash Lite** est le modèle de production le moins cher et le plus rapide de Google à compter de mars 2026, publié le 3 mars 2026. C’est le niveau optimisé pour l’API de la famille Gemini 3.1 — conçu pour des charges de travail à haut débit et sensibles aux coûts, comme les chatbots en temps réel, les pipelines de classification et les couches de récupération RAG. Hébergez-le vous-même via Ollama ou vLLM sur les GPU de Clore.ai pour un contrôle maximal des coûts.

## Qu’est-ce que Gemini 3.1 Flash Lite ?

Publié le 3 mars 2026 comme l’entrée légère de la famille Gemini 3.1 (qui comprend aussi Gemini 3.1 Pro du 19 février 2026), Flash Lite échange une partie de la profondeur de raisonnement contre une latence et un coût nettement plus faibles. C’est la réponse de Google au niveau « rapide et bon marché » — en concurrence directe avec les variantes mini de GPT-5.4 et Claude Sonnet en termes de rapport prix/performance.

**Spécifications clés :**

* **Multimodal**: entrées texte, image, audio, vidéo
* **Fenêtre de contexte**: 1 M de jetons (identique à Gemini 3.1 Pro)
* **Sortie**: jusqu’à 8 K jetons par requête
* **Latence**: \~120 ms de temps jusqu’au premier jeton pour les prompts courts (API)
* **Architecture**: distillée à partir de Gemini 3.1 Pro avec décodage spéculatif

> **Remarque :** Gemini 3.1 Flash Lite est un **modèle réservé à l’API Google** — les poids ne sont pas publiés publiquement. Ce guide couvre (a) l’utilisation de l’API Google Gemini sur l’infrastructure de Clore.ai, et (b) des alternatives open source comparables que vous pouvez héberger entièrement vous-même.

## Option A : utiliser l’API Gemini 3.1 Flash Lite sur un serveur Clore.ai

Même si vous ne pouvez pas exécuter les poids localement, héberger votre application consommatrice d’API sur les serveurs bon marché de Clore.ai est judicieux pour les processus de longue durée, les pipelines d’automatisation et les traitements par lots.

### Configuration : proxy d’API + FastAPI sur Clore.ai

```bash
# Louez un serveur CPU ou GPU léger sur Clore.ai
# Une RTX 3060 (~0,25 $/h) est largement suffisante pour les charges de travail de proxy d’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 Gemini 3.1 Flash Lite")

class ChatRequest(BaseModel):
    message: str
    system_prompt: str = "Vous êtes un assistant serviable."
    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=votre-clé uvicorn gemini_proxy:app --host 0.0.0.0 --port 8080
```

### Traitement par lots à haut débit

```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]:
    """Classifiez les textes par lots parallèles — coûtent environ 0,001 $ par 1 K textes."""
    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"Classifiez ce texte comme POSITIVE, NEGATIVE ou NEUTRAL. Répondez avec un seul mot uniquement.\n\nTexte : {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

# Exemple
texts = ["Super produit !", "Service terrible.", "Ça va, je suppose."]
labels = asyncio.run(batch_classify(texts))
print(list(zip(texts, labels)))
```

## Option B : alternatives open source (hébergement autonome sur Clore.ai)

Si vous voulez une inférence entièrement locale sans coût d’API, ces modèles correspondent à Gemini 3.1 Flash Lite dans le niveau « rapide/bon marché » :

### Gemma 3 4B (modèle léger ouvert de Google)

```bash
# Fonctionne sur n’importe quel GPU avec 6 Go+ de VRAM — même une 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 "Explique simplement l’intrication quantique."
```

### Qwen3.5 7B (plus rapide, meilleure qualité pour sa taille)

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

### Comparaison des vitesses sur le matériel Clore.ai

| Modèle                      | VRAM  | Jetons/sec (RTX 4090) | Coût/1 M jetons (Clore.ai)                           |
| --------------------------- | ----- | --------------------- | ---------------------------------------------------- |
| Gemini 3.1 Flash Lite (API) | N/A   | \~200 (API)           | \~0,25 $ en entrée / 1,50 $ en sortie par 1 M jetons |
| Gemma 3 4B (local)          | 4 Go  | 95 tok/s              | \~0,002 $ (à 2 $/h)                                  |
| Qwen3.5 7B (local)          | 8 Go  | 78 tok/s              | \~0,005 $ (à 2 $/h)                                  |
| Gemma 3 12B (local)         | 12 Go | 55 tok/s              | \~0,008 $ (à 2 $/h)                                  |
| Gemma 3 27B (local)         | 20 Go | 32 tok/s              | \~0,014 $ (à 2 $/h)                                  |

> **À retenir :** Pour les charges de travail à grand volume (>100 M jetons/mois), l’hébergement autonome de Gemma 3 / Qwen3.5 sur Clore.ai est **35 à 50× moins cher** que l’API Gemini.

## Déployer sur Clore.ai

### GPU recommandé pour les charges de travail du niveau Flash Lite

| Cas d’utilisation            | GPU recommandé                     | Prix sur Clore.ai |
| ---------------------------- | ---------------------------------- | ----------------- |
| Proxy d’API / automatisation | Aucun GPU nécessaire (serveur CPU) | \~0,05 $/h        |
| Modèle local 4B              | RTX 3060 12 Go                     | \~0,25 $/h        |
| Modèle local 7B              | RTX 3080 10 Go                     | \~0,35 $/h        |
| Modèle local 27B             | RTX 4090 24 Go                     | \~1,20 $/h (spot) |

### Lancement Ollama en un clic sur Clore.ai

Dans le tableau de bord Clore.ai, sélectionnez **Ollama** dans les modèles :

```bash
# Ou manuellement via SSH :
curl -fsSL https://ollama.com/install.sh | sh
ollama serve &
ollama pull gemma3:4b
ollama run gemma3:4b
```

## Cas d’utilisation les mieux adaptés au niveau Flash Lite

1. **couche de récupération RAG** — classement rapide du contexte, pas génération finale
2. **Réponses de chatbot en temps réel** — moins de 200 ms pour les requêtes courtes
3. **Classification de documents** — traiter des milliers de documents par minute
4. **Auto-complétion de code** — génération de suggestions à faible latence
5. **Pipelines de traduction** — traduire du contenu par lots à faible coût
6. **Modération de contenu** — classer le contenu des utilisateurs à grande échelle

## Estimateur de coûts

| Volume mensuel | Coût de l’API Google | Clore.ai (Gemma 3 4B)         |
| -------------- | -------------------- | ----------------------------- |
| 10 M jetons    | \~$8.75              | \~3,60 $ (50 h/mois RTX 3060) |
| 100 M jetons   | \~$7.00              | \~3,60 $ (en continu)         |
| 1 Md jetons    | \~$70.00             | \~26 $ (RTX 3060 en continu)  |

> Pour des volumes supérieurs à environ 200 M jetons/mois, l’hébergement autonome sur Clore.ai est plus avantageux que le coût de l’API Gemini.

## Surveillance de l’utilisation de l’API

```python
# Suivre l’utilisation et les coûts de l’API 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)
    
    # Journaliser l’utilisation
    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

# Utilisation
result = tracked_generate("Quelle est la capitale de la France ?")
print(result)
```

## Guides associés

* [Gemma 3 sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/gemma3.md) — famille de modèles open source de Google
* [Guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) — exécutez n’importe quel LLM localement avec une seule commande
* [RAGFlow](/guides/guides_v2-fr/rag-et-bases-de-donnees-vectorielles/ragflow.md) — pipeline RAG qui fonctionne bien avec les modèles rapides
* [Service vLLM](/guides/guides_v2-fr/modeles-de-langage/vllm.md) — serveur compatible OpenAI à haut débit
* [Comparaison des GPU](/guides/guides_v2-fr/prise-en-main/gpu-comparison.md) — trouvez le GPU le moins cher pour vos besoins

***

*Dernière mise à jour : 16 mars 2026 | Gemini 3.1 Flash Lite publié : 3 mars 2026 | Poids : API uniquement (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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/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.