Archive:Give Hermes Agent Powers with MCP

Connect your AI agent to GitHub and your filesystem using Model Context Protocol.

Introduction

30 Second Summary

AI agents are powerful thinkers, but without connections to the outside world they can only work with what you type into the chat. Imagine giving your agent the ability to read GitHub repositories, browse local files, and call any tool you connect.

In this project, you will connect your Hermes Agent to GitHub and your local filesystem using Model Context Protocol (MCP), then ask it to summarize a real repository using both connections together.

What You'll Build

An MCP-powered AI agent that reads GitHub repositories and local files through two connected MCP servers, then synthesizes information across both sources.

By the end of this project, you'll have:

A GitHub MCP server running via Docker that gives your agent access to repositories, issues, and pull requests.
A Filesystem MCP server that lets your agent read and navigate local project files.
A working demo where your agent summarizes a repository by combining data from both servers.
Secret Mission: Turn your agent into a full AI GitHub Engineer that can review PRs, find bugs, generate documentation, and create issues.

Do I need to complete Part 1 first?

Yes. This project assumes you have Hermes Agent installed and connected to a free model from Part 1.

You should be comfortable starting a chat session with hermes --tui and have uv available in your terminal.

Before We Start

Before we dive in, let's lock in what you're about to build and why it matters.

Set Up Your Database

Set Up Your Tools

To connect your Hermes Agent to GitHub and your local filesystem, you need two additional tools beyond what Part 1 provided. Docker runs the official GitHub MCP server in a container, and Node.js powers the Filesystem MCP server via npx.

In this step, you'll verify Hermes is working, then install Docker and Node.js so both MCP servers can run.

In this step, get ready to:

Confirm Hermes Agent and uvx are working.
Install Node.js (for the Filesystem MCP server).
Install Docker (for the GitHub MCP server).

Confirm Hermes Agent is working

This project builds on Hermes Agent from Part 1 of the Hermes Agent series. If you haven't completed Part 1 yet, you'll need to install Hermes and configure a free model before continuing. Help me find and set up Hermes Agent from Part 1.

✔️ Yes, I've completed Part 1

Great. Your Hermes Agent and uvx should already be installed. Let's confirm they're working.

ⓧ No, I haven't set up Hermes yet

No worries. You'll need to install Hermes Agent and add a free model. Follow the steps below.

Install uv (which includes uvx)

Install uv by running the installer for your platform:

macOS

curl -LsSf https://astral.sh/uv/install.sh | sh

Windows

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Linux

curl -LsSf https://astral.sh/uv/install.sh | sh

Close and reopen your terminal so the PATH update takes effect.

Install Hermes Agent

Install Hermes Agent by running:

uvx hermes-agent install

When prompted, use your arrow keys to select your current active shell (such as bash or zsh) and press Enter to confirm.
Accept the default options for any remaining prompts by pressing Enter.

Add a free model

Add a model by running:

hermes models add

Use your arrow keys to highlight your preferred provider and press Enter to select it.
Paste your API key when prompted and press Enter.
For a free option, choose Google Gemini or Groq and use their free tier API keys.

Where do I get a free API key?

Google Gemini offers a free tier at aistudio.google.com. To generate a key:

Click Get API key in the left sidebar.
Click Create API key.
Select Create API key in new project.
Copy the generated key to your clipboard.

Alternatively, Groq offers free access at console.groq.com. Sign in, click API Keys in the left sidebar, then click Create API Key and copy it.

Verify your model was added successfully by running:

hermes models list

You should see your model listed with its provider name. If the list is empty, run hermes models add again and double-check your API key.

Hermes Agent runs through uvx, a tool runner bundled with uv. Every time you start a Hermes chat session, uvx handles downloading and launching it. If uvx isn't working, Hermes can't start.

To open a new terminal on macOS: Press Cmd+Space, type Terminal, and press Enter to open a clean terminal session.
On Windows, press the Windows key to open your search bar. Type Terminal and press Enter to open a new terminal.

Verify uvx is available by running this command:

uvx --version

✔️ I see a version number

Nice. uvx is ready. Move on to installing Node.js.

ⓧ Command not found

You need to install uv (which bundles uvx). Run the installer for your platform:

macOS

curl -LsSf https://astral.sh/uv/install.sh | sh

Windows

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Linux

curl -LsSf https://astral.sh/uv/install.sh | sh

Close and reopen your terminal after the install finishes.
Run uvx --version again to confirm it works.

Install Node.js

The Filesystem MCP server is a Node.js package that runs via npx. You need Node.js installed to use it.

Check if Node.js is already installed by running:

node --version

✔️ I see a version number

Node.js is ready. Move on to installing Docker.

ⓧ Command not found

Install Node.js for your platform:

macOS

Download the macOS installer from nodejs.org.
Run the installer and follow the prompts.
Open a new terminal and run node --version to confirm.

Windows

Download the Windows installer from nodejs.org.
Run the installer and follow the prompts.
Open a new terminal and run node --version to confirm.

Linux

Install Node.js using the commands for your distribution:

# For Debian/Ubuntu:
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

# For Arch Linux:
sudo pacman -S nodejs npm

# For Fedora:
sudo dnf install nodejs

Run node --version to confirm it installed.

Install Docker

Check if Docker is already installed by running:

docker --version

Why do I need Docker Desktop running?

Having Docker installed is not the same as having it running. Docker Desktop manages the background engine (called the Docker daemon) that actually runs containers. If the daemon isn't running, any docker command will hang or fail with a "Cannot connect to the Docker daemon" error.

✔️ I see a version number

Docker is installed. Make sure Docker Desktop is running (check for the whale icon in your system tray), then move on.

ⓧ Command not found

Install Docker Desktop for your platform:

macOS

Install Docker Desktop via Homebrew by running this command:

brew install --cask docker-desktop

Open Docker Desktop by pressing Cmd+Space, typing Docker, and pressing Enter.
Docker Desktop will ask for permissions on first launch. Grant them when prompted.
Wait for the whale icon to appear in your menu bar, then run docker --version in a new terminal to confirm.
If you don't have Homebrew, download Docker Desktop from docker.com/products/docker-desktop instead.

Windows

Install Docker Desktop via winget by running this command:

winget install Docker.DockerDesktop

The installer may prompt you to enable WSL 2. Accept when asked.
Restart your computer if prompted.
Open Docker Desktop from the Start menu and wait for it to finish starting.
Open a new terminal and run docker --version to confirm.
If winget is not available, download Docker Desktop from docker.com/products/docker-desktop instead.

Linux

Install Docker Engine by running these commands:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

Log out and log back in so the group change takes effect.
Run docker --version to confirm it installed.

Verify Docker is running by pulling a test image:

docker run --rm hello-world

You should see a "Hello from Docker" message confirming everything is working.

Docker command hangs or permission denied?

Make sure Docker Desktop is running (look for the whale icon in your system tray or menu bar). On Linux, if you see a permission error, confirm you added your user to the docker group and logged out/back in.

Help me troubleshoot why Docker is not working on my machine.

Your toolbox is ready. Next up, you'll connect your first MCP server and give Hermes access to GitHub.

Ask Hermes Without Database Access

Connect the GitHub MCP Server

Your tools are installed. Now it's time to give Hermes its first superpower: access to GitHub repositories. To do this, you need to understand how MCP works.

MCP (Model Context Protocol) is a standard that lets AI agents talk to external tools. The agent is the client and each tool runs as a server. In this step, you'll register the official GitHub MCP server with Hermes and watch it discover new tools at startup.

In this step, get ready to:

Create a GitHub Personal Access Token.
Register the GitHub MCP server with Hermes via Docker.
Verify Hermes discovers the GitHub tools.

Understand MCP: client vs server

What is MCP?

Model Context Protocol (MCP) is an open standard that defines how AI agents connect to external tools and data sources. Think of it like USB for AI: any agent that speaks MCP can plug into any MCP server, regardless of who built either side.

In this setup, Hermes is the MCP client. When it starts, it connects to each configured MCP server, calls list_tools() to discover what the server can do, then registers those tools so the agent can call them during conversations.

Why Docker for the GitHub MCP server?

GitHub's official MCP server is distributed as a Docker image at ghcr.io/github/github-mcp-server. Running it in a container means you always get the latest version without installing Go or building from source.

Create a GitHub Personal Access Token

The GitHub MCP server authenticates with your GitHub account using a Personal Access Token (PAT). This lets the server read repositories, issues, and pull requests on your behalf.

Do you have a GitHub account?

If you do not have a GitHub account yet, visit github.com and sign up for a free account first. You need to be logged in to generate a Personal Access Token.

Open github.com/settings/tokens in your browser.
Click Generate new token, then select Generate new token (classic).

If prompted, confirm your identity to authorize access.

Give your token a descriptive name like hermes-mcp.
Under Select scopes, check the repo checkbox (this grants full access to your repositories, which you need to read code and create issues).
Scroll down and click Generate token at the bottom.

Copy the token immediately. You will not be able to see it again.

Where do I store my token?

You will paste this token into an environment variable in your terminal. Never commit it to a file or share it. If you lose it or accidentally expose it, delete it and generate a new one from the same page.

Set the token as an environment variable by running the command below. Replace your-token-here with the token you just copied from GitHub before pressing Enter:

macOS

export GITHUB_PERSONAL_ACCESS_TOKEN=your-token-here

Windows

$env:GITHUB_PERSONAL_ACCESS_TOKEN="your-token-here"

Linux

export GITHUB_PERSONAL_ACCESS_TOKEN=your-token-here

This variable disappears when you close the terminal

The export command only sets the variable for your current terminal session. If you close this terminal window or open a new tab, you'll need to run the export command again. Keep this terminal open throughout the project.

If you want it to persist across sessions, add the export line to your ~/.zshrc (macOS) or ~/.bashrc (Linux). On Windows, use System Environment Variables in Settings.

Register the GitHub MCP server with Hermes

Now you'll tell Hermes how to launch the GitHub MCP server. Hermes uses the hermes mcp add command to register new servers in its config file.

hermes mcp add github --command docker --args run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server

Paste this as a single line

This command is long and may wrap in your terminal. Make sure you paste the entire thing as one line with no line breaks. If your terminal split it into two commands, press the up arrow to check what actually ran.

If you accidentally run this command a second time, Hermes will ask "Server 'github' already exists. Overwrite?" — type y to replace the existing entry, or n to skip.

What does this command do?

hermes mcp add github registers a new MCP server named "github" in your Hermes config.
--command docker tells Hermes to launch the server using Docker.
--args run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server passes the Docker run arguments: interactive mode, auto-remove the container, inject the PAT as an environment variable, and use the official GitHub image.

The -e GITHUB_PERSONAL_ACCESS_TOKEN flag passes your environment variable into the container so the server can authenticate with GitHub.

After running the command, Hermes will pull the Docker image (this may take 30-60 seconds the first time), connect to the server, and display a list of discovered tools. You'll see a prompt asking which tools to enable. Press Enter to accept the default (all tools enabled).

✔️ It worked and I see no error

Hermes connected to the GitHub server and listed the discovered tools. Move on to verifying the connection.

ⓧ I got an error

If Docker is not running, you'll see a connection error. Make sure Docker Desktop is active (whale icon in system tray).

Copy and paste this exact command into your terminal to try again:

hermes mcp add github --command docker --args run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN ghcr.io/github/github-mcp-server

If the image fails to pull, try logging out of the registry first:

docker logout ghcr.io

Then run the hermes mcp add command again.

If Hermes opened a chat session instead of registering the server, fall back to editing the config file directly:

Open ~/.hermes/config.yaml in any text editor.
Find or create the mcp_servers section and add:

mcp_servers:
  github:
    command: "docker"
    args: ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"]

Save the file.

Verify the GitHub tools are available

Start a new Hermes chat session by running:

hermes --tui

When Hermes starts, its banner should show the GitHub MCP server connected with its tool count.

Ask Hermes to confirm its available tools by typing:

Can you confirm that the GitHub MCP server is connected? 
What GitHub tools do you have available?

Look through the response for tools prefixed with mcp_github_. You should see names like mcp_github_get_file_contents, mcp_github_search_repositories, and mcp_github_list_issues.

✔️ It worked and I see no error

Hermes listed the GitHub tools without any authorization errors. You're good to go.

ⓧ I got an authorization error

If you see a message like "The GitHub MCP server is connected, but authentication is pending" or McpError: github authorization... this means the MCP server was installed successfully. The connection is working. Only GitHub authentication is incomplete.

This is not an installation failure

The GitHub MCP server is already connected to Hermes. The error only means GitHub has not finished verifying your identity. Once you complete the steps below, the tools will work immediately.

To complete authentication, follow these steps:

Check whether your PAT is set

Exit Hermes chat by typing /exit or pressing Ctrl+C.
Make sure your PAT is still set in this terminal session by running:

echo $GITHUB_PERSONAL_ACCESS_TOKEN

On Windows PowerShell, run echo $env:GITHUB_PERSONAL_ACCESS_TOKEN instead.

If the output is blank/empty, your environment variable isn't set.

set it again by running:

export GITHUB_PERSONAL_ACCESS_TOKEN="your-token-here"

Start a fresh Hermes chat session by running:

Make it persistent

If you're using zsh run this:

# Replace your-token-here with the token you copied from GitHub
echo 'export GITHUB_PERSONAL_ACCESS_TOKEN=your-token-here' >> ~/.zshrc
source ~/.zshrc

If you're using bash run this:

# Replace your-token-here with the token you copied from GitHub
echo 'export GITHUB_PERSONAL_ACCESS_TOKEN=your-token-here' >> ~/.bashrc
source ~/.bashrc

Verify the fix

Start a fresh Hermes chat session by running:

hermes --tui

Once Hermes connects without an authorization error, confirm it by asking:

Can you confirm that the GitHub MCP server is connected? What GitHub capabilities do you currently have?

If Hermes lists GitHub capabilities (repositories, issues, pull requests, code search) without reporting an authorization error, the setup is complete.

Still seeing device authorization errors after re-exporting?

The GitHub MCP server runs inside an isolated Docker container. The -e GITHUB_PERSONAL_ACCESS_TOKEN flag only passes the variable by reference from your host shell. If the variable is empty when Hermes spawns the container (new terminal, session timeout, or the shell that exported it closed), Docker passes nothing. The server sees no token and falls back to an OAuth device-code flow that Hermes cannot complete over stdio.

Open ~/.hermes/config.yaml in any text editor.
Find the github entry under mcp_servers and replace it with the version below, pasting your actual token value directly into the args line:

mcp_servers:
  github:
    command: "docker"
    args: ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN=your-token-here", "ghcr.io/github/github-mcp-server"]

Replace your-token-here with the PAT you copied from GitHub earlier.
Save the file, then start a fresh Hermes chat with hermes --tui. The token is now baked into the Docker command, so it reaches the container regardless of your shell session.

Help me fix the Docker device authorization error for the GitHub MCP server.

How does Hermes name MCP tools?

Hermes uses the pattern mcp_<server_name>_<tool_name>. Since you named your server "github", all its tools appear with the mcp_github_ prefix. This keeps tools from different MCP servers organized.

Run a quick smoke test by asking Hermes:

Search GitHub for repositories about "model context protocol". Show me the top 3 results.

Hermes should call a GitHub search tool and return real repository names, star counts, and descriptions from GitHub.

Hermes not calling GitHub tools?

If Hermes answers generically without using a tool, try being more explicit: "Use your mcp_github_search_repositories tool to search for repos about MCP."

If it says the tool does not exist, run /reload-mcp inside the chat session to refresh the tool list, or exit and run hermes mcp test github to check the connection.

Help me troubleshoot why Hermes is not using the GitHub MCP tools.

Seeing McpError: github authorization?

If the server shows as enabled in hermes mcp list but tool calls fail with McpError: github authorization, your PAT is not reaching the Docker container. Ignore the suggestion to run gh auth login — you do not need the GitHub CLI.

The Docker flag -e GITHUB_PERSONAL_ACCESS_TOKEN copies the variable from your current terminal session into the container. If that variable is empty (new terminal, or never persisted), Docker passes nothing and the server boots unauthenticated.

Fix: exit Hermes, re-export your token (export GITHUB_PERSONAL_ACCESS_TOKEN=your-token-here), verify it prints with echo $GITHUB_PERSONAL_ACCESS_TOKEN, then run hermes --tui again. To make it permanent, add the export to your ~/.zshrc or ~/.bashrc (see the authorization error tab above).

Help me fix the GitHub MCP authorization error.

Hermes can now reach GitHub. Next up, you'll add a second MCP server so it can also read files on your local machine.

Connect the SQLite MCP Server

Connect the Filesystem MCP Server

Hermes can now reach GitHub through the MCP server you connected in the last step. But to truly summarize a repository, your agent also needs to read the actual source code files on your machine.

In this step, you'll add a second MCP server: the official Filesystem server. This one runs via npx (no Docker needed) and gives Hermes read access to a directory you specify.

In this step, get ready to:

Clone a public repository to your machine.
Register the Filesystem MCP server pointing at that directory.
Verify Hermes can read local files.

Clone a public repository

You need a real repository on disk for Hermes to read. You'll clone (download a copy of) a small, well-known open-source project.

Exit the Hermes chat by typing /exit or pressing Ctrl+C.
Move to your Desktop by running this command:

macOS

cd ~/Desktop

Windows

cd $HOME\Desktop

Linux

cd ~/Desktop

Clone the official MCP servers repository by running:

git clone https://github.com/modelcontextprotocol/servers.git mcp-servers

Confirm the clone worked by running:

ls ~/Desktop/mcp-servers

On Windows PowerShell, run dir $HOME\Desktop\mcp-servers instead.
You should see folders like src, a README.md, and other project files.

Git not found?

If git is not installed, download it from git-scm.com/downloads. On macOS, running git for the first time will prompt you to install Xcode Command Line Tools.

Help me install git on my machine.

Register the Filesystem MCP server

The Filesystem MCP server is a Node.js package (@modelcontextprotocol/server-filesystem) that exposes file-reading tools over MCP. You point it at one or more directories, and it only allows access to those paths.

Find the absolute path to your cloned repository by running:

macOS

echo $HOME/Desktop/mcp-servers

Windows

echo $HOME\Desktop\mcp-servers

Linux

echo $HOME/Desktop/mcp-servers

Copy the path that prints out.

Register the Filesystem MCP server with Hermes by running this command (replace the path with your absolute path from above):
Type "y" when asked to enable the discovered tools.

hermes mcp add filesystem --command npx --args -y @modelcontextprotocol/server-filesystem [[REPO_PATH="/home/youruser/Desktop/mcp-servers"]]

Replace the highlighted path

The highlighted section of the command above is a placeholder. Replace it entirely with the absolute path you copied in the previous step. For example, if your path is /Users/alex/Desktop/mcp-servers, your final command would end with ...server-filesystem /Users/alex/Desktop/mcp-servers.

What does this command do?

hermes mcp add filesystem registers a new MCP server named "filesystem" in your Hermes config.
--command npx tells Hermes to launch the server using Node.js's npx tool runner.
--args -y @modelcontextprotocol/server-filesystem /path/... auto-installs the package and passes the allowed directory as an argument.

The server will only allow access to files inside the directory you specified. This is a security feature.

Hermes will connect and discover the filesystem tools. Press Enter to enable all tools when prompted.

✔️ It worked and I see tools discovered

Hermes connected to the Filesystem server and listed its tools. Move on to the verification below.

ⓧ I got an error

Error: Failed to connect: MCP call timed out after 40.0s

This timeout has two common causes. Check them in order.

Cause 1: The command ran as two lines.

Press the up arrow and check what you actually ran.
If the command ends at --args -y and the package name is on a separate line, your terminal ran an incomplete command.
The whole command must be ONE line with no Enter in the middle.
Answer N to the save prompt and rerun it as a single line.
If Hermes asks "Server 'filesystem' already exists. Overwrite?", answer y.

Cause 2: The first-time package download was slower than the 40 second timeout.

Cache it by running the server once manually:

npx -y @modelcontextprotocol/server-filesystem [[REPO_PATH="/home/youruser/Desktop/mcp-servers"]]

Wait for the line "Secure MCP Filesystem Server running on stdio", then press Ctrl+C.

Then rerun the hermes mcp add command.
It should now connect in seconds, then prompt available tools.

Type "y" when asked to Enable all 14 tools.
If you see a yellow "npm warn deprecated" message during this, ignore it. It is a harmless dependency warning.

Verify by running this:

hermes mcp test filesystem

Success looks like: "✓ Connected! Found 14 tool(s) from 'filesystem'".

If you see an error about npx not found

Make sure Node.js is installed (you verified this in Step 1).
If the path is rejected, verify it is absolute (starts with /home/ or /Users/). Relative paths and ~ do not work because the MCP server runs as a subprocess.

As a fallback, edit ~/.hermes/config.yaml directly and add:

mcp_servers:
  filesystem:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-filesystem", "[[REPO_PATH=\"/home/youruser/Desktop/mcp-servers\"]]"]

Save the file, then start a new chat session. MCP servers load when a session starts.

Verify Hermes can read local files

In your terminal, navigate to the mcp-servers folder by running:

macOS

cd ~/Desktop/mcp-servers

Windows

cd $HOME\Desktop\mcp-servers

Linux

cd ~/Desktop/mcp-servers

Start a fresh Hermes chat session by running:

hermes --tui

Ask Hermes to list files in the repository:

List the files in this directory of my filesystem.

Hermes should call the mcp_filesystem_list_directory tool and return the contents of the mcp-servers folder, including README.md, src/, and other project files.

Now ask Hermes to read a specific file:

Read the README.md file and tell me what this project is about.

Hermes should call mcp_filesystem_read_file and return a summary of the MCP servers repository based on its actual README content.

Hermes not using filesystem tools?

If Hermes answers without calling a tool, try being explicit: "Use your mcp_filesystem_read_file tool to read README.md."

If the tool returns a permission error, the path you registered may not match. Run hermes mcp test filesystem to check.

Help me troubleshoot why Hermes cannot read my local files.

Your agent now has two superpowers: GitHub access and local file reading. Next up, you'll combine both to summarize a repository in one conversation.

Query Your Data with Natural Language

Summarize a Repository

Both MCP servers are live. Hermes can browse GitHub remotely and read local files on disk. Now you'll combine both in a single conversation to produce a real repository summary.

This is the final demo. You'll ask one natural-language question and watch Hermes orchestrate multiple tool calls across both servers to produce a comprehensive answer.

In this step, get ready to:

Ask Hermes to summarize the repository using both MCP servers.
Observe the agent calling tools from both GitHub and Filesystem servers.
Get a synthesized summary combining remote metadata and local code.

Ask Hermes to summarize the repository

Your cloned mcp-servers repository lives on both GitHub (where Hermes can check issues, stars, and contributors) and on your local disk (where Hermes can read the actual source code).

Exit your current Hermes session by typing /exit or pressing Ctrl+C.
Make sure you're still in the mcp-servers folder (run cd ~/Desktop/mcp-servers if you're not sure).
Start a fresh Hermes chat session by running:

hermes --tui

Ask Hermes to produce a full summary by typing:

Summarize this repository: modelcontextprotocol/servers. Use your GitHub tools to get the description, star count, and recent issues. Then use your filesystem tools to read the README and list the main source directories. Give me a complete overview.

Watch the output carefully. Hermes should make multiple tool calls across both servers:

A mcp_github_ tool call to fetch the repository metadata (description, stars, open issues).
A mcp_filesystem_read_file call to read the README from your local clone.
A mcp_filesystem_list_directory call to show the project structure.
A synthesized summary combining all the information.

What should I see?

Hermes produces a multi-paragraph summary that includes: the repository's purpose, its star count and activity from GitHub, a description of the project structure from the local filesystem, and the key MCP servers available in the repository.

The exact output varies depending on your model, but you should see evidence of both mcp_github_ and mcp_filesystem_ tool calls in the conversation.

Try additional prompts

The power of MCP is composability. Try a few more questions to see how Hermes combines both servers:

Ask about the project structure:

What MCP servers are implemented in this repository? List each one from the src/ directory and describe what it does based on the file contents.

Hermes can create its own skills

If Hermes asks whether you'd like it to save a workflow as a reusable skill, you can say yes. This is a built-in feature that lets the agent learn new patterns from your conversations.

Ask a cross-server question:

How many open issues does this repository have on GitHub, and does the README mention any of those topics?

Each question triggers a different combination of tool calls. Hermes decides which tools to use based on what information it needs.

Why is this powerful?

Without MCP, you would need to manually open GitHub, read the README, browse the file tree, and cross-reference issues yourself. With two MCP servers connected, Hermes does all of that in seconds from a single prompt.

This same pattern scales to any combination of MCP servers: databases, cloud services, APIs, and more.

Hermes only using one server?

If Hermes only uses GitHub tools or only filesystem tools, be more explicit in your prompt. Mention both by name: "Use your GitHub tools AND your filesystem tools to give me a complete picture."

If one server is missing entirely, run /reload-mcp in the chat session to refresh both connections.

Help me get Hermes to use both MCP servers together.

Your MCP-powered agent is complete. Ready for a challenge? In the Secret Mission, you'll push Hermes further and turn it into a full AI GitHub Engineer that can review code, generate docs, and create issues.

Secret mission

Build an AI GitHub Engineer

Your agent can read repositories and summarize code. But what if it could also review pull requests, find bugs, generate documentation, and create issues? In this secret mission, you'll push Hermes to its full potential as a developer assistant.

Clean Up Your Resources

This project runs entirely locally (Docker containers are ephemeral), so there are no ongoing costs. Decide whether to keep your resources available, pause them to come back later, or delete them entirely.

Resources you used:

~/Desktop/mcp-servers/ cloned repository folder.
MCP server entries (github and filesystem) in ~/.hermes/config.yaml.
GitHub Personal Access Token (stored in your terminal session).
hermes-mcp-test GitHub repository (created during the Secret Mission).

Keep everything running

No action needed. Choose this if you want to keep exploring MCP or connect more servers later.

The MCP config persists locally at zero cost.
Hermes will connect to both GitHub and Filesystem servers on every future chat session automatically.
Your GitHub PAT only persists for the current terminal session unless you add it to your shell profile.

Pause - I'll come back to this later

Remove the MCP servers from Hermes so they don't load on startup, but keep your files for later.

Remove both MCP servers from Hermes by running:

hermes mcp remove github
hermes mcp remove filesystem

Confirm the servers are removed by running:

hermes mcp list

You should see an empty list, confirming no MCP servers are registered.

Your cloned repository and config remain on disk. When you're ready to reconnect, re-add the servers with hermes mcp add.

Delete - I don't want to use this again

Remove all project resources and the MCP configuration to start fresh.

Remove both MCP servers from Hermes by running:

hermes mcp remove github
hermes mcp remove filesystem

Confirm the servers are removed by running:

hermes mcp list

You should see an empty list, confirming no MCP servers are registered.

Delete the cloned repository by running:

macOS

rm -rf ~/Desktop/mcp-servers

Windows

Remove-Item -Recurse -Force $HOME\Desktop\mcp-servers

Linux

rm -rf ~/Desktop/mcp-servers

Revoke your GitHub PAT by visiting github.com/settings/tokens and clicking Delete next to the hermes-mcp token.
If you added the export GITHUB_PERSONAL_ACCESS_TOKEN=... line to your ~/.zshrc or ~/.bashrc during Step 2 troubleshooting, open that file and delete the line.
If you completed the Secret Mission, delete the hermes-mcp-test repository: go to your repository page on GitHub, click Settings in the top menu, scroll to the bottom, and click Delete this repository.
Verify the cloned folder is gone by running:

macOS

ls ~/Desktop/mcp-servers

Windows

dir $HOME\Desktop\mcp-servers

Linux

ls ~/Desktop/mcp-servers

You should see a "No such file or directory" message confirming the folder has been removed.

What about Docker and Node.js?

Docker Desktop and Node.js are general-purpose tools you may use for other projects. Keep them installed unless you specifically want to free disk space. The GitHub MCP server Docker image is only pulled when Hermes starts, so it uses no resources when idle.

That's a Wrap!

Nice work. You just built your first MCP-powered AI agent, connecting Hermes to both GitHub and your local filesystem and using them together to summarize a real repository.

You've learned how to:

Connected the official GitHub MCP server via Docker, giving your agent access to repositories, issues, and pull requests.
Connected the Filesystem MCP server via npx, letting your agent read and navigate local project files securely.
Combined both servers in a single conversation to produce a repository summary that draws on remote metadata and local source code.
Secret Mission: Turned Hermes into a full AI GitHub Engineer that can review code, find bugs, generate documentation, and create issues.