> 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-ru/yazykovye-modeli/gemini-3-1-flash-lite.md).

# Gemini 3.1 Flash Lite

> **Gemini 3.1 Flash Lite** это самая дешёвая и быстрая производственная модель Google по состоянию на март 2026 года, выпущенная 3 марта 2026 года. Это API-оптимизированный уровень семейства Gemini 3.1 — созданный для высоконагруженных, чувствительных к стоимости задач, таких как чат-боты в реальном времени, конвейеры классификации и слои извлечения RAG. Разверните её самостоятельно через Ollama или vLLM на GPU Clore.ai для максимального контроля затрат.

## Что такое Gemini 3.1 Flash Lite?

Выпущенная 3 марта 2026 года как облегчённая версия семейства Gemini 3.1 (которое также включает Gemini 3.1 Pro от 19 февраля 2026 года), Flash Lite жертвует частью глубины рассуждений ради значительно меньшей задержки и стоимости. Это ответ Google на уровень «быстро и дёшево» — прямой конкурент мини-версиям GPT-5.4 и Claude Sonnet по соотношению цены и производительности.

**Основные характеристики:**

* **Мультимодальная**: текст, изображение, аудио, видео на входе
* **Окно контекста**: 1 млн токенов (как у Gemini 3.1 Pro)
* **Вывод**: до 8K токенов за запрос
* **Задержка**: \~120 мс до первого токена для коротких запросов (API)
* **Архитектура**: дистиллирована из Gemini 3.1 Pro с использованием спекулятивного декодирования

> **Примечание:** Gemini 3.1 Flash Lite — это **модель только для Google API** — веса публично не опубликованы. Это руководство охватывает (а) использование Google Gemini API на инфраструктуре Clore.ai и (б) сопоставимые open-source альтернативы, которые вы можете полностью развернуть самостоятельно.

## Вариант A: используйте API Gemini 3.1 Flash Lite на сервере Clore.ai

Даже если вы не можете запускать веса локально, размещение приложения, использующего API, на дешёвых серверах Clore.ai имеет смысл для долгоживущих процессов, конвейеров автоматизации и пакетных задач.

### Настройка: API-прокси + FastAPI на Clore.ai

```bash
# Арендуйте CPU- или лёгкий GPU-сервер на Clore.ai
# RTX 3060 (~$0.25/ч) более чем достаточно для задач 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="Gemini 3.1 Flash Lite Proxy")

class ChatRequest(BaseModel):
    message: str
    system_prompt: str = "You are a helpful assistant."
    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
```

### Пакетная обработка с высокой пропускной способностью

```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]:
    """Классифицировать тексты параллельными пакетами — стоимость около ~$0.001 за 1K текстов."""
    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"Классифицируйте этот текст как POSITIVE, NEGATIVE или NEUTRAL. Ответьте только одним словом.\n\nТекст: {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

# Пример
texts = ["Отличный продукт!", "Ужасный сервис.", "Пожалуй, нормально."]
labels = asyncio.run(batch_classify(texts))
print(list(zip(texts, labels)))
```

## Вариант B: open-source альтернативы (самостоятельное размещение на Clore.ai)

Если вам нужен полностью локальный инференс без затрат на API, эти модели соответствуют Gemini 3.1 Flash Lite в уровне «быстро/дёшево»:

### Gemma 3 4B (лёгкая открытая модель Google)

```bash
# Работает на любом GPU с 6 ГБ+ VRAM — даже 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 "Объясни квантовую запутанность простыми словами."
```

### Qwen3.5 7B (быстрее, выше качество для своего размера)

```bash
docker exec -it $(docker ps -q) ollama pull qwen3.5:7b
# ~3.8 ГБ VRAM, ~45 ток/с на RTX 3080
```

### Сравнение скорости на оборудовании Clore.ai

| Модель                      | VRAM  | Токенов/с (RTX 4090) | Стоимость/1M токенов (Clore.ai)                |
| --------------------------- | ----- | -------------------- | ---------------------------------------------- |
| Gemini 3.1 Flash Lite (API) | Н/Д   | \~200 (API)          | \~$0.25 на ввод / $1.50 на вывод за 1M токенов |
| Gemma 3 4B (локально)       | 4 ГБ  | 95 ток/с             | \~$0.002 (при $2/ч)                            |
| Qwen3.5 7B (локально)       | 8 ГБ  | 78 ток/с             | \~$0.005 (при $2/ч)                            |
| Gemma 3 12B (локально)      | 12 ГБ | 55 ток/с             | \~$0.008 (при $2/ч)                            |
| Gemma 3 27B (локально)      | 20 ГБ | 32 ток/с             | \~$0.014 (при $2/ч)                            |

> **Вывод:** Для задач с большим объёмом (>100 млн токенов/месяц) самостоятельное размещение Gemma 3 / Qwen3.5 на Clore.ai **в 35–50 раз дешевле** чем Gemini API.

## Развернуть на Clore.ai

### Рекомендуемый GPU для задач уровня Flash Lite

| Сценарий использования     | Рекомендуемый GPU         | Цена на Clore.ai |
| -------------------------- | ------------------------- | ---------------- |
| API-прокси / автоматизация | GPU не нужен (CPU-сервер) | \~$0.05/ч        |
| Локальная модель 4B        | RTX 3060 12GB             | \~$0.25/ч        |
| Локальная модель 7B        | RTX 3080 10GB             | \~$0.35/ч        |
| Локальная модель 27B       | RTX 4090 24GB             | \~$1.20/ч (spot) |

### Запуск Ollama в один клик на Clore.ai

В панели управления Clore.ai выберите **Ollama** из шаблонов:

```bash
# Или вручную через SSH:
curl -fsSL https://ollama.com/install.sh | sh
ollama serve &
ollama pull gemma3:4b
ollama run gemma3:4b
```

## Сценарии использования, лучше всего подходящие для уровня Flash Lite

1. **Слой извлечения RAG** — быстрая ранжировка контекста, а не финальная генерация
2. **Ответы чат-бота в реальном времени** — менее 200 мс для коротких запросов
3. **Классификация документов** — обрабатывайте тысячи документов в минуту
4. **Автодополнение кода** — генерация подсказок с низкой задержкой
5. **Пайплайны перевода** — пакетный перевод контента с низкой стоимостью
6. **Модерация контента** — классификация пользовательского контента в масштабе

## Калькулятор стоимости

| Ежемесячный объём | Стоимость Google API | Clore.ai (Gemma 3 4B)          |
| ----------------- | -------------------- | ------------------------------ |
| 10 млн токенов    | \~$8.75              | \~$3.60 (50 ч/мес RTX 3060)    |
| 100 млн токенов   | \~$7.00              | \~$3.60 (непрерывно)           |
| 1 млрд токенов    | \~$70.00             | \~$26 (непрерывно на RTX 3060) |

> При объёмах выше \~200 млн токенов/месяц самостоятельное размещение на Clore.ai оказывается дешевле, чем стоимость Gemini API.

## Мониторинг использования API

```python
# Отслеживайте использование и затраты Gemini API
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)
    
    # Запись использования в лог
    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

# Использование
result = tracked_generate("Какова столица Франции?")
print(result)
```

## Связанные руководства

* [Gemma 3 на Clore.ai](/guides/guides_v2-ru/yazykovye-modeli/gemma3.md) — open-source семейство моделей Google
* [Руководство по Ollama](/guides/guides_v2-ru/yazykovye-modeli/ollama.md) — запускайте любую LLM локально одной командой
* [RAGFlow](/guides/guides_v2-ru/rag-i-vektornye-bazy-dannykh/ragflow.md) — RAG-пайплайн, который хорошо работает с быстрыми моделями
* [Обслуживание vLLM](/guides/guides_v2-ru/yazykovye-modeli/vllm.md) — высокопроизводительный сервер, совместимый с OpenAI
* [Сравнение GPU](/guides/guides_v2-ru/nachalo-raboty/gpu-comparison.md) — найдите самый дешёвый GPU под ваши задачи

***

*Последнее обновление: 16 марта 2026 | Gemini 3.1 Flash Lite выпущен: 3 марта 2026 | Веса: только 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-ru/yazykovye-modeli/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.