Плагины

У Hermes есть система плагинов для добавления пользовательских инструментов, хуков и интеграций без изменения основного кода.

Если вы хотите создать собственный инструмент для себя, своей команды или одного проекта, плагины — это правильный путь. Страница Добавление инструментов предназначена для встроенных основных инструментов Hermes, которые находятся в tools/ и toolsets.py.

Создать плагин Hermes — пошаговое руководство с полным рабочим примером.

Краткий обзор

Перетащите каталог в ~/.hermes/plugins/ с plugin.yaml и кодом Python:

~/.hermes/plugins/my-plugin/
├── plugin.yaml      # manifest
├── __init__.py      # register() — wires schemas to handlers
├── schemas.py       # tool schemas (what the LLM sees)
└── tools.py         # tool handlers (what runs when called)

Запустите Hermes — ваши инструменты появятся рядом со встроенными. Модель может позвонить им немедленно.

Минимальный рабочий пример

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

~/.hermes/plugins/hello-world/plugin.yaml

name: hello-world
version: "1.0"
description: A minimal example plugin

~/.hermes/plugins/hello-world/__init__.py

"""Minimal Hermes plugin — registers a tool and a hook."""

import json


def register(ctx):
    # --- Tool: hello_world ---
    schema = {
        "name": "hello_world",
        "description": "Returns a friendly greeting for the given name.",
        "parameters": {
            "type": "object",
            "properties": {
                "name": {
                    "type": "string",
                    "description": "Name to greet",
                }
            },
            "required": ["name"],
        },
    }

    def handle_hello(params, **kwargs):
        del kwargs
        name = params.get("name", "World")
        return json.dumps({"success": True, "greeting": f"Hello, {name}!"})

    ctx.register_tool(
        name="hello_world",
        toolset="hello_world",
        schema=schema,
        handler=handle_hello,
        description="Return a friendly greeting for the given name.",
    )

    # --- Hook: log every tool call ---
    def on_tool_call(tool_name, params, result):
        print(f"[hello-world] tool called: {tool_name}")

    ctx.register_hook("post_tool_call", on_tool_call)

Drop both files into ~/.hermes/plugins/hello-world/, restart Hermes, and the model can immediately call hello_world. The hook prints a log line after every tool invocation.

Project-local plugins under ./.hermes/plugins/ are disabled by default. Enable them only for trusted repositories by setting HERMES_ENABLE_PROJECT_PLUGINS=true before starting Hermes.

What plugins can do

Every ctx.* API below is available inside a plugin's register(ctx) function.

Capability How
Add tools ctx.register_tool(name=..., toolset=..., schema=..., handler=...)
Add hooks ctx.register_hook("post_tool_call", callback)
Add slash commands ctx.register_command(name, handler, description) — adds /name in CLI and gateway sessions
Dispatch tools from commands ctx.dispatch_tool(name, args) — invokes a registered tool with parent-agent context auto-wired
Add CLI commands ctx.register_cli_command(name, help, setup_fn, handler_fn) — adds hermes <plugin> <subcommand>
Inject messages ctx.inject_message(content, role="user") — see Injecting Messages
Ship data files Path(__file__).parent / "data" / "file.yaml"
Bundle skills ctx.register_skill(name, path) — namespaced as plugin:skill, loaded via skill_view("plugin:skill")
Gate on env vars requires_env: [API_KEY] in plugin.yaml — prompted during hermes plugins install
Distribute via pip [project.entry-points."hermes_agent.plugins"]
Register a gateway platform (Discord, Telegram, IRC, …) ctx.register_platform(name, label, adapter_factory, check_fn,...) — see Adding Platform Adapters
Register an image-generation backend ctx.register_image_gen_provider(provider) — see Image Generation Provider Plugins
Register a context-compression engine ctx.register_context_engine(engine) — see Context Engine Plugins
Register a memory backend Subclass MemoryProvider in plugins/memory/<name>/__init__.py — see Memory Provider Plugins (uses a separate discovery system)
Register an inference backend (LLM provider) register_provider(ProviderProfile(...)) in plugins/model-providers/<name>/__init__.py — see Model Provider Plugins (uses a separate discovery system)

Plugin discovery

Source Path Use case
Bundled <repo>/plugins/ Ships with Hermes — see Built-in Plugins
User ~/.hermes/plugins/ Personal plugins
Project .hermes/plugins/ Project-specific plugins (requires HERMES_ENABLE_PROJECT_PLUGINS=true)
pip hermes_agent.plugins entry_points Distributed packages
Nix services.hermes-agent.extraPlugins / extraPythonPackages NixOS declarative installs — see Nix Setup

Later sources override earlier ones on name collision, so a user plugin with the same name as a bundled plugin replaces it.

Plugin sub-categories

Within each source, Hermes also recognizes sub-category directories that route plugins to specialized discovery systems:

Sub-directory What it holds Discovery system
plugins/ (root) General plugins — tools, hooks, slash commands, CLI commands, bundled skills PluginManager (kind: standalone or backend)
plugins/platforms/<name>/ Gateway channel adapters (ctx.register_platform()) PluginManager (kind: platform, one level deeper)
plugins/image_gen/<name>/ Image-generation backends (ctx.register_image_gen_provider()) PluginManager (kind: backend, one level deeper)
plugins/memory/<name>/ Memory providers (subclass MemoryProvider) Own loader in plugins/memory/__init__.py (kind: exclusive — one active at a time)
plugins/context_engine/<name>/ Context-compression engines (ctx.register_context_engine()) Own loader in plugins/context_engine/__init__.py (one active at a time)
plugins/model-providers/<name>/ LLM provider profiles (register_provider(ProviderProfile(...))) Own loader in providers/__init__.py (lazily scanned on first get_provider_profile() call)

User plugins at ~/.hermes/plugins/model-providers/<name>/ and ~/.hermes/plugins/memory/<name>/ override bundled plugins of the same name — last-writer-wins in register_provider() / register_memory_provider(). Drop a directory in, and it replaces the built-in without any repo edits.

Plugins are opt-in (with a few exceptions)

General plugins and user-installed backends are disabled by default — discovery finds them (so they show up in hermes plugins and /plugins), but nothing with hooks or tools loads until you add the plugin's name to plugins.enabled in ~/.hermes/config.yaml. This stops third-party code from running without your explicit consent.

plugins:
  enabled:
    - my-tool-plugin
    - disk-cleanup
  disabled:       # optional deny-list — always wins if a name appears in both
    - noisy-plugin

Три способа перевернуть состояние:

hermes plugins                    # interactive toggle (space to check/uncheck)
hermes plugins enable <name>      # add to allow-list
hermes plugins disable <name>     # remove from allow-list + add to disabled

After hermes plugins install owner/repo, you're asked Enable 'name' now? [y/N] — defaults to no. Skip the prompt for scripted installs with --enable or --no-enable.

What the allow-list does NOT gate

Several categories of plugin bypass plugins.enabled — they're part of Hermes' built-in surface and would break basic functionality if gated off by default:

Plugin kind How it's activated instead
Bundled platform plugins (IRC, Teams, etc. under plugins/platforms/) Auto-loaded so every shipped gateway channel is available. The actual channel turns on via gateway.platforms.<name>.enabled in config.yaml.
Bundled backends (image-gen providers under plugins/image_gen/, etc.) Auto-loaded so the default backend "just works". Selection happens via <category>.provider in config.yaml (e.g. image_gen.provider: openai).
Memory providers (plugins/memory/) All discovered; exactly one is active, chosen by memory.provider in config.yaml.
Context engines (plugins/context_engine/) All discovered; one is active, chosen by context.engine in config.yaml.
Model providers (plugins/model-providers/) All 33 providers discover and register at the first get_provider_profile() call. The user picks one at a time via --provider or config.yaml.
Pip-installed backend plugins Opt-in via plugins.enabled (same as general plugins).
User-installed platforms (under ~/.hermes/plugins/platforms/) Opt-in via plugins.enabled — third-party gateway adapters need explicit consent.

In short: bundled "always-works" infrastructure loads automatically; third-party general plugins are opt-in. The plugins.enabled allow-list is the gate specifically for arbitrary code a user drops into ~/.hermes/plugins/.

Migration for existing users

When you upgrade to a version of Hermes that has opt-in plugins (config schema v21+), any user plugins already installed under ~/.hermes/plugins/ that weren't already in plugins.disabled are automatically grandfathered into plugins.enabled. Your existing setup keeps working. Bundled standalone plugins are NOT grandfathered — even existing users have to opt in explicitly. (Bundled platform/backend plugins never needed grandfathering because they were never gated.)

Available hooks

Plugins can register callbacks for these lifecycle events. See the Event Hooks page for full details, callback signatures, and examples.

Hook Fires when
pre_tool_call Before any tool executes
post_tool_call After any tool returns
pre_llm_call Once per turn, before the LLM loop — can return {"context": "..."} to inject context into the user message
post_llm_call Once per turn, after the LLM loop (successful turns only)
on_session_start New session created (first turn only)
on_session_end End of every run_conversation call + CLI exit handler
on_session_finalize CLI/gateway tears down an active session (/new, GC, CLI quit)
on_session_reset Gateway swaps in a new session key (/new, /reset, /clear, idle rotation)
subagent_stop Once per child after delegate_task finishes
pre_gateway_dispatch Gateway received a user message, before auth + dispatch. Return {"action": "skip" \| "rewrite" \| "allow",...} to influence flow.

Plugin types

Hermes has four kinds of plugins:

Type What it does Selection Location
General plugins Add tools, hooks, slash commands, CLI commands Multi-select (enable/disable) ~/.hermes/plugins/
Memory providers Replace or augment built-in memory Single-select (one active) plugins/memory/
Context engines Replace the built-in context compressor Single-select (one active) plugins/context_engine/
Model providers Declare an inference backend (OpenRouter, Anthropic, …) Multi-register, picked by --provider / config.yaml plugins/model-providers/

Memory providers and context engines are provider plugins — only one of each type can be active at a time. Model providers are also plugins, but many load simultaneously; the user picks one at a time via --provider or config.yaml. General plugins can be enabled in any combination.

Pluggable interfaces — where to go for each

The table above shows the four plugin categories, but within "General plugins" the PluginContext exposes several distinct extension points — and Hermes also accepts extensions outside the Python plugin system (config-driven backends, shell-hooked commands, external servers, etc.). Use this table to find the right doc for what you want to build:

Want to add… How Authoring guide
A tool the LLM can call Python plugin — ctx.register_tool() Build a Hermes Plugin · Adding Tools
A lifecycle hook (pre/post LLM, session start/end, tool filter) Python plugin — ctx.register_hook() Hooks reference · Build a Hermes Plugin
A slash command for the CLI / gateway Python plugin — ctx.register_command() Build a Hermes Plugin · Extending the CLI
A subcommand for hermes <thing> Python plugin — ctx.register_cli_command() Extending the CLI
A bundled skill that your plugin ships Python plugin — ctx.register_skill() Creating Skills
An inference backend (LLM provider: OpenAI-compat, Codex, Anthropic-Messages, Bedrock) Provider plugin — register_provider(ProviderProfile(...)) in plugins/model-providers/<name>/ Model Provider Plugins · Adding Providers
A gateway channel (Discord / Telegram / IRC / Teams / etc.) Platform plugin — ctx.register_platform() in plugins/platforms/<name>/ Adding Platform Adapters
A memory backend (Honcho, Mem0, Supermemory, …) Memory plugin — subclass MemoryProvider in plugins/memory/<name>/ Memory Provider Plugins
A context-compression strategy Context-engine plugin — ctx.register_context_engine() Context Engine Plugins
An image-generation backend (DALL·E, SDXL, …) Backend plugin — ctx.register_image_gen_provider() Image Generation Provider Plugins
A TTS backend (any CLI — Piper, VoxCPM, Kokoro, xtts, voice-cloning scripts, …) Config-driven — declare under tts.providers.<name> with type: command in config.yaml TTS setup
An STT backend (custom whisper binary, local ASR CLI) Config-driven — set HERMES_LOCAL_STT_COMMAND env var to a shell template Voice Message Transcription (STT)
External tools via MCP (filesystem, GitHub, Linear, Notion, any MCP server) Config-driven — declare mcp_servers.<name> with command: / url: in config.yaml. Hermes auto-discovers the server's tools and registers them alongside built-ins. MCP
Additional skill sources (custom GitHub repos, private skill indexes) CLI — hermes skills tap add <repo> Skills Hub · Publishing a custom tap
Gateway event hooks (fire on gateway:startup, session:start, agent:end, command:*) Drop HOOK.yaml + handler.py into ~/.hermes/hooks/<name>/ Event Hooks
Shell hooks (run a shell command on events — notifications, audit logs, desktop alerts) Config-driven — declare under hooks: in config.yaml Shell Hooks

📝 Note

Не всё является Python-плагином. Некоторые точки расширения намеренно используют **команды оболочки через конфиг** (TTS, STT, shell hooks), чтобы любой уже имеющийся CLI стал плагином без написания Python. Другие — это **внешние серверы** (MCP), к которым агент подключается и автоматически регистрирует их инструменты. А некоторые — **drop-in директории** (gateway hooks) со своим форматом манифеста. Выбирайте подходящую поверхность под ваш стиль интеграции; руководства в таблице выше описывают плейсхолдеры, обнаружение и примеры.

NixOS declarative plugins

В NixOS плагины можно установить декларативно через опции модуля — hermes plugins install не требуется. Подробнее в руководстве по установке Nix.

services.hermes-agent = {
  # Directory plugin (source tree with plugin.yaml)
  extraPlugins = [ (pkgs.fetchFromGitHub {... }) ];
  # Entry-point plugin (pip package)
  extraPythonPackages = [ (pkgs.python312Packages.buildPythonPackage {... }) ];
  # Enable in config
  settings.plugins.enabled = [ "my-plugin" ];
};

Декларативные плагины имеют символическую ссылку с префиксом nix-managed- — они сосуществуют с плагинами, установленными вручную, и автоматически очищаются при удалении из конфигурации Nix.

Управление плагинами

hermes plugins                               # unified interactive UI
hermes plugins list                          # table: enabled / disabled / not enabled
hermes plugins install user/repo             # install from Git, then prompt Enable? [y/N]
hermes plugins install user/repo --enable    # install AND enable (no prompt)
hermes plugins install user/repo --no-enable # install but leave disabled (no prompt)
hermes plugins update my-plugin              # pull latest
hermes plugins remove my-plugin              # uninstall
hermes plugins enable my-plugin              # add to allow-list
hermes plugins disable my-plugin             # remove from allow-list + add to disabled

Интерактивный интерфейс

Запуск плагинов Hermes без аргументов открывает составной интерактивный экран:

Plugins
  ↑↓ navigate  SPACE toggle  ENTER configure/confirm  ESC done

  General Plugins
  [] my-tool-plugin  Custom search tool
   [ ] webhook-notifier  Event hooks
   [ ] disk-cleanup  Auto-cleanup of ephemeral files [bundled]

  Provider Plugins
     Memory Provider           honcho
     Context Engine            compressor

Выбор плагинов провайдера сохраняется в config.yaml:

memory:
  provider: "honcho"      # empty string = built-in only

context:
  engine: "compressor"    # default built-in compressor

Включено, отключено или нет

Плагины занимают одно из трёх состояний:

Состояние Значение В plugins.enabled? В plugins.disabled?
enabled Загружено на следующем сеансе Да Нет
disabled Явно выключен — не загружается, даже если также включен (не имеет значения) Да
not enabled Обнаружен, но никогда не подписывался Нет Нет

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

В работающем сеансе /plugins показывает, какие плагины загружены в данный момент.

Внедрение сообщений

Плагины могут вставлять сообщения в активный диалог, используя ctx.inject_message():

ctx.inject_message("New data arrived from the webhook", role="user")

Подпись: ctx.inject_message(content: str, role: str = "user") -> bool

Как это работает:

Это позволяет плагинам, таким как средства просмотра удаленного управления, мосты обмена сообщениями или приемники веб-перехватчиков, передавать сообщения в разговор из внешних источников.

📝 Note

`inject_message` доступен только в режиме CLI. В режиме шлюза ссылка CLI отсутствует, и метод возвращает False.

См. полное руководство для получения информации о контрактах обработчиков, формате схемы, поведении перехватчиков, обработке ошибок и распространенных ошибках.