> 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** По состоянию на март 2026 года это самая дешёвая и быстрая production-модель Google, выпущенная 3 марта 2026 года. Это уровень Gemini 3.1, оптимизированный для API, — рассчитанный на высокопроизводительные и чувствительные к стоимости задачи, такие как чат-боты в реальном времени, пайплайны классификации и слои извлечения 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)
* **Вывод**: до 8 тыс. токенов на запрос
* **Задержка**: \~120 мс до первого токена для коротких запросов (API)
* **Архитектура**: дистиллирована из Gemini 3.1 Pro с помощью спекулятивного декодирования

> **Примечание:** Gemini 3.1 Flash Lite — это **только для API Google** модель — веса публично не опубликованы. Это руководство охватывает (a) использование Google Gemini API на инфраструктуре Clore.ai и (b) сопоставимые 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.03–0.07/час) более чем достаточно для нагрузок 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")

class ChatRequest(BaseModel):
    message: str
    system_prompt: str = "Вы — полезный помощник."
    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 за 1 тыс. текстов."""
    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: альтернативы с открытым исходным кодом (самостоятельное размещение на 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, один поток) | Стоимость за 1 млн выходных токенов         |
| --------------------------- | ----- | -------------------------------- | ------------------------------------------- |
| Gemini 3.1 Flash Lite (API) | Н/Д   | \~200 (API)                      | \~$0.25 вход / $1.50 выход за 1 млн токенов |
| Gemma 3 4B (локально)       | 4 ГБ  | 95 ток/с                         | \~$0.58 (RTX 4090 при $0.20/час)            |
| Qwen3.5 7B (локально)       | 8 ГБ  | 78 ток/с                         | \~$0.71                                     |
| Gemma 3 12B (локально)      | 12GB  | 55 ток/с                         | \~$1.01                                     |
| Gemma 3 27B (локально)      | 20 ГБ | 32 ток/с                         | \~$1.74                                     |

> **Вывод:** при обработке по одному запросу за раз самостоятельное размещение обходится примерно так же, как API. Выигрыш приходит за счёт **пакетирования**: при обслуживании одновременных запросов через vLLM или SGLang совокупная пропускная способность на той же 4090 возрастает в несколько раз, и стоимость за миллион токенов снижается вместе с ней. Разворачивайте самостоятельно, когда у вас стабильный параллельный объём; используйте API для всплескового трафика с небольшим объёмом.

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

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

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

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

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

```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) — семейство моделей с открытым исходным кодом от 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.