Summary: This article documents the process of deploying Hermes Agent to Docker, integrating it with Feishu, configuring tinyfish-mcp search, and pairing it with the cost-effective DeepSeek V4 Flash solution, along with two weeks of in-depth real-world usage. It is suitable for readers with some Docker experience who want to set up a self-hosted AI assistant.

In the previous blog post Hermes Agent AI Assistant and Momei Blog Updates | 2026 Week 24 Caomei Weekly Report, we briefly mentioned Hermes Agent. This time, we’ll provide a comprehensive deployment and usage report based on real-world experience over the past few weeks.

Official documentation: https://hermes-agent.nousresearch.com/docs/zh-Hans/

Deployment

First, similar to OpenClaw, to use Hermes Agent, you need to deploy it first.

Given the extensive permissions required by such AI assistants, it is strongly discouraged to deploy them on personal computers. If deployment is necessary, it is recommended to use a containerized environment like Docker to isolate it from the host system, minimizing risks such as accidental file deletion or security breaches.

Docker containers themselves serve as security boundaries.

Next, let’s walk through the steps to deploy Hermes Agent using Docker.

Some preliminary preparations are required, including a Linux server, Docker, and an LLM API key.

Requirements

• Server: Linux (preferably at least 2 cores and 4GB RAM, otherwise it may freeze)
• Docker: Docker and docker-compose must be installed
• API Key: At least one LLM provider’s API key (e.g., DeepSeek, OpenAI)
• Messaging Gateway: Here, we’ll use Feishu as an example (you can choose any supported messaging platform, such as QQ, WeCom, DingTalk, etc.)

Installation

In the appropriate directory on the server, write the following docker-compose.yml configuration file.

#
# Hermes Agent — Docker Compose Deployment

Configuration: DeepSeek V4 Flash + Lark WebSocket

services: hermes: image: nousresearch/hermes-agent:latest container_name: hermes restart: unless-stopped volumes: - ./hermes_data:/opt/data env_file: - .env environment: # ---- User Permissions ---- - HERMES_UID=${HERMES_UID:-1000} - HERMES_GID=${HERMES_GID:-1000} # ---- DeepSeek Provider ---- - DEEPSEEK_API_KEY=${DEEPSEEK_API_KEY} # ---- Lark Channel (WebSocket Mode) ---- - FEISHU_APP_ID=${FEISHU_APP_ID} - FEISHU_APP_SECRET=${FEISHU_APP_SECRET} - FEISHU_DOMAIN=feishu - FEISHU_CONNECTION_MODE=websocket # ---- Lark Security Whitelist (Highly Recommended) ---- - FEISHU_ALLOWED_USERS=${FEISHU_ALLOWED_USERS} # ---- Recommended: Set home chat for cron/notifications ---- - FEISHU_HOME_CHANNEL=${FEISHU_HOME_CHANNEL} # - GATEWAY_ALLOW_ALL_USERS=${GATEWAY_ALLOW_ALL_USERS:-false} - GATEWAY_ALLOWED_USERS=${GATEWAY_ALLOWED_USERS} - OPENCODE_GO_API_KEY=${OPENCODE_GO_API_KEY} command:[“gateway”, “run”]

Here, DeepSeek V4 Flash is selected as the backend AI model, and Feishu (Lark) is used as the frontend interaction client. The Web dashboard is not used here, so no ports are exposed—all messages are sent and received via Feishu. All data is saved to the `hermes_data` directory under the current path (this differs from the official setup, which defaults to `~/.hermes/`; a custom mount is used here for easier backups).

Of course, the above configuration is still incomplete because the corresponding environment variables are missing.

Create a `.env` file in the same directory with the following configuration. Be sure to replace the values with your actual credentials.

```ini
# === DeepSeek API ===
# Apply at https://platform.deepseek.com
DEEPSEEK_API_KEY=sk-xxxx

# === Feishu App Credentials ===
# Apply at https://open.feishu.cn/app. Refer to the guide below for details.
FEISHU_APP_ID=cli_xxxx
FEISHU_APP_SECRET=xxxxx
FEISHU_DOMAIN=feishu
FEISHU_CONNECTION_MODE=websocket

# === Feishu Allowlist (comma-separated user open_ids) ===
FEISHU_ALLOWED_USERS=ou_xxxx

# === Optional: Home Chat ID (for cron job results and notifications) ===
# FEISHU_HOME_CHANNEL=oc_xxx
# Allowed user IDs.
# GATEWAY_ALLOWED_USERS=xxx
# For first-time use, it's recommended to allow all users, but ensure the app is only accessible to you!
GATEWAY_ALLOW_ALL_USERS=true 

Additionally, you need to create a config.yaml file in the hermes_data directory with the following content:

model:
  provider: deepseek
  default: deepseek-v4-flash

You can also use any supported AI provider.

Of course, you can also configure it via the command line. Use the following command to enter the setup wizard, which will prompt you to enter the API key and write it to ./hermes_data/.env:

docker run -it --rm \
  -v ./hermes_data:/opt/data \
  nousresearch/hermes-agent setup

Integrating with the Feishu Platform

Here, you will need a Feishu app credential and the user’s open_id. First, let’s go over how to create a Feishu intelligent agent application.

Log in to the Feishu Developer Backend. On the homepage, you will see an entry for Create Feishu Intelligent Agent Application pinned at the top. If it’s not there, you can also click the Create Enterprise Self-Built Application entry below to create one.

Then, you will see a page to set the avatar and name. Simply click Create Now.

After that, you will immediately see the App ID and App Secret. Copy these into your environment variables.

Next, execute the following command in the project directory to enable the Hermes Agent Docker image:

docker compose up -d 

At this point, you can send a message to the bot to verify whether the integration was successful.

If there is no response, it is usually because the Feishu Security Whitelist and Allowed User IDs have not been configured.

In this case, you can temporarily set GATEWAY_ALLOW_ALL_USERS to true, then directly ask the AI for the user’s open_id and fill it into FEISHU_ALLOWED_USERS and GATEWAY_ALLOWED_USERS.

You can also directly check the logs in logs/gateway.log.

Usage

Once the AI is capable of replying through the Feishu channel, it can be officially put into use.

For example, you can start by introducing yourself to it—it will remember and later reference this information directly.

Here are some usage tips.

Deploying Search MCP

As we all know, an AI model without search tools remains rather limited. In my actual usage, the triggering probability for search-based tools is around 80%~90%. For tasks like research, exploration, and verification, they are practically essential. Therefore, I chose to integrate tinyfish-mcp, which works exceptionally well.

Refer to the official documentation for deploying tinyfish-mcp.

After deploying tinyfish-mcp, configure it in config.yaml.

mcp_servers:
  tinyfish-search:
    url: "https://tinyfish.example.com/mcp"
    headers:
      Authorization: "Bearer xxxxxx"

Using Cost-Effective AI Models

While some may use Hermes Agent for programming, most interactions involve chatting. In such cases, high-end models are unnecessary, and the expenses associated with premium models are non-negligible. Therefore, it’s advisable to use cost-effective AI models, such as the high-performance DeepSeek V4 Flash instead of DeepSeek V4 Pro. If programming is truly needed, you can then call specialized AI tools like Claude Code or OpenCode.

Personally, I highly recommend using OpenCode Go to call DeepSeek V4 Flash, as it offers even better pricing than DeepSeek’s official rates.

The above link includes my referral code. By registering through this link, both you and I will receive some free usage credits.

OpenCode Go official documentation: https://opencode.ai/docs/zh-cn/go

The principle is simple: OpenCode Go costs only $10 per month but provides $60 worth of credits.

Although OpenCode Go’s DeepSeek V4 Pro hasn’t yet synced with DeepSeek’s official 60% discount, the pricing for DeepSeek V4 Flash is the same. This means you can effectively use $60 worth of DeepSeek V4 Flash for just $10, making it one of the most cost-effective options among AI models.

Additionally, OpenCode Go can be paired with Qwen3.7 Plus to handle image recognition tasks, making it one of the most budget-friendly AI model bundles available.

If you use OpenCode Go, you’ll need to update the environment variables accordingly, for example:

OPENCODE_GO_API_KEY=xxxx

Also, the model.provider field in config.yaml should be modified as follows:

model:
  provider: opencode-go
  default: deepseek-v4-flash

Configuring Vision Models

If you’re using the DeepSeek V4 series as the primary AI model backend for Hermes Agent, you may encounter an issue: DeepSeek V4 currently doesn’t support image recognition, meaning it can’t interpret the images you send, which affects the user experience.

In the Hermes Agent, it supports setting up a separate vision model. Therefore, you can configure the auxiliary.vision.model field in config.yaml to use AI models like qwen3.7-plus that support image recognition, compensating for the limitations of DeepSeek V4 Flash.

auxiliary:
  vision:
    provider: opencode-go
    model: qwen3.7-plus

Automated Memory Organization

Hermes Agent supports scheduled tasks. To enhance its autonomous learning capability, you can configure it to automatically scan conversations from the past 24 hours every midnight and extract reusable knowledge, eliminating the need for manual intervention.

Example prompt: “Scan all conversations from the past 24 hours and extract reusable knowledge…”

One minor issue is that cron jobs cannot directly write to Memory, meaning the Agent’s memory cannot be modified directly. Therefore, an indirect solution is required—using the file tool to write to reusable-knowledge.json as a file-level knowledge base.

Sending Messages in Markdown

Due to limitations in Feishu, tables cannot be rendered in messages. To address this, you can convert them into markdown files and send them as attachments. This resolves formatting issues and avoids unsupported markdown characters in messages.

You can directly instruct the AI to send attachments in markdown format or automatically convert detected table characters into markdown attachments.

Some User Experience

Now, let’s talk about my experience using Hermes Agent over this period.

First, it’s incredibly powerful and highly effective.

Initially, my expectation was that it would be a highly customizable alternative to Doubao, but it turns out to be far more capable than Doubao.

Why?

Doubao can’t execute code, operate files, or perform scheduled self-checks—whereas Hermes Agent integrates all these features into a single interface, which is why it’s more user-friendly than Doubao.

On one hand, the search quality issue is resolved through the self-built tinyfish-mcp. On the other hand, the report quality problem is addressed via super-search. It’s safe to say this is the foundation for surpassing the result quality of most AI search tools.

Next is the scheduled task system.

I’ve personally used low-code visual platforms like n8n. While writing a scheduled task isn’t overly complex, manually scripting and connecting nodes can still be a hassle. Writing scripts from scratch is also tedious. With Hermes Agent, a single command can make it write its own script, and if issues arise, it can even fix them itself—making the experience incredibly smooth.

And these are just the most basic features of Hermes Agent. At its core, Hermes Agent is a self-deployable AI assistant that can easily integrate into most workflows. Adding it to a work group is the simplest way to use it (though proper permission controls are a must). From there, just let time do its thing—the more you interact with it, the better it gets.

Even if you can’t immediately find the perfect use case, you can simply treat it as an AI chat tool. Ask it questions, and it can even help summarize insights for you.

Final Thoughts

There isn’t much left to say. Once AI can reply via Feishu channels, all that’s left is to use it more. Whenever you encounter a problem, just ask the AI—it can even solve issues on its own, automating entire workflows.

It’s no coincidence that self-deployable personal AI Agent frameworks like OpenClaw have exploded in popularity—it’s a genuine necessity. In the future, we’ll undoubtedly see more projects like Hermes Agent emerge to meet user demands.

With AI assistants like Hermes Agent, the potential for automation is beyond imagination. It can fully replace manual operations. Whether this means replacement or liberation is a matter of perspective.

See you next time—bye!

You can subscribe to updates from Caomei’s blog through the following channels:

• Blog: Caomei Youren’s Blog
• Momei Blog: Momei Blog
• RSS: Caomei Youren’s Blog RSS
• WeChat Official Account: Caomei Youren’s Backyard
• Email Subscription: Caomei Youren’s Blog Subscription

Past Issues

• 2026-06-14 Hermes Agent AI Assistant & Momei Blog Updates | Caomei Weekly Issue #24, 2026
• 2026-06-07 Momei Blog 1.19.0 Release & Copilot Price Increase Alternatives | Caomei Weekly Issue #23, 2026
• 2026-05-31 AI Super Search & Momei Blog Open-Source Updates | Caomei Weekly Issue #22, 2026