> ## Documentation Index
> Fetch the complete documentation index at: https://speshu.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Как работать с медиа

> Как передавать изображения, документы, аудио и видео в запросах к AI моделям

В запросы к моделям SpeShu.AI можно передавать не только текст, но и файлы: изображения, документы, аудио и видео.

<Note>
  Поддержка конкретного типа данных зависит от модели. Перед использованием проверьте поле `input_modalities` в каталоге моделей.
</Note>

## Какие файлы можно передавать

| Тип         | Форматы              |
| ----------- | -------------------- |
| Изображения | PNG, JPEG, GIF, WebP |
| Документы   | PDF, DOCX, TXT       |
| Аудио       | MP3, WAV, FLAC, M4A  |
| Видео       | MP4, MOV, WebM       |

## Способы передачи

### 1. URL файла

Самый простой вариант — указать публичную ссылку на файл:

```typescript theme={null}
const completion = await openai.chat.completions.create({
  model: 'openai/gpt-5.5',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Что изображено на этой картинке?' },
        { type: 'image_url', image_url: { url: 'https://example.com/image.jpg' } }
      ]
    }
  ]
});
```

```python theme={null}
completion = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Что изображено на этой картинке?"},
                {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
            ]
        }
    ]
)
```

```bash theme={null}
curl -X POST "https://speshu.ai/api/v1/chat/completions" \
  -H "Authorization: Bearer <SPESHU_AI_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.5",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "Что изображено на этой картинке?"},
          {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
        ]
      }
    ]
  }'
```

### 2. Base64

Если файл хранится локально, его можно закодировать в Base64 и передать прямо в запросе.

```typescript theme={null}
import * as fs from 'fs';

const imageBuffer = fs.readFileSync('local-image.jpg');
const base64Image = imageBuffer.toString('base64');

const completion = await openai.chat.completions.create({
  model: 'openai/gpt-5.5',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Опиши это изображение' },
        {
          type: 'image_url',
          image_url: { url: `data:image/jpeg;base64,${base64Image}` }
        }
      ]
    }
  ]
});
```

```python theme={null}
import base64

with open("local-image.jpg", "rb") as image_file:
    base64_image = base64.standard_b64encode(image_file.read()).decode("utf-8")

completion = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Опиши это изображение"},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}
                }
            ]
        }
    ]
)
```

### 3. Загрузка в хранилище

Для крупных файлов удобнее сначала загрузить файл в хранилище SpeShu.AI, а затем передать в запрос полученную ссылку.

<Note>
  Хранилище подходит для изображений, видео и аудио. Документы PDF, DOCX и TXT передаются через Base64.
</Note>

```typescript theme={null}
// 1. Загрузка изображения в хранилище
const formData = new FormData();
formData.append('file', fileBlob, 'photo.jpg');
formData.append('purpose', 'assistants');

const uploadResponse = await fetch('https://speshu.ai/api/v1/storage/upload', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <SPESHU_AI_API_KEY>' },
  body: formData
});

const { url } = await uploadResponse.json();

// 2. Использование URL файла в запросе
const completion = await openai.chat.completions.create({
  model: 'openai/gpt-5.5',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Что изображено на этой фотографии?' },
        {
          type: 'image_url',
          image_url: { url }
        }
      ]
    }
  ]
});
```

```python theme={null}
# 1. Загрузка изображения в хранилище
with open("photo.jpg", "rb") as f:
    upload_response = requests.post(
        "https://speshu.ai/api/v1/storage/upload",
        headers={"Authorization": "Bearer <SPESHU_AI_API_KEY>"},
        files={"file": ("photo.jpg", f, "image/jpeg")},
        data={"purpose": "assistants"}
    )

file_url = upload_response.json()["url"]

# 2. Использование URL файла в запросе
completion = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Что изображено на этой фотографии?"},
                {
                    "type": "image_url",
                    "image_url": {"url": file_url}
                }
            ]
        }
    ]
)
```

## Изображения

### Поддерживаемые форматы

| Формат | Описание                       |
| ------ | ------------------------------ |
| PNG    | удобно для скриншотов          |
| JPEG   | подходит для фотографий        |
| GIF    | используется первый кадр       |
| WebP   | современный формат изображений |

### Детализация изображения

Параметр `detail` задаёт уровень обработки изображения:

| Значение | Результат                |
| -------- | ------------------------ |
| `auto`   | выбирается автоматически |
| `low`    | быстрее и дешевле        |
| `high`   | точнее, но дороже        |

```json theme={null}
{
  "type": "image_url",
  "image_url": {
    "url": "https://example.com/image.jpg",
    "detail": "high"
  }
}
```

### Несколько изображений

```typescript theme={null}
const completion = await openai.chat.completions.create({
  model: 'openai/gpt-5.5',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Сравни эти два изображения' },
        { type: 'image_url', image_url: { url: 'https://example.com/image1.jpg' } },
        { type: 'image_url', image_url: { url: 'https://example.com/image2.jpg' } }
      ]
    }
  ]
});
```

```python theme={null}
completion = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Сравни эти два изображения"},
                {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}},
                {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}}
            ]
        }
    ]
)
```

## Документы

Документы на вход поддерживаются не всеми моделями. Перед запросом проверьте `input_modalities` у выбранной модели. Для PDF также можно использовать плагин file-parser.

Для PDF, DOCX и TXT используется тип `file`:

```typescript theme={null}
import * as fs from 'fs';

const pdfBuffer = fs.readFileSync('report.pdf');
const base64Pdf = pdfBuffer.toString('base64');

const completion = await openai.chat.completions.create({
  model: 'openai/gpt-5.5',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Кратко перескажи содержание документа' },
        {
          type: 'file',
          file: {
            filename: 'report.pdf',
            file_data: `data:application/pdf;base64,${base64Pdf}`
          }
        }
      ]
    }
  ]
});
```

```python theme={null}
import base64

with open("report.pdf", "rb") as f:
    base64_pdf = base64.standard_b64encode(f.read()).decode("utf-8")

completion = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Кратко перескажи содержание документа"},
                {
                    "type": "file",
                    "file": {
                        "filename": "report.pdf",
                        "file_data": f"data:application/pdf;base64,{base64_pdf}"
                    }
                }
            ]
        }
    ]
)
```

### Форматы документов

| Формат | MIME-тип                                                                |
| ------ | ----------------------------------------------------------------------- |
| PDF    | application/pdf                                                         |
| DOCX   | application/vnd.openxmlformats-officedocument.wordprocessingml.document |
| TXT    | text/plain                                                              |

## Аудио

Аудио передаётся через `input_audio` в Base64.

```typescript theme={null}
import * as fs from 'fs';

const audioBuffer = fs.readFileSync('recording.wav');
const base64Audio = audioBuffer.toString('base64');

const completion = await openai.chat.completions.create({
  model: 'openai/gpt-5.5',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Что говорит человек на этой записи?' },
        {
          type: 'input_audio',
          input_audio: {
            data: base64Audio,
            format: 'wav'
          }
        }
      ]
    }
  ]
});
```

```python theme={null}
import base64

with open("recording.wav", "rb") as f:
    base64_audio = base64.standard_b64encode(f.read()).decode("utf-8")

completion = client.chat.completions.create(
    model="openai/gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Что говорит человек на этой записи?"},
                {
                    "type": "input_audio",
                    "input_audio": {
                        "data": base64_audio,
                        "format": "wav"
                    }
                }
            ]
        }
    ]
)
```

Поддерживаемые значения `format`:

| Формат | Значение `format` |
| ------ | ----------------- |
| WAV    | `wav`             |
| MP3    | `mp3`             |
| FLAC   | `flac`            |
| M4A    | `m4a`             |

## Видео

Видео через `video_url` поддерживается только моделями Gemini. В качестве ссылки принимается YouTube URL.

Для передачи видео используйте тип `video_url`:

```typescript theme={null}
const completion = await openai.chat.completions.create({
  model: 'google/gemini-3.1-pro',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Опиши что происходит в этом видео' },
        {
          type: 'video_url',
          video_url: { url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ' }
        }
      ]
    }
  ]
});
```

```python theme={null}
completion = client.chat.completions.create(
    model="google/gemini-3.1-pro",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Опиши что происходит в этом видео"},
                {
                    "type": "video_url",
                    "video_url": {"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"}
                }
            ]
        }
    ]
)
```

## Рекомендации

**Сжимайте изображения перед отправкой:** большие файлы дольше обрабатываются и могут стоить дороже. Если высокая детализация не нужна, используйте `detail: "low"`.

**Выбирайте формат под задачу:** PNG — для скриншотов и графики, JPEG — для фото, PDF — для документов.

**Перед отправкой файла проверьте, поддерживает ли модель нужный тип входных данных.** Это можно сделать через `/v1/models`:

```bash theme={null}
curl https://speshu.ai/api/v1/models | jq '.data[] | select(.architecture.input_modalities | contains(["image"]))'
```

**В промпте лучше сразу писать, что именно нужно сделать с файлом:** описать изображение, сравнить два файла, извлечь данные из документа или пересказать запись.

**Для файлов больше нескольких мегабайт используйте загрузку через `/v1/storage/upload`,** а в запрос передавайте полученный URL.
