Настроил ИИ-агента прямо в редакторе Zed: подключил Gemini и gopls, чтобы агент понимал код и реально помогал писать

За последние десять лет инструменты разработки существенно ускорили мою работу, но не изменили её сути: до недавних пор я тратил большую часть рабочего времени на написание кода и тестов. Но я смог это изменить, когда начал активно осваивать возможности ИИ.

Меня зовут Александр Зайцев. Я Go-разработчик в команде Delivery компании «Флант» и работаю над werf ^[1] и Deckhouse Delivery Kit ^[2] (DevSecOps). В этой статье я:

• расскажу, как переводил свою работу на ИИ-рельсы и с какими вызовами столкнулся на этом пути;

• покажу набор инструментов и инструкций, который позволил мне внедрить и настроить ИИ-агента (если хотите, можете сразу перейти к этому разделу ^[3]).

IDE + ИИ-плагин = Workslop

В работе я привык пользоваться продуктами JetBrains: у них удобная интеграция с Git и возможности анализа, рефакторинга, отладки, форматирования и автодополнения кода. И вот где-то в середине прошлого года я узнал, что для JetBrains IDE есть AI-плагины.

Так как у меня была персональная лицензия на GoLand 2022, мне хотелось найти совместимый с ней плагин. Как выяснилось, большинство новых плагинов эту версию не поддерживают. В итоге я установил плагин от «Сбера». Он совместим с GoLand 2022 и подключён «из коробки» к модели в облаке — GigaChat. А ещё он бесплатный. Для меня как для конечного пользователя это был хороший вариант — минимум усилий, чтобы попробовать.

Заявленные функции плагина:

• Умные подсказки: когда набираешь код, тебе предлагают дополнить целую строку.

• Режим чата: аналог веб-интерфейса, который находится прямо в IDE.

• Режим агента: когда LLM сама читает/пишет код без необходимости копировать его в чат.

Я начал пробовать с малого — с умных подсказок. Пользовался ими около месяца. Это давало небольшое ускорение разработки, но часто подсказки галлюцинировали. Похоже, они использовали ограниченный контекст.

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

Потом я перешёл к агенту. Когда ставил ему задачу написания/рефакторинга кода, он с ней справлялся, но часто приходилось дорабатывать/переделывать руками.

В целом цикл «поставить задачу, получить результат от ИИ, а потом переделать» занимал у меня больше времени, чем сделать всё сразу самому.

IDE + ИИ-плагин с API-ключом = снова не то

Позже я узнал, что у нас в компании появился корпоративный сервис, который позволяет пользоваться разными LLM-моделями для рабочих нужд. Я начал использовать его в режиме чата. Если не ошибаюсь, на тот момент там была доступна модель GPT-4o. Изредка в качестве эксперимента я задавал ей вопросы, и она отвечала — иногда хорошо, иногда просто отвечала =) Одно могу отметить точно: качество ответов у GPT-4o было существенно лучше, чем у GigaChat.

В конце 2025-го я выяснил, что в нашем корпоративном сервисе стал доступен режим API-ключа — возможность подключения к LLM по API. Мои знакомые уже использовали связку «GoLand IDE + какой-то ИИ-плагин + API-ключ». Из популярных на тот момент могу выделить Cline ^[4] и Continue ^[5].

И коллеги, и я отмечали одно — тормозит, очень сложно работать. Похоже, что эти плагины используют веб-интерфейс. Если не ошибаюсь, веб-интерфейс сам по себе ресурсоёмкий, плюс IDE тоже любит кушать ресурсы.

Таким образом, вариант с API-ключом тоже не сработал.

Уже близко: ИИ-агент в терминале

От связки «JetBrains IDE + какой-то ИИ-плагин» мои коллеги переходили к агентам в терминале.

Самым популярным был OpenCode ^[6]. Я слышал, что многие коллеги им довольны и остановились на нём. Сам я его не использовал, потому что предпочитаю просто скачивать бинарь и/или использовать менеджеры пакетов в Linux, а тут пришлось бы устанавливать себе интерпретатор Node.js и npm.

Вторым по популярности шёл Crush ^[7]. В первом приближении он показался мне аналогом OpenCode, но с более удобной доставкой (бинарник + deb-пакет для Linux). Кроме того, он написан на привычном мне языке Go. Я подключил Crush к корпоративному LLM-сервису и начал пользоваться — это был мой первый опыт ^[8] применения ИИ-агента на реальном проекте. И могу сказать, что он был положительным: Crush не только использует знания из LLM, но и анализирует проект, отвечает на вопросы по нему, умеет писать код, добавлять контекст в виде файлов, применяет LSP и MCP. Для меня это ИИ-агент, который смог не только облегчить мне работу, но и вызвать у меня желание заглянуть «под капот» и детальнее разобраться в конфигурировании ИИ-агентов в принципе (встроенные инструменты, LSP, MCP и их типы). Я с уверенностью могу рекомендовать Crush — как минимум как промежуточную точку на пути к чему-то комплексному.

Несмотря на все плюсы ИИ-агента в терминале, я вижу в нём существенный минус — при работе с Git-репозиторием он не может дать такого удобства, какое даёт редактор кода. Поэтому логичный следующий шаг — редактор кода с ИИ.

Золотая середина: редактор кода со встроенным ИИ

Для меня скорость работы IDE/редактора критична. Я пытался установить на своё железо GoLand 2025, но столкнулся с трудностями:

• он существенно медленнее, чем GoLand 2022;

• он платный, а для GoLand 2022 у меня была персональная бесплатная fallback-лицензия;

• он требует постоянно включённого VPN, причём специального, который ещё не забанен на стороне JetBrains (как доступ из РФ), а это означает боль ^[9] с обновлением и установкой плагинов.

В начале этого года я узнал от коллег о редакторе Zed ^[10] (от создателей Atom, Electron и Tree-sitter), который позиционируется как быстрый редактор в коллаборации с ИИ. Он написан на Rust, то есть управление памятью ^[11] у него статическое. У Zed «из коробки» есть свои ИИ-панель, ИИ-агент и возможность подключать внешних агентов. Редактор не завязан на вендора, и его можно подключить к любому LLM-провайдеру. Он даёт минимальный лёгкий GUI и интеграцию с Git (пока неполную, но в будущем добавят фичи — вот роадмап ^[12]) — этого нет у ИИ-агентов в терминале. Также Zed привлёк раунд инвестиций от Sequoia Capital ^[13] — фонда, который прославился инвестициями в перспективные компании-стартапы, ставшие в итоге гигантами (Cisco, Google, YouTube, LinkedIn, Dropbox, Airbnb).

Я успешно подключил Zed к корпоративному LLM-сервису, пользуюсь им и доволен скоростью его работы и функциональностью.

Итак, я кратко рассказал, как пришёл к тому варианту работы с ИИ, который меня устраивает. Настало время поделиться, как именно я настраивал ИИ-агента под себя. Я постараюсь дать достаточно инструкций, чтобы при желании вы могли повторить мой опыт или использовать для себя какую-то его часть.

Настройка ИИ-агента

Формула эффективного ИИ-агента для меня:

Рабочий ИИ-агент = LLM + собственно ИИ-агент + (опционально) серверы контекста и инструменты (LSP, MCP) + (опционально) промпт-инжиниринг

Далее рассмотрим каждый из этих компонентов.

Выбор LLM

Сейчас я использую модель Gemini 3 Flash — она устраивает меня по качеству, скорости и стоимости. Я выбирал эмпирическим путём, но этот процесс можно немного формализовать и упорядочить.

В целом необходимо выбрать такую LLM, которая сочетает в себе два свойства:

• умеет работать в режиме агента;

• натренирована решать задачи в программировании.

Чтобы выбрать модель (и при желании соотнести её возможности с возможностями модели, которую выбрал я), можно использовать сравнительно простой инструмент — Artificial Analysis Intelligence Index ^[14]. Это агрегированный индекс, который, помимо прочего, включает в себя необходимые модели умения — поддержку агентского режима плюс навыки программирования.

Также этот инструмент позволяет оценить не только качество модели, но и другие её характеристики:

• стоимость — Cost to Run Artificial Analysis Intelligence Index; ^[15]

• размер контекстного окна — Context Window Size ^[16];

• скорость.

Выбор ИИ-агента

В общих чертах зафиксирую, на что стоит обращать внимание ^[17] при выборе:

• возможность подключения к нужной LLM;

• базовый набор промптов (системный промпт, промпты для мультиагентного режима) и инструментов (tools), которые закрывают 80 % потребностей ^[18];

• возможность подключать контексты и дополнительные инструменты по протоколу MCP;

• мультиагентность / оркестрация агентов (если нужно будет использовать такой режим).

Как я уже писал выше, последние несколько месяцев я использую редактор Zed Editor. Он заменил мне GoLand, а также у него есть собственный встроенный агент — Zed Agent. Но в целом на Zed Editor можно смотреть как на единый интерфейс ко множеству различных агентов. Agent Client Protocol (ACP) позволяет подключить любой внешний агент, который поддерживает этот протокол, например:

• Claude Code,

• Cline,

• Codex CLI,

• Docker Agent,

• Gemini CLI,

• GitHub Copilot,

• Gooze,

• JetBrains Junie,

• Kimi CLI,

• OpenCode,

• Qwen Code.

Дальше все настройки я буду показывать на примере Zed Agent, которым пользуюсь сам.

Подключение Zed Editor к LLM c помощью API-ключа

В нашем корпоративном сервисе в качестве интерфейса для доступа к LLM используется Open-WebUI ^[19]. Open-WebUI позволяет организовать доступ по API-ключу ^[20]. Его мы и будем использовать.

Предполагается, что вы знаете, как получить API-ключ, и он уже есть в вашем распоряжении.

Zed Editor даёт пользователям следующие ИИ-возможности:

• подсказки при наборе кода ^[21];

• генерация сообщений коммитов ^[22];

• Inline Assistant ^[23];

• режим агента ^[24].

Пришло время познакомиться с конфигурацией Zed Editor. Чтобы упростить повествование, предположим, что имеем дело с глобальной конфигурацией, которая доступна через «Open File Settings». Я приведу свою полную конфигурацию Zed здесь (под спойлером), а ниже буду показывать и комментировать фрагменты из неё.

// Zed settings
//
// For information on how to configure Zed, see the Zed
// documentation: https://zed.dev/docs/configuring-zed
//
// To see all of Zed's default settings without changing your
// custom settings, run `zed: open default settings` from the
// command palette (cmd-shift-p / ctrl-shift-p)
{
  "telemetry": {
    "diagnostics": true,
    "metrics": false
  },
  "language_models": {
    "openai_compatible": {
      "<YOUR_PROVIDER>": {
        "api_url": "https://<YOUR_DOMAIN>/v1",
        "available_models": [
          {
            "name": "gemini-3-flash",
            "display_name": "Gemini 3 Flash",
            "max_tokens": 1000000,
            "capabilities": {
              "tools": true,
              "images": true,
              // Эта настройка выключена, так как дальше в статье я хочу наглядно продемонстрировать
              // разницу в использовании инструментов (grep vs gopls-mcp),
              // то есть мне необходимо будет последовательно их применять.
              // Однако для повседневного использования я рекомендую держать эту настройку включённой.
              "parallel_tool_calls": false,
              "prompt_cache_key": true,
              "chat_completions": true
            }
          }
        ]
      }
    }
  },
  "context_servers": {
    "gopls-mcp": {
      "enabled": true,
      "remote": false,
      "command": "gopls",
      "args": ["mcp"],
      "env": {
        "GOPATH": "/home/<USER>/go",
        "GOMODCACHE": "/home/<USER>/go/pkg/mod",
        "GOROOT": "/snap/go/current"
      },
      "timeout": 480
    }
  },
  "agent": {
    "enable_feedback": false,
    "inline_assistant_model": {
      "provider": "<YOUR_PROVIDER>",
      "model": "gemini-3-flash"
    },
    "profiles": {
      "write": {
        "name": "Write",
        "tools": {
          "diagnostics": true,
          "fetch": true,
          "list_directory": true,
          "project_notifications": true,
          "now": true,
          "find_path": true,
          "read_file": true,
          "open": true,
          "grep": true,
          "thinking": true,
          "web_search": true
        },
        "default_model": {
          "provider": "<YOUR_PROVIDER>",
          "model": "gemini-3-flash"
        },
        "enable_all_context_servers": true
      }
    },
    "default_profile": "write",
    "default_model": {
      "provider": "<YOUR_PROVIDER>",
      "model": "gemini-3-flash"
    },
    "favorite_models": [
      {
        "provider": "<YOUR_PROVIDER>",
        "model": "gemini-3-flash"
      }
    ],
    "model_parameters": []
  }
}

Вот срез моей глобальной конфигурации в Zed Editor. Он позволяет активировать все ИИ-возможности, кроме одной — подсказки. На них останавливаться не будем, так как это второстепенно.

// Zed settings
//
// For information on how to configure Zed, see the Zed
// documentation: https://zed.dev/docs/configuring-zed
//
// To see all of Zed's default settings without changing your
// custom settings, run `zed: open default settings` from the
// command palette (cmd-shift-p / ctrl-shift-p)
{
  "language_models": {
    // https://zed.dev/docs/ai/llm-providers?highlight=max_to#openai-api-compatible — по ссылке доступны нюансы этой конфигурации
    "openai_compatible": {
      "<YOUR_PROVIDER>": {
        "api_url": "https://<YOUR_DOMAIN>.ru/api/v1",
        "available_models": [
          {
            "name": "gemini-3-flash",
            "display_name": "Gemini 3 Flash",
            "max_tokens": 1000000,
            "capabilities": {
              "tools": true,
              "images": true,
              "parallel_tool_calls": false,
              "prompt_cache_key": true,
              "chat_completions": true
            }
          }
        ]
      }
    }
  },
  "agent": {
    "default_model": {
      "provider": "<YOUR_PROVIDER>",
      "model": "gemini-3-flash"
    },
    "inline_assistant_model": {
      "provider": "<YOUR_PROVIDER>",
      "model": "gemini-3-flash"
    },
    "favorite_models": [
      {
        "provider": "<YOUR_PROVIDER>",
        "model": "gemini-3-flash"
      }
    ]
  }
}

Осталось установить API-ключ в Zed Editor. Так как редактор не хранит ключ в файле настроек из соображений безопасности, необходимо задать его вручную ^[25]:

1. Открываем Zed Editor.

2. Чтобы открыть Agent Settings, воспользуемся Command Palette ^[26]:

   1. Дважды нажимаем Shift, чтобы вызвать Command Palette.

   2. В появившемся окне вводим agent: open settings и нажимаем Enter.

3. В разделе LLM Providers:

   1. Находим нашего провайдера — в конфигурации выше он условно обозначен как <YOUR_PROVIDER> (он там появился после загрузки конфигурации на первом шаге).

   2. Вводим полученный ранее (на втором шаге) API-ключ и нажимаем Enter.

Отлично! Теперь мы можем генерировать сообщения для Git-коммитов, использовать текстовые чаты, inline-ассистента, но главное — режим агента, Zed Agent. Самое время проверить это с помощью ИИ-панели — вот официальная страница с видео ^[24], которая наглядно демонстрирует, как это сделать.

Встроенные инструменты агентов (tools)

Чтобы агент мог взаимодействовать со средой, ему необходимы инструменты. Разберём их также на примере Zed Agent.

Остановимся подробнее на встроенных (built-in) инструментах. Их можно разделить на несколько категорий по типу совершаемых ими операций:

• Read & Search Tools ^[27]

  • diagnostics. Возвращает ошибки ^[28] и предупреждения как для конкретного файла, так и для всего проекта в целом. Кейс: агент внёс изменения в код, после чего тот перестал компилироваться. С помощью этого инструмента агент может узнать, в чём дело, и устранить ошибку.

  • fetch. Извлекает URL-адрес и возвращает содержимое в формате Markdown. Полезно для предоставления документов в качестве контекста.

  • find_path. Быстро находит файлы, сопоставляя шаблоны глобальных объектов (например, “*/.js”) и возвращая совпадающие пути к файлам в алфавитном порядке. 

  • grep. Ищет содержимое файлов по всему проекту с использованием регулярных выражений, предпочтительных для поиска символов в коде, без знания точных путей к файлам.

  • list_directory. Выводит список файлов и каталогов по заданному пути, предоставляя обзор содержимого файловой системы.

  • now. Возвращает текущую дату и время.

  • open. Открывает файл или URL-адрес с приложением по умолчанию, связанным с ним в операционной системе пользователя. 

  • read_file. Считывает содержимое указанного файла в проекте, предоставляя доступ к содержимому файла. 

  • thinking. Позволяет агенту работать над задачами, проводить мозговой штурм идей или планировать без выполнения действий, что полезно для решения сложных задач. 

  • web_search. Ищет информацию в Интернете и предоставляет в качестве результатов фрагменты и ссылки с соответствующих веб-страниц, полезные для доступа к информации в режиме реального времени.

• Edit Tools ^[29]

  • copy_path. Рекурсивно копирует файл или каталог в проекте, что более эффективно, чем ручное чтение и запись файлов при дублировании содержимого.

  • create_directory. Создаёт новый каталог по указанному пути внутри проекта, генерируя все необходимые родительские каталоги (аналогично mkdir -p).

  • delete_path. Удаляет файл или каталог (включая содержимое рекурсивно) по указанному пути и подтверждает удаление.

  • edit_file. Редактирует файлы, заменяя определённый текст новым содержимым.

  • move_path. Перемещает или переименовывает файл или каталог в проекте, выполняя переименование, если отличается только имя файла.

  • restore_file_from_disk. Удаляет несохранённые изменения в открытых буферах, перезагружая содержимое файла с диска. Полезно для восстановления состояния файлов на диске перед повторной попыткой редактирования.

  • save_file. Сохраняет файлы с несохранёнными изменениями. Используется, когда файлы необходимо сохранить перед внесением дальнейших изменений.

  • terminal. Выполняет команды оболочки и возвращает объединённые выходные данные, создавая новый процесс оболочки для каждого вызова.

Важно отметить, что набор встроенных инструментов различается от агента к агенту. Например, если бы вместо Zed Editor и Zed Agent мы использовали Crush ^[7] (ИИ-агент в терминале), то у него был бы уже другой набор встроенных инструментов, а нам потребовалось бы дополнительно устанавливать следующие:

• thinking ^[30];

• fetch ^[31];

• web_search.

Настройка Zed Agent в Zed Editor

Агенты в Zed Editor настраиваются через профили. «Из коробки» доступно три профиля ^[32]:

• Write. Включены все встроенные инструменты. LLM может писать в файлы и выполнять команды в терминале.

• Ask. Инструменты в режиме read-only. Можно задавать LLM вопросы о кодовой базе и не бояться, что агент внесёт какие-то изменения.

• Minimal. Инструментов нет. Можно вести обычный диалог с LLM, для которого не требуется знание кодовой базы.

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

Мы будем использовать встроенный профиль write:

1. Сделаем write профилем по умолчанию.

2. Включим для него встроенные инструменты категории Read & Search:

// Zed settings
//
// For information on how to configure Zed, see the Zed
// documentation: https://zed.dev/docs/configuring-zed
//
// To see all of Zed's default settings without changing your
// custom settings, run `zed: open default settings` from the
// command palette (cmd-shift-p / ctrl-shift-p)
{
  "agent": {
    "profiles": {
      "write": {
        "name": "Write",
        "tools": {
          "diagnostics": true,
          "fetch": true,
          "list_directory": true,
          "project_notifications": true,
          "now": true,
          "find_path": true,
          "read_file": true,
          "open": true,
          "grep": true,
          "thinking": true,
          "web_search": true
        }
      }
    },
    "default_model": {
      "provider": "<YOUR_PROVIDER>",
      "model": "gemini-3-flash"
    },
    "default_profile": "write"
  }
}

Диагностика и анализ работы агента

Самое время проверить конфигурацию. В качестве репозитория я буду использовать werf ^[33], который написан на языке Go.

1. Откроем werf-репозиторий в Zed Editor. 

2. Вызовем AI Panel через иконку в нижнем правом углу. 

3. Убедимся, что в выпадающем списке выбран профиль write.

4. Введём следующий промпт в открывшееся окно диалога с агентом:

«Найди в проекте интерфейс ContainerBackend. Расскажи, какой инструмент ты использовал и почему».

Результат:

Можно заметить, что Zed Agent использовал инструмент grep и нашел два совпадения. Меня это не устраивает: я знаю, что этот интерфейс встречается чаще, чем два раза. Обратите внимание, что я задал очень расплывчатую формулировку — «найди в проекте интерфейс». Я не указал, что именно имею в виду: объявление этого интерфейса или его имплементацию. Уточним промпт:

«Найди в проекте имплементации этого интерфейса».

На этом этапе можно сделать несколько выводов:

• Какой вопрос, такой и ответ. Если вопрос не выверенный и не точный, агент/LLM будет делать предположение и возвращать результат на его основе.

• Был использован инструмент grep, который не учитывает специфику конкретного языка (в нашем случае Go).

• Чтобы узнать, как и почему агент/LLM принял то или иное решение, необходимо использовать диагностику. В нашем случае мы спросили у агента/LLM, какой инструмент и почему он использовал.

Попробуем улучшить поведение ^[34] агента, чтобы он учитывал специфику языка (Go), с которым мы работаем.

Дополнительный контекст (MCP) и внешние инструменты

Для начала вспомним, что такое Language Server Protocol (LSP). Согласно определению с официального сайта ^[35], этот протокол используется между инструментом (клиентом) и поставщиком интеллектуальных языковых функций (сервером) и позволяет интегрировать в инструмент такие фичи, как автодополнение, просмотр определений, поиск всех упоминаний и т. д.

Получается, что для каждого языка нужен свой LSP. Таблица от Microsoft ^[36] содержит информацию обо всех LSP, репозиториях и способах их установки. Для Go в ней указан LSP gopls ^[37]. В документации Zed Editor ^[38] для языка Go мы видим то же самое:

Language Server: golang/tools/tree/master/gopls

Используя официальную документацию, установим LSP для Go ^[39]. На момент написания статьи на моем компьютере используется версия gopls@v0.21.1 ^[40].

Важный момент. Прямо сейчас Zed Editor поддерживает ^[41] LSP «only for humans not for agents». Иными словами, агент не сможет использовать установленный нами LSP. К счастью, gopls содержит ^[42] экспериментальную фичу в виде MCP. Её мы и будем использовать.

Вот конфигурация Zed Editor для подключения gopls-mcp:

// Zed settings
//
// For information on how to configure Zed, see the Zed
// documentation: https://zed.dev/docs/configuring-zed
//
// To see all of Zed's default settings without changing your
// custom settings, run `zed: open default settings` from the
// command palette (cmd-shift-p / ctrl-shift-p)
{
  "context_servers": {
    "gopls-mcp": {
      "enabled": true,
      "remote": false,
      "command": "gopls",
      "args": ["mcp"],

      // На моем компьютере Go установлен через менеджер пакетов snap,
      // поэтому необходимо указать пути таким образом:
      "env": {
        "GOPATH": "/home/user/go",
        "GOMODCACHE": "/home/user/go/pkg/mod",
        "GOROOT": "/snap/go/current",
        "GOTOOLCHAIN": "local"
      },

      // gopls-mcp запускает ещё один LSP-сервер в headless-режиме, доступный к использованию ИИ-агентом.
      // Необходимо дождаться индексации кода этим LSP-сервером, поэтому timeout задан большим.
      // Таким образом, в итоге будут работать два LSP-сервера: один для человека, другой для агента,
      // что приводит к дополнительному расходу RAM.
      //
      // Я рекомендую убедиться, что gopls-mcp запустился.
      // Это можно сделать, зайдя в настройки (AI Panel / Settings).
      //
      // Если сервер отвалился по таймауту или завис (к сожалению, такое иногда бывает),
      // его можно перезапустить, подвигав ползунком enabled возле gopls-mcp там же
      // в настройках (AI Panel / Settings).
      "timeout": 480
    }
  },
  "agent": {
    "profiles": {
      "go_dev": {
        // Я добавил параметр «Использовать все контекстные серверы», в т. ч. gopls-mcp:
        "enable_all_context_servers": true
      }
    }
  }
}

Мы установили gopls-mcp и рассчитываем, что агент будет всегда его использовать. Как бы не так! Документация Zed Editor это отлично подчёркивает ^[44]:

Надёжность вызова MCP-инструментов может варьироваться в зависимости от модели. Упоминание MCP-сервера по имени может помочь модели выбрать инструменты с этого сервера.

Однако, если вы хотите убедиться, что будет использоваться данный MCP-сервер, вы можете создать кастомный профиль, в котором все встроенные инструменты (или те, которые могут вызвать конфликты с инструментами сервера) будут отключены, а включены будут только инструменты MCP-сервера.

Таким образом, у нас есть два способа относительно надёжно использовать этот и любой другой MCP-сервер:

1. Явно указать это в промпте. Например:

«Найди в проекте интерфейс ContainerBackend, используя gopls-mcp. Расскажи, какой инструмент ты использовал и почему».

2. Создать ещё один профиль конфигурации ^[45] для Zed Editor, в котором отключён инструмент grep. Этот сценарий я не буду рассматривать подробно, так как grep может нам потребоваться для поиска по текстовым файлам. Однако я могу допустить, что можно написать конфигурацию вовсе без grep, в которой будут подключены все необходимые MCP на каждый язык.

Отмечу ещё один важный момент: gopls-mcp может осуществлять поиск, близкий к семантическому. Вот полный перечень инструментов, которые доступны в gopls-mcp@v0.21.1:

• go_workspace. Предоставляет общую сводку по всему рабочему пространству Go. Позволяет понять структуру проекта и основные пакеты. 

• go_package_api. Выводит сводку API для указанных пакетов Go (экспортируемые типы, функции, переменные). Полезно, чтобы быстро ознакомиться с интерфейсом библиотеки без чтения всего кода. 

• go_file_context. Анализирует зависимости конкретного файла. Помогает понять, какие внешние и внутренние пакеты импортирует файл и как он вписывается в общую архитектуру. 

• go_search. Поиск символов (интерфейсов, структур, функций, методов) во всём рабочем пространстве с использованием нечёткого поиска (fuzzy search). Это основной инструмент для навигации по коду. 

• go_symbol_references. Находит все места использования (ссылки) конкретного символа (например, функции pkg.Func). Позволяет отследить использование кода. 

• go_rename_symbol. Безопасно переименовывает символ во всём проекте. Возвращает список правок, необходимых для корректного обновления всех ссылок на этот символ. 

• go_diagnostics. Проверяет всё рабочее пространство на наличие ошибок компиляции, синтаксических ошибок и предупреждений линтера. 

• go_vulncheck. Проверяет проект на наличие известных уязвимостей в зависимостях (использует базу данных уязвимостей Go).

Prompt Engineering

Промпт-инжиниринг — это база при работе с любой LLM. В предыдущем разделе мы уже немного познакомились с ним, когда прямо сказали агенту, чтобы он использовал gopls-mcp.

Если мы хотим использовать gopls-mcp максимально эффективно, стоит использовать специальный промпт ^[46]. Есть несколько вариантов добавить его в диалог с агентом:

• внести его в AGENTS.md. Zed читает ^[47] некоторые файлы по умолчанию при инициализации нового диалога с агентом;

• сохранить его в файл (скилл/правило) и явно упоминать ^[48] как дополнительный контекст в конкретном сообщении.

В качестве примера промпт-инжиниринга хочу привести AGENTS.md ^[49] из репозитория werf. На мой взгляд, он отлично демонстрирует принцип «Лучшие практики разработки ПО» ^[50].

Также, чтобы взглянуть на промпт-инжиниринг комплексно и больше узнать о его нюансах и техниках, рекомендую ознакомиться с презентацией от Google ^[51].

Напоследок поделюсь техниками промпт-инжиниринга, которыми чаще всего пользуюсь сам:

• Role prompting. Стараюсь всегда задавать роль или микс ролей, например: «Ты эксперт в Go, Docker, werf…».

• Contextual prompting. Прикладываю контекст в виде файлов или выделенной области в редакторе кода.

• Chain of thought при составлении плана. Я прошу LLM рассуждать пошагово. Если она рассуждает неверно, я корректирую направление её мысли и/или даю больше вводных. Когда она даёт результат, который меня устраивает, я прошу её сохранить план в файл. Далее я проверяю детали плана и при необходимости корректирую их вместе с LLM. Если с деталями всё в порядке, я начинаю новый диалог по реализации плана.

• Step-back prompting. Предположим, я начал решать задачу и задал агенту вектор движения на основе гипотезы, которая у меня есть. Агент предложил решение. Я проанализировал его и понял, что оно не удовлетворяет требованиям задачи, так как я изначально задал неверное направление (гипотеза была неверна). Тогда в новом окне диалога я даю агенту больше вводных (повышаю уровень абстракции) и прошу его самого выдвинуть гипотезы. Далее я оцениваю эти гипотезы и выбираю новое направление движения (реализации) для агента.

• Использование примеров. «Вот образец написания тестов (путь к файлу). Используя его, напиши тесты для…».

Бонус. Список официальных MCP для Dev, DevOps, DevSecOps, Q/A

Вот список некоторых официальных MCP, которые могут быть полезны для Dev, DevOps, DevSecOps, Q/A:

• ClickHouse MCP ^[52],

• Elasticsearch MCP ^[53],

• GitHub MCP ^[54],

• GitLab MCP ^[55],

• Golang MCP ^[42],

• Grafana MCP ^[56],

• Kubernetes MCP ^[57],

• Playwright MCP ^[58],

• Redis MCP ^[59],

• Terraform MCP ^[60],

• Vault MCP ^[61].

Буду рад, если мой опыт окажется полезным и как-то поможет сделать вашу работу или общение с ИИ в целом более продуктивным. Если что-то осталось непонятным — комментарии всегда открыты =) А ещё мне нравится не только делиться своим опытом, но и узнавать об опыте других, так что, если кто-то решит поделиться своими сетапами и лайфхаками по работе с ИИ, буду очень благодарен.