ChatGPT — нейросети в разработке

ChatGPT — это языковая модель, которая генерирует текст: отвечает на вопросы, пишет и объясняет код, придумывает тесты и документацию. Хороший инженер использует нейросеть как мощного ассистента — но всегда проверяет её ответы.

1. Что такое ChatGPT и GPT

GPT (Generative Pre-trained Transformer) — архитектура нейросети. Модель обучается на огромном объёме текста и предсказывает следующее слово, поэтому умеет писать связный код и тексты.

2. Возможности для разработчика

• генерация кода по описанию;
• объяснение непонятных фрагментов;
• отладка и поиск багов;
• написание unit-тестов и документации;
• рефакторинг и перевод на другой язык;
• генерация запросов SQL, конфигураций YAML, Dockerfile и т.д.

3. Как правильно писать промпты

Хороший промпт содержит роли, контекст, цель и ограничения.

«Ты — опытный Python-разработчик. Напиши функцию,
которая принимает список чисел и возвращает сумму
чётных. Требования: Python 3.11, без сторонних библиотек,
добавь докстринг. Сначала покажи функцию, потом пример вызова.»

4. Чек-лист перед запросом

1. определи цель одним предложением;
2. укажи язык, версию и стек;
3. ограничь объём («только код, без объяснений»);
4. приведи пример входных и выходных данных;
5. попроси объяснить решение, а не только дать ответ.

5. Генерация кода

Чем точнее условие, тем лучше результат. Плохо:

«Напиши парсер CSV»

Хорошо:

«Напиши на Python 3.11 функцию parse_csv(path: str) -> list[dict],
которая читает CSV с заголовками, умеет quotes и запятые в полях,
возвращает список словарей. Использовать только стандартную библиотеку.
Добавь обработку ошибок и docstring.»

6. Отладка и объяснение

«Вот код и traceback. Объясни, почему возникает ошибка,
и предложи исправление. Объясни на пальцах:»

[вставь код и ошибку]

7. Тесты и документация

«Сгенерируй pytest-тесты для этой функции. Покрой:
обычный случай, пустой ввод, граничные значения, исключения.»

Полезно также просить написать README, комментарии к непонятным местам и примеры Dockerfile — модель хорошо знает типовые паттерны из Docker, Kubernetes и Terraform.

8. Ограничения и риски

• модель может «уверенно» врать (галлюцинации);
• не отправляй в чат секреты, ключи и личные данные клиентов;
• изучи и проверяй каждый фрагмент перед запуском;
• не полагайся на неё в задачах, требующих сертификации или ответственности.

9. Работа через API

Из приложения нейросеть вызывается через API. Пример на Python:

from openai import OpenAI

client = OpenAI(api_key="sk-...")

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Ты — тестировщик."},
        {"role": "user", "content": "Придумай 5 кейсов для формы логина."},
    ]
)
print(response.choices[0].message.content)

10. Альтернативы и экосистема

11. Управление контекстом

Модель «помнит» только ограниченный кусок переписки — контекстное окно. Чем длиннее диалог, тем больше внимания уходит «в прошлое», а ранние правки начинают вытесняться. Поэтому важные требования держат в одном месте, а не размазывают по репликам.

• задавай ключевые условия повторно перед новой подзадачей;
• устаревшие ветки диалога закрывай и начинай новую тему заново;
• длинный код выноси в конец сообщения, а задание — в начало;
• при сбое требований начни новый чат и вставь сводку из старого.

12. Function calling и инструменты

Через API модели можно дать набор функций, чтобы она не сочиняла ответ, а вызывала ваш код. Схема проста: приложение описывает функции JSON-схемой, модель возвращает имя и аргументы вызова, а приложение выполняет его и возвращает результат.

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"]
        }
    }
}]

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Погода в Москве?"}],
    tools=tools,
)

13. Интеграция в приложение

Нейросеть подключается к сервису через API: клиентский код формирует сообщения, а сервер возвращает ответ. Ниже типичный цикл: системный промпт, пользовательский запрос и разбор ответа.

from openai import OpenAI

client = OpenAI()

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "Ты — ассистент службы поддержки."},
        {"role": "user", "content": "Как вернуть заказ?"},
    ],
    temperature=0.3,
    max_tokens=300,
)
print(resp.choices[0].message.content)

14. RAG: ответы по своей базе знаний

RAG (Retrieval-Augmented Generation) — способ отвечать по вашим документам: система находит релевантные фрагменты, кладёт их в промпт, и модель отвечает, опираясь на них, а не на «общие знания».

1. разбей документы на куски и сложи в векторное хранилище;
2. по запросу найди ближайшие фрагменты (косинусная близость);
3. собери системный промпт из найденных отрывков;
4. отдай моделью ответ с цитатами-источниками.

15. Токены и стоимость запросов

Модель «считает» текст не по символам, а по токенам — фрагментам слов. Кириллица тяжелее латиницы: один токен покрывает меньше символов:

# грубая оценка
tokens ≈ len(text) / 4    # английский
tokens ≈ len(text) / 1.5  # русский и сложные слова

В тариф входят и токены запроса, и токены ответа, поэтому дороже всего — длинные системные промпты и большие вложения в RAG:

16. Fine-tuning: когда он нужен

Если промптинг и RAG исчерпали себя, модель можно дообучить на своих примерах. Подготовь размеченный датасет в JSONL, где каждая строка — диалог целиком:

{"messages": [
  {"role": "system", "content": "Ты — бот юридической поддержки."},
  {"role": "user", "content": "Сгорела и товар. Что делать?"},
  {"role": "assistant", "content": "Подайте заявление по ст. 18 Закона о защите прав потребителей…"}
]}

• 20–100 качественных пар хватает для заметного сдвига стиля;
• приоритет — формат ответа и правила, с которыми промпт не справляется;
• после обучения прогони офлайн-эвалюацию на отложенной выборке.

17. Чек-лист внедрения ИИ в продукт

Перед релизом фичи с LLM пройди по короткому списку:

• явная цель и метрика успеха (доля решённых обращений, время ответа);
• fallback при сбое API — человек или статичный ответ;
• ограничения: длина, температура, бюджет на пользователя;
• логирование запросов и ответов со степенью уверенности;
• запрет на автономные действия без подтверждения (платежи, удаление);
• ручное ревью на выборке ответов.

def handle(user_text):
    if not safe(user_text):
        return transfer_to_human(user_text)
    answer = chat(user_text, max_tokens=300)
    if answer.confidence < 0.5:
        return transfer_to_human(answer)
    return answer

18. Кейс: чат-бот службы поддержки

Соберём типовое решение: классификация темы → ответ по базе знаний → эскалация:

1. сервис классифицирует интент (возврат, статус, рекламация);
2. для темы из базы — RAG по инструкциям и ответ с цитатой;
3. если уверенность низкая или запрос содержит маркеры риска — перевод оператору;
4. каждый инцидент пишется в лог для еженедельного разбора.

19. Системные промпты: роль и формат ответа

Системный промпт — это «инструкция сотруднику», которая действует на весь диалог. Задай роль, границы и формат вывода:

"role": "system",
"content": "Ты — техлид по Python. Проверяй код
на утечки, гонки и небезопасные API. Отвечай
нумерованным списком замечаний с приоритетом P1–P3.",
"temperature": 0.2

Низкая temperature (0–0.3) убирает «фантазии» в фактологической работе, высокая (0.7+) нужна для брейншторма. Формат ответа фиксируй явно: таблица, JSON, Markdown-список — это упрощает парсинг и автотесты.

• роль и тон задавай до задачи, а не после;
• примеры «плохо» и «хорошо» работают лучше абстрактных правил;
• не держи секреты в промпте — история диалога бывает видна пользователю.

20. Оценка качества ответов и автотесты

Голое «вроде работает» не переживёт прода. Построй контур оценки из трёх уровней:

1. автоматические проверки — валидация ответа: JSON, длина, запрещённые слова;
2. тесты-наборы промптов — золотая выборка вопросов с ожидаемыми критериями;
3. llm-as-a-judge — отдельный вызов модели, который выставляет балл по рубрике.

def check(answer):
    if not isinstance(answer, dict):
        return {"pass": False, "why": "не JSON"}
    if len(str(answer)) < 20:
        return {"pass": False, "why": "слишком короткий"}
    return {"pass": True}

Рубрика для судьи: полнота, корректность, формат, отсутствие галлюцинаций. Прогоняй выборку при каждом изменении промпта и храни результаты в таблице.

21. Кэширование ответов и снижение стоимости

Одинаковые вопросы и повторные вызовы жгут токены. Кэш убирает до 80% повторных запросов:

# точное совпадение: хэш канонизированного промпта
key = sha256((system + "|" + user).encode())
cached = redis.get(key)
if cached: return cached

• семантический кэш — эмбеддинг запроса сравнивается с близкими (косинусная дистанция);
• не кэшируй ответы с ошибками и чувствительные данные;
• проставляй TTL: кэш — это скорость, а не хранилище фактов.

Второй рычаг — короткие ответы: точный max_tokens и стриминг, чтобы пользователь не ждал полной генерации.

22. Кейс: безопасный пилот на проде

Пилот влезает в продукт через канареечный зазор, а не через дверь. Типичный план:

1. запуск на 5% трафика под фича-флагом;
2. A/B против базовой логики: эскалация, время ответа, CSAT;
3. логирование промптов и ответов с ID сессии;
4. автоматический откат при росте ошибок выше порога.

Что дальше

Применяй нейросети вместе с курсами: генерируй тесты для pytest и JUnit, конфиги для Docker и Terraform. Обзор всех уроков — на главной странице.

← Вернуться к курсам