Ты уже умеешь собирать агента вручную — писать цикл, подключать инструменты, обрабатывать ответы. Это важно для понимания. Но в реальной работе никто не собирает всё с нуля каждый раз. Для этого существуют SDK — готовые библиотеки, которые берут рутину на себя.
SDK — это аббревиатура: Software Development Kit (набор для разработки программ).
Звучит абстрактно. Но на самом деле ты уже пользовалась SDK — просто не знала, что это так называется.
В уроке 2.3 ты писала такой код:
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Привет"}]
)
print(response.content[0].text)
Вот эта библиотека anthropic — это и есть SDK. Она делает за тебя кучу работы, которую ты даже не замечаешь.
Без библиотеки anthropic тот же самый запрос к Claude выглядел бы так:
import requests
response = requests.post(
"https://api.anthropic.com/v1/messages", # нужно знать точный URL
headers={
"x-api-key": "sk-ant-...", # нужно вручную передавать ключ
"anthropic-version": "2023-06-01", # нужно знать версию API
"Content-Type": "application/json" # нужно указывать формат
},
json={
"model": "claude-sonnet-4-5",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Привет"}]
}
)
result = response.json() # нужно самому разбирать JSON
# Нужно самому проверять ошибки
if response.status_code != 200:
print(f"Ошибка: {result}")
else:
print(result["content"][0]["text"]) # нужно знать структуру ответа
Сравни:
Без SDK (вручную): С SDK (библиотека anthropic):
────────────────── ─────────────────────────────
Знать URL сервера → SDK знает сам
Передавать API-ключ в заголовках → SDK делает сам
Указывать версию API → SDK делает сам
Разбирать JSON-ответ → SDK возвращает объект
Проверять ошибки → SDK бросает исключение
SDK = библиотека-переводчик. Ты говоришь на простом Python (client.messages.create(...)), а SDK переводит это в HTTP-запрос, отправляет на сервер, получает ответ и возвращает тебе готовый результат.
SDK — как переводчик при встрече с иностранцем:
Без переводчика (без SDK):
Ты → учишь иностранный язык → говоришь сам → понимаешь ответ сам
С переводчиком (с SDK):
Ты → говоришь по-русски → переводчик переводит → слушает ответ →
переводит обратно → ты получаешь ответ по-русски
Ты говоришь на Python. Сервер Claude понимает HTTP-запросы. SDK переводит между ними.
SDK — не уникальная штука Claude. Почти каждый крупный сервис даёт свой SDK — готовую библиотеку, чтобы с ним было проще работать:
| Сервис | Их SDK | Что делает |
|---|---|---|
| Telegram | python-telegram-bot |
Создавать ботов проще |
googlemaps |
Работать с картами проще | |
| Anthropic | anthropic |
Отправлять запросы к Claude проще |
| Anthropic | claude-agent-sdk |
Создавать AI-агентов проще |
Обрати внимание: у Anthropic два SDK:
anthropic (урок 2.3) claude-agent-sdk (этот урок)
───────────────────── ─────────────────────────────
Базовый SDK SDK для агентов
Отправляет запросы к Claude Создаёт агентов с инструментами
Цикл пишешь сам Цикл автоматический
Инструменты пишешь сам 10 готовых инструментов
Без защиты Встроенная безопасность
Первый SDK (anthropic) — это то, что ты уже знаешь из уроков 2.3 и 3.2. Ты отправляешь запросы, пишешь цикл, подключаешь инструменты вручную.
Второй SDK (claude-agent-sdk) — это надстройка, которая делает создание агентов ещё проще. Цикл, инструменты, безопасность — всё уже внутри.
Давай вспомним, сколько кода нужно для агента вручную (из урока 3.2):
# Вручную — через базовый SDK anthropic:
import anthropic
client = anthropic.Anthropic()
# 1. Описать инструменты (JSON-схемы — 10+ строк на каждый)
tools = [{"name": "get_weather", "description": "...", "input_schema": {...}}]
# 2. Написать реальные функции
def get_weather(city):
return f"В {city} солнечно"
# 3. Создать маппинг (имя → функция)
tool_functions = {"get_weather": get_weather}
# 4. Написать цикл
messages = [{"role": "user", "content": "Какая погода?"}]
while True:
response = client.messages.create(
model="claude-sonnet-4-5", max_tokens=1024,
tools=tools, messages=messages
)
if response.stop_reason == "end_turn":
break
for block in response.content:
if block.type == "tool_use":
result = tool_functions[block.name](block.input)
messages.append({"role": "assistant", "content": response.content})
messages.append({"role": "user", "content": [
{"type": "tool_result", "tool_use_id": block.id, "content": result}
]})
~30 строк, и это ещё без обработки ошибок.
А вот тот же агент через Agent SDK:
# Через Agent SDK:
from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage
async for message in query(
prompt="Какая погода в Москве?",
options=ClaudeAgentOptions(allowed_tools=["WebSearch"])
):
if isinstance(message, ResultMessage):
print(message.result)
7 строк. И не нужно писать функцию get_weather — SDK даёт готовый инструмент WebSearch, который сам ищет в интернете.
Что делалось вручную: Что Agent SDK делает сам:
────────────────────── ──────────────────────────
Писать while True цикл → Цикл работает автоматически
Проверять stop_reason → Проверяет сам
Описывать tools в JSON → 10 готовых инструментов
Писать функции для tools → Функции уже написаны
Создавать маппинг → Маппинг не нужен
Обрабатывать ошибки → Обрабатывает сам
Думать о безопасности → Встроенная защита
pip install claude-agent-sdk
Для работы нужен API-ключ Anthropic (из урока 2.3):
export ANTHROPIC_API_KEY="sk-ant-..."
import anyio
from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage
async def main():
async for message in query(
prompt="Найди все Python-файлы в текущей папке и объясни, что делает каждый",
options=ClaudeAgentOptions(
cwd=".", # рабочая папка (текущая)
allowed_tools=["Read", "Glob", "Grep"] # какие инструменты дать агенту
)
):
if isinstance(message, ResultMessage):
print(message.result)
anyio.run(main)
import anyio
from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage
Импортируем из SDK три вещи:
- query — функция, которая запускает агента
- ClaudeAgentOptions — настройки агента (что ему можно, где работать)
- ResultMessage — тип сообщения с финальным ответом
async def main():
async def вместо обычного def — это особый вид функции для задач, которые занимают время (запросы к API). Пока не нужно понимать глубоко — просто используй как шаблон для работы с SDK.
async for message in query(
prompt="Найди все Python-файлы...",
query() — запуск агента. prompt — задача, которую даём агенту.
options=ClaudeAgentOptions(
cwd=".",
allowed_tools=["Read", "Glob", "Grep"]
)
Настройки:
- cwd — рабочая папка агента (. = текущая папка)
- allowed_tools — список инструментов, которые агент может использовать
):
if isinstance(message, ResultMessage):
print(message.result)
Агент присылает разные сообщения по ходу работы. Нас интересует финальный результат — ResultMessage.
anyio.run(main)
Запускает async функцию. Это аналог обычного вызова main(), но для асинхронных функций:
# Обычная функция: Асинхронная функция (для SDK):
def main(): async def main():
print("Привет") print("Привет")
main() anyio.run(main)
После запуска агент сам решает, как выполнить задачу:
1. Использует Glob → находит все .py файлы
2. Использует Read → открывает каждый файл
3. Анализирует код → пишет объяснение
4. Возвращает ResultMessage с ответом
Никакого while True, никакого stop_reason, никакого маппинга. SDK делает всё это внутри.
SDK идёт с 10 готовыми инструментами. Их не нужно описывать в JSON, не нужно писать функции — они работают сразу:
| Инструмент | Что делает | Пример |
|---|---|---|
| Read | Читает файлы | Прочитать config.py |
| Write | Создаёт новые файлы | Создать report.txt |
| Edit | Редактирует файлы | Исправить ошибку в строке 15 |
| Bash | Выполняет команды терминала | Запустить python test.py |
| Glob | Ищет файлы по паттерну | Найти все *.py файлы |
| Grep | Ищет текст внутри файлов | Найти все вызовы api_key |
| WebSearch | Ищет в интернете | Найти документацию |
| WebFetch | Загружает веб-страницу | Прочитать страницу на GitHub |
| AskUserQuestion | Спрашивает у пользователя | Уточнить задачу |
| Agent | Создаёт под-агента | Делегировать часть работы |
Помнишь из урока 3.2 — чтобы дать агенту один инструмент, нужно было написать JSON-схему (10+ строк) и реальную функцию? В SDK эти инструменты уже готовы. Просто указываешь имя в allowed_tools.
Правило из урока 3.2 работает и здесь: давай только те инструменты, которые нужны для задачи.
# Только чтение — агент может смотреть, но не менять
allowed_tools=["Read", "Glob", "Grep"]
# Чтение + редактирование — агент может изменять файлы
allowed_tools=["Read", "Edit", "Write"]
# Полный доступ (осторожно! агент может запускать команды)
allowed_tools=["Read", "Edit", "Write", "Bash", "Glob", "Grep"]
В ручном агенте (урок 3.2) безопасности не было — агент делал всё, что мог. В SDK есть встроенная защита:
| Режим | Как работает | Когда использовать |
|---|---|---|
"default" |
Спрашивает перед опасными действиями | Обычная работа |
"plan" |
Только составляет план, не выполняет | Когда хочешь сначала посмотреть план |
"acceptEdits" |
Автоматически разрешает изменения файлов | Когда доверяешь агенту |
# Агент в режиме "только план"
options = ClaudeAgentOptions(
allowed_tools=["Read", "Edit", "Glob"],
permission_mode="plan"
)
# Агент скажет: "Я бы открыл файл X, нашёл ошибку Y, исправил Z"
# Но НЕ сделает это — только покажет план
Это как разница между "нарисуй план ремонта" и "делай ремонт". Иногда полезно сначала посмотреть, что агент собирается делать.
| Что нужно | Вручную (урок 3.2) | Через Agent SDK |
|---|---|---|
| Агентный цикл | Пишешь сам: while True, stop_reason |
Автоматически |
| Инструменты | Описываешь JSON + пишешь функцию | 10 готовых, просто указываешь имя |
| Безопасность | Нет | Встроенные режимы |
| Количество кода | ~30–50 строк | ~7 строк |
| Гибкость | Максимальная — контролируешь всё | Меньше — SDK решает за тебя |
Хочу понять, как агент работает внутри → Ручной цикл (урок 3.2)
Хочу быстро сделать работающего агента → Agent SDK
Нужен максимальный контроль → Ручной цикл
Стандартная задача (файлы, поиск) → Agent SDK
Создай файл my_agent.py и запусти агента, который читает файлы:
import anyio
from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage
async def main():
async for message in query(
prompt="Какие файлы есть в текущей папке? Опиши каждый кратко.",
options=ClaudeAgentOptions(
cwd=".",
allowed_tools=["Read", "Glob"]
)
):
if isinstance(message, ResultMessage):
print(message.result)
anyio.run(main)
Добавь permission_mode="plan" и запусти снова. Сравни: агент покажет, что он собирается делать, но не выполнит.
options = ClaudeAgentOptions(
cwd=".",
allowed_tools=["Read", "Glob"],
permission_mode="plan"
)
Создай агента, который ищет информацию в интернете:
async def main():
async for message in query(
prompt="Найди, какая сейчас погода в Москве",
options=ClaudeAgentOptions(
allowed_tools=["WebSearch", "WebFetch"]
)
):
if isinstance(message, ResultMessage):
print(message.result)
Задача 1: Что такое SDK? Объясни своими словами.
Задача 2: В чём разница между pip install anthropic и pip install claude-agent-sdk?
Задача 3: Что делает permission_mode="plan"?
Задача 4: Агенту нужно только читать файлы для анализа. Какие инструменты дать?
| Термин | Что значит |
|---|---|
| SDK | Software Development Kit — готовая библиотека от создателей сервиса, которая упрощает работу с ним |
| Claude Agent SDK | SDK от Anthropic специально для создания AI-агентов |
query() |
Функция SDK, которая запускает агента |
ClaudeAgentOptions |
Настройки агента (инструменты, папка, режим безопасности) |
ResultMessage |
Финальный ответ агента |
allowed_tools |
Список инструментов, которые агент может использовать |
permission_mode |
Режим безопасности (default, plan, acceptEdits) |
cwd |
Current Working Directory — рабочая папка агента |
async/await |
Способ Python работать с задачами, которые требуют ожидания |
anyio.run() |
Функция, которая запускает асинхронную функцию |
SDK = готовая библиотека-переводчик от создателей сервиса.
Ты пишешь простой Python → SDK переводит в запросы к серверу.
anthropic (урок 2.3) — это тоже SDK, ты его уже использовала!
claude-agent-sdk — это SDK для создания агентов (надстройка)
Claude Agent SDK даёт:
✓ Автоматический агентный цикл (не нужен while True)
✓ 10 готовых инструментов (Read, Write, Edit, Bash, Glob, Grep...)
✓ Встроенную безопасность (permission modes)
✓ Запуск агента в 7 строк кода
Вручную (урок 3.2) — чтобы понять, как это работает внутри.
SDK — чтобы быстро делать рабочих агентов.
В следующем уроке — Мульти-шаговые задачи. Агент, который не просто выполняет одно действие, а планирует сложную задачу из нескольких шагов: анализирует → разбивает на части → выполняет по порядку → проверяет результат. Это финальный урок Этапа 3.