Представьте себе обычный компьютер с монитором, клавиатурой и мышью — это полноценный компьютер, который вы видите и с которым взаимодействуете напрямую. Безголовый сервер — это компьютер без монитора и клавиатуры. Он работает в фоне, невидимый для глаз, но выполняет свою работу — обслуживает запросы, запускает программы, хранит данные.
Когда говорят безголовый режим в программировании, это означает, что программа работает как фоновый сервис без красивого интерфейса. Она просто принимает команды через сеть и возвращает результаты. Программа не требует вашего постоянного внимания и взаимодействия — она обслуживает запросы автоматически.
Такой подход широко используется в веб-разработке. Когда вы заходите на любой сайт в интернете, вы взаимодействуете с безголовыми серверами. Вы не видите эти серверы, не нажимаете на них кнопки, но они работают и обрабатывают ваши запросы. Сервер OpenCode работает по тому же принципу — он принимает запросы по сети и возвращает ответы.
Когда вы запускаете команду opencode serve, вы превращаете свой компьютер в сервер искусственного интеллекта. После запуска этой команды OpenCode перестаёт быть интерактивным помощником в терминале и становится HTTP-сервером, который принимает запросы и возвращает ответы.
Базовый запуск сервера выполняется командой:
opencode serve
После запуска вы увидите примерно такое сообщение:
🚀 OpenCode сервер запущен на http://localhost:3000
Это означает, что сервер работает и готов принимать запросы на адресе localhost (это ваш компьютер) через порт 3000. Сервер будет работать в фоне, пока вы не остановите его нажатием Ctrl+C или не закроете терминал.
Если порт 3000 уже используется другой программой, можно указать другой порт:
opencode serve --port 8080
Теперь сервер будет доступен по адресу http://localhost:8080.
HTTP — это протокол, который используют все сайты в интернете. Когда вы вводите адрес сайта в браузере, браузер отправляет HTTP-запрос на сервер, а сервер возвращает веб-страницу. Сервер OpenCode работает по тому же принципу, но вместо веб-страниц он возвращает ответы от искусственного интеллекта.
Процесс работы сервера состоит из нескольких этапов. Сначала клиент — это может быть ваша программа, скрипт или веб-приложение — отправляет HTTP-запрос на адрес сервера OpenCode. Затем сервер OpenCode принимает запрос и обрабатывает его с помощью модели искусственного интеллекта. После обработки сервер возвращает результат в структурированном формате JSON, который легко читается программами.
Весь процесс занимает доли секунды, потому что модель искусственного интеллекта уже загружена в память сервера. В обычном режиме OpenCode загружает модель каждый раз при новом запросе, что занимает от 5 до 30 секунд. Серверный режим избавляет вас от этого ожидания.
Представьте, что вы создаёте веб-сайт с вопросами и ответами. Без сервера OpenCode ваш сайт не может использовать искусственный интеллект, потому что у него нет доступа к модели. С сервером OpenCode ваш сайт может отправлять запросы к локальному серверу и получать ответы.
Приведём пример на языке JavaScript для веб-приложения. Допустим, у вас есть сайт и вы хотите добавить функцию вопросов к искусственному интеллекту. Вы можете отправлять запросы к серверу OpenCode прямо из браузера:
async function спроситьУOpenCode(вопрос) {
const ответ = await fetch('http://localhost:3000/api/chat', {
метод: 'POST',
заголовки: {
'Content-Type': 'application/json'
},
тело: JSON.stringify({
сообщение: вопрос
})
});
const результат = await ответ.json();
return результат.ответ;
}
// Теперь можно использовать на сайте
спроситьУOpenCode("Объясни квантовую физику просто")
.then(console.log);
Этот код отправляет вопрос на сервер OpenCode и получает ответ. Вы можете встроить эту функцию в любой сайт и пользователи смогут общаться с искусственным интеллектом через ваш интерфейс.
Приведём пример на языке Python для бэкенд-приложения. Если вы создаёте серверное приложение на Python, вы можете обращаться к OpenCode из своего кода:
import requests
def спросить_opencode(вопрос):
ответ = requests.post(
'http://localhost:3000/api/chat',
json={'сообщение': вопрос}
)
return ответ.json()['ответ']
# Использование в приложении
ответ = спросить_opencode("Напиши функцию сортировки списка")
print(ответ)
Когда сервер уже запущен, вы можете подключаться к нему для быстрого выполнения запросов без холодного старта. Это делается с помощью команды opencode run --attach. Вам не нужно ждать загрузки модели каждый раз — вы сразу получаете доступ к уже запущенному серверу.
Сначала в одном терминале запустите сервер:
opencode serve
Сервер начнёт работать и принимать запросы. Теперь в другом терминале вы можете подключиться к нему для выполнения запросов:
opencode run --attach http://localhost:3000 "Explain async/await in JavaScript"
Эта команда отправляет запрос на локальный сервер и получает ответ. Вся процедура занимает секунды вместо минут, потому что модель уже загружена в память сервера.
Представьте типичный рабочий день разработчика. Вам нужно быстро получить ответы на несколько вопросов по коду.
Без подключения к серверу — каждый раз ждёте:
Терминал 1:
# Запуск первого запроса — ждём 15 секунд
opencode "Как работает async/await в JavaScript?"
# Запуск второго запроса — снова ждём 15 секунд!
opencode "Чем отличается Promise от async/await?"
# Запуск третьего запроса — снова ждём!
opencode "Покажи пример обработки ошибок в async/await"
Каждый запуск требует загрузки модели — 15 секунд ожидания, потом ответ, снова 15 секунд, снова ответ. На три вопроса уходит почти минута только на ожидание.
С подключением к серверу — мгновенные ответы:
Терминал 1 (сервер запущен один раз):
opencode serve
Терминал 2 (работаем параллельно):
# Первый запрос — 2 секунды
opencode run --attach http://localhost:3000 "Как работает async/await?"
# Второй запрос — 1 секунда
opencode run --attach http://localhost:3000 "Чем отличается Promise от async/await?"
# Третий запрос — мгновенно
opencode run --attach http://localhost:3000 "Покажи пример обработки ошибок"
Всего 5-7 секунд на три запроса вместо 45 секунд. Разница в 10 раз!
Если вы хотите продолжить диалог с сервером в интерактивном режиме, используйте флаг --interactive:
opencode run --attach http://localhost:3000 --interactive
После этого вы сможете отправлять несколько запросов в рамках одной сессии, и контекст будет сохраняться между запросами. Это удобно, когда нужно обсудить сложную тему пошагово.
Вы можете использовать подключение к серверу в скриптах для ещё большего ускорения:
#!/bin/bash
# Скрипт быстрого анализа кода
echo "Анализирую файл main.py..."
opencode run --attach http://localhost:3000 "Проанализируй файл main.py и найди потенциальные ошибки"
echo "Проверяю документацию..."
opencode run --attach http://localhost:3000 "Проверь, есть ли в коде устаревшие комментарии"
echo "Генерирую тесты..."
opencode run --attach http://localhost:3000 "Напиши unit-тесты для функции calculate_total"
Каждый запрос выполняется мгновенно благодаря подключению к работающему серверу.
Одно из главных преимуществ серверного режима — ускорение автоматизации. Когда вы запускаете OpenCode в обычном режиме каждый раз для нового запроса, происходит так называемый холодный старт. Сначала запускается программа OpenCode, затем загружается модель искусственного интеллекта в память, потом обрабатывается запрос и выводится ответ. На всё это может уйти от 5 до 30 секунд.
С сервером OpenCode ситуация меняется кардинально. При первом запуске сервера модель загружается в память один раз. Все последующие запросы обрабатываются мгновенно, потому что модель уже готова. Разница во времени может быть в 100 и более раз.
Приведём сравнение двух подходов на примере скрипта на Python. Без сервера каждый запрос требует ожидания загрузки модели:
import subprocess
def спросить_opencode_обычный(вопрос):
результат = subprocess.run(
['opencode', '--prompt', вопрос],
capture_output=True,
text=True
)
return результат.stdout
# Каждый вызов ждёт 20 секунд
ответ1 = спросить_opencode_обычный("Создай список чисел")
print(ответ1)
ответ2 = спросить_opencode_обычный("Отфильтруй чётные") # Снова ждать!
Со скриптом, который обращается к серверу, всё происходит мгновенно:
import requests
def спросить_opencode_быстро(вопрос):
ответ = requests.post(
'http://localhost:3000/api/chat',
json={'сообщение': вопрос}
)
return ответ.json()['ответ']
# Мгновенные ответы
ответ1 = спросить_opencode_быстро("Создай список чисел")
print(ответ1)
ответ2 = спросить_opencode_быстро("Отфильтруй чётные") # 0.1 секунды!
Если вам нужно выполнить сотни или тысячи запросов, экономия времени будет колоссальной. Вместо часов ожидания вы получите результат за минуты.
По умолчанию OpenCode использует порт 3000 для своего сервера. Порт — это как номер двери в вашем компьютере. Каждый сетевой сервис использует свой порт, чтобы не мешать другим.
Если порт 3000 уже занят другой программой, вы получите сообщение об ошибке при запуске сервера. В этом случае нужно указать другой порт. Выберите любой свободный порт от 1024 до 65535:
# Запустить на порту 8080
opencode serve --port 8080
# Запустить на порту 5000
opencode serve --port 5000
# Запустить на порту 9000
opencode serve --port 9000
Чтобы узнать, какие порты уже используются на вашем компьютере, выполните команду:
# Linux/Mac
netstat -tulpn | grep LISTEN
# Или более современный способ
ss -tulpn
Вы увидите список всех запущенных сервисов и занимаемых ими портов. Выберите свободный порт для запуска сервера OpenCode.
Рассмотрим реальный пример использования сервера OpenCode для автоматизации. Представьте, что у вас есть сервер, который генерирует логи — записи о происходящем. Вы хотите, чтобы OpenCode автоматически анализировал эти логи и сообщал об ошибках.
Сначала запустим сервер OpenCode в фоновом режиме, чтобы он работал постоянно:
# Запускаем сервер в фоне
opencode serve --port 3000 &
Символ амперсанд (&) в конце команды означает запуск в фоне. Терминал останется свободным для других команд.
Теперь создадим скрипт автоматического анализа логов:
#!/bin/bash
# Путь к лог-файлу
LOG_FILE="/var/log/app.log"
# Читаем последние 100 строк лога
LOGS=$(tail -100 "$LOG_FILE")
# Отправляем на сервер OpenCode для анализа
RESPONSE=$(curl -s -X POST http://localhost:3000/api/chat \
-H "Content-Type: application/json" \
-d "{\"сообщение\": \"Проанализируй лог-файл и найди все ошибки. Кратко опиши каждую ошибку: $LOGS\"}")
# Выводим результат
echo "$RESPONSE"
# Можно сохранить в файл отчёта
echo "$RESPONSE" >> /home/user/ reports/анализ_логов_$(date +%Y-%m-%d).txt
Этот скрипт отправляет содержимое лог-файла на сервер OpenCode и получает анализ ошибок. Вы можете запускать этот скрипт по расписанию с помощью cron:
# Открыть редактор cron
crontab -e
# Добавить строку для запуска каждый час
0 * * * * /home/user/анализатор_логов.sh
Теперь скрипт будет запускаться автоматически каждый час, анализировать логи и сохранять отчёты.
По умолчанию сервер OpenCode доступен только локально, то есть только с вашего компьютера. Это важная мера безопасности. Когда сервер слушает только localhost, к нему нельзя подключиться из интернета или из сети.
Адрес http://localhost:3000 работает только на вашем компьютере. Если кто-то попытается подключиться по вашему IP-адресу, например http://192.168.1.100:3000, он получит ошибку соединения. Это защищает вас от несанкционированного доступа.
Если вы хотите открыть доступ к серверу из сети, это требует дополнительной настройки аутентификации. Без пароля или другого механизма защиты ваш сервер будет уязвим — любой сможет использовать его для своих запросов, тратить ваши ресурсы и деньги.
Для безопасного открытия доступа рекомендуется использовать VPN, SSH-туннели или механизмы аутентификации API. Это выходит за рамки данной статьи, но помните о рисках, прежде чем открывать сервер наружу.
Команда opencode serve открывает новые возможности для работы с OpenCode. Превращая программу в HTTP-сервер, вы получаете инструмент для интеграции искусственного интеллекта в веб-приложения, ускорения автоматизации и создания сложных рабочих процессов.
Ключевые преимущества серверного режима очевидны. Во-первых, интеграция — вы можете встроить OpenCode в любое приложение на любом языке программирования через HTTP-запросы. Во-вторых, скорость — модель загружается один раз, все последующие запросы мгновенные. В-третьих, автоматизация — вы можете создавать сложные скрипты, которые обращаются к OpenCode без ожидания. В-четвёртых, масштабирование — один запущенный сервер обслуживает тысячи запросов.
Для простых задач в терминале используйте обычный режим работы OpenCode. Для интеграции в приложения, автоматизации и сценариев с множеством запросов — серверный режим. Теперь вы понимаете разницу и можете выбрать подходящий инструмент для каждой задачи.
Дата: 8 февраля 2026