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

# Gemini 3.1 Flash Lite

> **Gemini 3.1 Flash Lite** ist Googles günstigstes und schnellstes Produktionsmodell Stand März 2026, veröffentlicht am 3. März 2026. Es ist die API-optimierte Stufe der Gemini-3.1-Familie — ausgelegt für Workloads mit hohem Durchsatz und hoher Kostensensibilität wie Echtzeit-Chatbots, Klassifizierungspipelines und RAG-Retrieval-Schichten. Hoste es selbst über Ollama oder vLLM auf Clore.ai-GPUs für maximale Kostenkontrolle.

## Was ist Gemini 3.1 Flash Lite?

Veröffentlicht am 3. März 2026 als leichter Einstieg in die Gemini-3.1-Familie (zu der auch Gemini 3.1 Pro vom 19. Februar 2026 gehört) tauscht Flash Lite etwas von der Tiefe des Schlussfolgerns gegen deutlich geringere Latenz und Kosten ein. Es ist Googles Antwort auf die Stufe „schnell und günstig“ — und konkurriert preis-leistungstechnisch direkt mit den Mini-Varianten von GPT-5.4 und Claude Sonnet.

**Wichtige Spezifikationen:**

* **Multimodal**: Text-, Bild-, Audio- und Videoeingaben
* **Kontextfenster**: 1 Mio. Token (wie bei Gemini 3.1 Pro)
* **Ausgabe**: bis zu 8K Token pro Anfrage
* **Latenz**: \~120 ms bis zum ersten Token bei kurzen Prompts (API)
* **Architektur**: Aus Gemini 3.1 Pro mit spekulativem Decoding destilliert

> **Hinweis:** Gemini 3.1 Flash Lite ist ein **nur über die Google-API** Modell — die Gewichte sind nicht öffentlich veröffentlicht. Dieser Leitfaden behandelt (a) die Nutzung der Google-Gemini-API auf der Infrastruktur von Clore.ai und (b) vergleichbare Open-Source-Alternativen, die du vollständig selbst hosten kannst.

## Option A: Gemini 3.1 Flash Lite API auf einem Clore.ai-Server verwenden

Selbst wenn du die Gewichte nicht lokal ausführen kannst, lohnt es sich, deine API-nutzende Anwendung auf den günstigen Servern von Clore.ai zu betreiben — für lang laufende Prozesse, Automatisierungspipelines und Batch-Jobs.

### Einrichtung: API-Proxy + FastAPI auf Clore.ai

```bash
# Miete einen CPU- oder leichten GPU-Server auf Clore.ai
# Eine RTX 3060 (0,03–0,07 $/Std.) ist für API-Proxy-Workloads mehr als ausreichend

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="Gemini 3.1 Flash Lite Proxy")

class ChatRequest(BaseModel):
    message: str
    system_prompt: str = "Du bist ein hilfreicher Assistent."
    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
```

### Batch-Verarbeitung mit hohem Durchsatz

```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]:
    """Texte in parallelen Batches klassifizieren — kostet ca. 0,001 $ pro 1K Texte."""
    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"Klassifiziere diesen Text als POSITIVE, NEGATIVE oder NEUTRAL. Antworte nur mit einem Wort.\n\nText: {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

# Beispiel
texts = ["Tolles Produkt!", "Schlechter Service.", "Ich denke, es ist okay."]
labels = asyncio.run(batch_classify(texts))
print(list(zip(texts, labels)))
```

## Option B: Open-Source-Alternativen (selbst auf Clore.ai hosten)

Wenn du vollständig lokale Inferenz ohne API-Kosten möchtest, entsprechen diese Modelle Gemini 3.1 Flash Lite in der Stufe „schnell/günstig“:

### Gemma 3 4B (Googles offenes Leichtgewichtsmodell)

```bash
# Läuft auf jeder GPU mit 6 GB+ VRAM — sogar auf einer 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 "Erkläre Quantenverschränkung einfach."
```

### Qwen3.5 7B (schneller, höhere Qualität für die Größe)

```bash
docker exec -it $(docker ps -q) ollama pull qwen3.5:7b
# ~3,8 GB VRAM, ~45 Tok/s auf einer RTX 3080
```

### Geschwindigkeitsvergleich auf Clore.ai-Hardware

| Modell                      | VRAM  | Token/s (RTX 4090, Einzelstream) | Kosten pro 1 Mio. Ausgabetoken                     |
| --------------------------- | ----- | -------------------------------- | -------------------------------------------------- |
| Gemini 3.1 Flash Lite (API) | k. A. | \~200 (API)                      | \~0,25 $ Eingabe / 1,50 $ Ausgabe pro 1 Mio. Token |
| Gemma 3 4B (lokal)          | 4 GB  | 95 tok/s                         | \~0,58 $ (RTX 4090 bei 0,20 $/Std.)                |
| Qwen3.5 7B (lokal)          | 8 GB  | 78 tok/s                         | \~$0.71                                            |
| Gemma 3 12B (lokal)         | 12 GB | 55 tok/s                         | \~$1.01                                            |
| Gemma 3 27B (lokal)         | 20 GB | 32 tok/s                         | \~$1.74                                            |

> **Fazit:** Bei einer Anfrage nach der anderen kostet Self-Hosting etwa so viel wie die API. Der Vorteil kommt von **Batching**: Mit vLLM oder SGLang, die gleichzeitige Anfragen bedienen, steigt der Gesamtdurchsatz auf derselben 4090 um ein Vielfaches und die Kosten pro Million Token sinken entsprechend. Hoste selbst, wenn du ein konstantes, paralleles Volumen hast; verwende die API für spitzenartigen, volumenarmen Traffic.

## Bereitstellung auf Clore.ai

### Empfohlene GPU für Workloads der Flash-Lite-Klasse

| Anwendungsfall              | Empfohlene GPU                      | Preis auf Clore.ai      |
| --------------------------- | ----------------------------------- | ----------------------- |
| API-Proxy / Automatisierung | Keine GPU erforderlich (CPU-Server) | \~$0,05/Std.            |
| Lokales 4B-Modell           | RTX 3060 12 GB                      | 0,03–0,07 $/Std.        |
| Lokales 7B-Modell           | RTX 3080 10GB                       | $0,05–0,19/Std.         |
| Lokales 27B-Modell          | RTX 4090 24GB                       | 0,14–0,42 $/Std. (Spot) |

### Ollama-Ein-Klick-Start auf Clore.ai

Wähle im Clore.ai-Dashboard **Ollama** aus den Vorlagen:

```bash
# Oder manuell per SSH:
curl -fsSL https://ollama.com/install.sh | sh
ollama serve &
ollama pull gemma3:4b
ollama run gemma3:4b
```

## Anwendungsfälle, die sich am besten für die Flash-Lite-Klasse eignen

1. **RAG-Retrieval-Schicht** — schnelles Kontext-Ranking, nicht die finale Generierung
2. **Echtzeit-Chatbot-Antworten** — unter 200 ms für kurze Anfragen
3. **Dokumentklassifizierung** — verarbeite Tausende von Dokumenten pro Minute
4. **Code-Autovervollständigung** — Vorschläge mit geringer Latenz generieren
5. **Übersetzungspipelines** — Inhalte kostengünstig im Batch übersetzen
6. **Inhaltsmoderation** — Benutzerdaten in großem Umfang klassifizieren

## Kostenrechner

| Monatliches Volumen | Kosten der Google-API | Clore.ai (Gemma 3 4B)             |
| ------------------- | --------------------- | --------------------------------- |
| 10 Mio. Token       | \~$8.75               | \~3,60 $ (50 Std./Monat RTX 3060) |
| 100 Mio. Token      | \~$7.00               | \~3,60 $ (durchgehend)            |
| 1 Mrd. Token        | \~$70.00              | \~26 $ (durchgehend RTX 3060)     |

> Bei Volumina über \~200 Mio. Token/Monat ist Self-Hosting auf Clore.ai günstiger als die Kosten der Gemini-API.

## API-Nutzung überwachen

```python
# Gemini-API-Nutzung und -Kosten verfolgen
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)
    
    # Nutzung protokollieren
    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

# Verwendung
result = tracked_generate("Was ist die Hauptstadt von Frankreich?")
print(result)
```

## Verwandte Leitfäden

* [Gemma 3 auf Clore.ai](/guides/guides_v2-de/sprachmodelle/gemma3.md) — Googles Open-Source-Modellfamilie
* [Ollama-Anleitung](/guides/guides_v2-de/sprachmodelle/ollama.md) — führe jedes LLM lokal mit einem einzigen Befehl aus
* [RAGFlow](/guides/guides_v2-de/rag-and-vektordatenbanken/ragflow.md) — RAG-Pipeline, die gut mit schnellen Modellen funktioniert
* [vLLM-Serving](/guides/guides_v2-de/sprachmodelle/vllm.md) — OpenAI-kompatibler Server mit hohem Durchsatz
* [GPU-Vergleich](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — finde die günstigste GPU für deine Anforderungen

***

*Zuletzt aktualisiert: 16. März 2026 | Gemini 3.1 Flash Lite veröffentlicht: 3. März 2026 | Gewichte: nur über 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-de/sprachmodelle/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.