# Karpathy-Style Knowledge Stack: Why I Put Hermes, MiniMax M3 and Obsidian at the Core
**作者**: Mr. Buzzoni
**日期**: 2026-06-16T15:25:06.000Z
**来源**: [https://x.com/polydao/status/2066904909849440434](https://x.com/polydao/status/2066904909849440434)
---
> Most people treat notes, models, and agents as three separate worlds
This stack merges them into one feedback loop:
Obsidian as your memory, Hermes as your agent, MiniMax M3 as the reasoning core
## Why a “knowledge stack” beats a “note app”
Classic PKM breaks in three predictable ways:
- Notes get written once and never updated
- AI chats are smart but amnesiac - every session starts from zero
- Context for serious work constantly falls out of RAM - yours and the model's
What we actually want:
- A local, linkable graph of everything we know
- An agent that lives inside that graph, not above it
- A frontier model that can reason over huge real context, not just 2-3 paragraphs
Hermes + MiniMax M3 + Obsidian give you this:
- Obsidian - local markdown graph with backlinks, graph view, and a plugin ecosystem designed for personal knowledge bases
- Hermes Agent - self-improving open-source agent with a built-in learning loop, tools, and long-running jobs that runs on your own infrastructure
- MiniMax M3 - the model I actually run inside Hermes every day. Long-context, multimodal, agentic
I picked it because I wanted one model that could read my whole vault, my logs, and a stack of new raw articles in a single context window - without me having to glue together a RAG pipeline to do it. After a few months of real use, it stays on as my default. More on why below
The result feels less like “using an LLM” and more like slowly training a second brain
## Why I picked M3 (and what I noticed)
> I did not pick M3 because of a benchmark
I picked it because every other model I tried in 2025 had the same failure mode in my workflow:
> it would summarize a single note fine, but the moment I asked it to read ten notes, cross‑reference them with my MOCs, and write a new one back, it would lose the thread
The symptoms were always the same:
- The summary was locally coherent but globally wrong
- It cited a project that wasn't actually in the file
- It used a tag from a different taxonomy
- It invented a wikilink to a page that didn't exist
The model was smart. The workflow was bigger than the model
M3 was the first one I tried where the whole graph fit in context and stayed there for the whole task
Three things stood out in real use:
1. It actually uses my taxonomy
I have ~41 tags in a fixed schema (#coin/*, #project/*, #concept/*, #solana-internal, #meta). When I ask M3 to compile a new note, it picks the right primary tag on the first try about 90% of the time.
With a 200K-context model I was at maybe 60%. The difference is that M3 sees the whole tag landscape at once and reasons over it instead of guessing from a few examples.
2. It doesn't drop the thread across long agentic loops
A full vault lint is 30+ tool calls: read MOC, follow wikilinks, count tags, scan for duplicates, write the report.
Most models start to drift around call 8-9.
M3 stays coherent through the end. That is the single biggest reason I stopped context‑rotating to a fresh session every 20 minutes.
3. It treats forward references as a feature
When I ask it to compile a note and a concept does not exist yet, M3 writes Forward Reference anyway.
Obsidian renders it as a gray link. I triage those once a week during the lint.
This is way better than a model that either invents a fake note or skips the link entirely.
Three honest caveats after months of use:
- First-call latency is high. Hermes pre‑loads the context. Don't judge M3 by the first 3 seconds - give it 10.
- It will confidently write a [[wikilink]] to a page that doesn't exist. That is the “forward reference” behavior above. It only becomes a problem if you skip the weekly lint.
- Multimodal is real, but for diagram‑heavy PDFs I still reach for a dedicated vision tool first. M3 reads text from images and short screenshots fine. For full pages with figures, it's not the right tool.
That is the whole pitch.
The model is good at exactly the thing a vault workflow needs: reading the whole graph at once and writing back into it without losing structure.
## Layer 1 – Obsidian as the ground truth
Obsidian is the boring but critical base layer in this stack
- Your knowledge lives as plain markdown files on disk, not locked into someone's cloud
- Backlinks, graph view, and daily notes help ideas converge into clusters instead of disappearing in chat history
- Plugins turn Obsidian into a programmable graph of documents, tasks, and datasets that an agent can systematically traverse
The principle is simple:
> If it is worth keeping, it lives in Obsidian first
> If the agent does something useful, it should end up as a note
A practical structure:
```
/obsidian-vault
/inbox
/people
/projects
/research
ai-agents.md
minimax-m3-benchmarks.md
/ai
hermes-playbook.md
agents-ideas.md
```
Hermes will read, refactor, and create these notes - but the vault remains the source of truth
## Layer 2 – Hermes as the self‑improving operator
This is where the stack stops being “a note system with an LLM” and starts acting like infrastructure
Hermes Agent is a self‑improving AI agent built by @NousResearch
It keeps a persistent model of you and your work, creates skills from experience, improves them during use, and searches its own past conversations to recall relevant context instead of resetting every session
You can run Hermes in two main ways:
- As a CLI tool on Linux, macOS, or WSL2
- Via Hermes Desktop - a native app for macOS, Windows, and Linux that wraps the same agent core in a GUI
## Install paths
macOS / Linux / WSL2 (CLI)
This one-liner installs Hermes Agent, sets up the environment, and exposes the global hermes command
```
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
```
After installation:
```
source ~/.bashrc 2>/dev/null || true
source ~/.zshrc 2>/dev/null || true
hermes
```
Windows PowerShell (CLI)
```
irm https://hermes-agent.nousresearch.com/install.ps1 | iex
```
The Windows installer handles Python 3.11, Node.js 22, ripgrep, ffmpeg, and portable Git Bash, then adds hermes to your PATH
Hermes Desktop (GUI)
If you do not want to live in the terminal, download Hermes Desktop from the official desktop page and run the native installer for macOS, Windows, or Linux.
- Use Desktop when you want a native GUI instead of CLI-first setup, simpler onboarding, and the same Hermes core without manual shell bootstrapping
- Use CLI when you want reproducibility, scripting, remote server/VPS deployment, and tight control over tools, environment variables, and long-running workflows
Most people will use both: Desktop for day-to-day interaction, CLI for setup, automation, and remote work
## Architecture – how the stack actually fits together
The clean mental model:
```
Obsidian Vault
↓
Hermes Agent
↓
MiniMax M3
↓
Updated notes, summaries, skills, scheduled jobs
```
Each layer has a distinct job:
- Obsidian stores your notes as markdown files, which makes them easy to index, search, diff, and version
- Hermes is the orchestration layer – it reads files, runs tools, remembers prior work, schedules jobs, and decides when to persist something useful. It can also connect to messaging platforms and gateways
- MiniMax M3 is the reasoning engine in this stack.
It reads large note collections, rewrites messy notes, compares documents across the vault, and handles long-running agentic tasks without forgetting what was at the top of the context 20 tool calls ago
- In my workflow, that last bit is the unlock: a full vault lint, a cross‑MOC refactor, or a 30‑call “compile this article into a 5‑section note and update 3 MOCs” task all stay coherent end‑to‑end
- The “MSA architecture” claim is marketing. The lived experience is: I can run one task for 20 minutes and the model still knows what I asked it to do at minute 1
> Hermes is not replacing Obsidian. It sits between your vault and the model, turning the vault into something actionable
A realistic loop:
- You capture raw ideas in Obsidian
- Hermes reads the vault or specific folders
- Hermes sends the relevant note set to MiniMax M3
- M3 restructures, tags, links, summarizes, or expands the material
- Hermes writes the result back into the vault as clean markdown
That loop - not one‑off chat - is the actual product
## Real setup – connect Hermes to your vault
Keep your Obsidian vault in a normal filesystem location and expose that path to Hermes.
macOS / Linux
```
export OBSIDIAN_VAULT="$HOME/Documents/Obsidian/MainVault"
ls "$OBSIDIAN_VAULT"
```
Windows PowerShell
```
$env:OBSIDIAN_VAULT="$HOME\Documents\Obsidian\MainVault"
Get-ChildItem $env:OBSIDIAN_VAULT
```
Now run the Hermes setup wizard:
```
hermes setup
```
Or, for the shortest path via Nous Portal (auto provider, Tool Gateway, etc.):
```
hermes setup --portal
```
The official docs recommend `hermes setup` as the main onboarding command and `--portal` as a shortcut for account- and provider-linked configuration
Then verify the install:
```
hermes doctor
```
hermes doctor checks dependencies, PATH, provider configuration, and flags common problems before you start wiring in models and tools
## Model layer – wiring Hermes to MiniMax M3
Hermes treats “which model to use” as a first‑class configuration, not a hardcoded assumption.
You pick and update models using Hermes itself, rather than editing config files by hand.
The main command:
```
hermes model
```
This opens a model selection flow where Hermes lists supported providers and models and lets you choose the backend that exposes MiniMax M3
Practical setup path:
1. Install Hermes (CLI or Desktop)
2. Run hermes setup or hermes setup --portal
3. Run hermes model
4. Choose the provider path that gives you access to MiniMax M3
5. Save it as your default long-context model
If you already know your environment variables and provider format, you can also set specific values with:
```
hermes config set
```
The docs call hermes config set the supported method to write individual config values without editing files manually.
In my daily setup, M3 is the default for anything I would otherwise have to split into multiple model calls. Concretely:
- Reading large folders of notes where the answer depends on the graph, not on any single file
- Merging duplicated or overlapping notes – this is a graph problem, not a text problem
- Writing structured summaries and overviews in my voice (the 5‑section template, the 41‑tag taxonomy)
- Long research chains where the context keeps growing – open‑ended “compile, then update 3 MOCs, then write 3 thread ideas” tasks
- Code‑heavy multi‑step agent tasks where the model has to remember its own tool history for 20+ calls
I keep a small fast model in Hermes for tiny utility actions (renaming a file, finding a string, formatting YAML).
For everything above - M3. The split is roughly: cheap model for mechanical tasks, M3 for reasoning tasks. After a few weeks, the routing becomes invisible.
> Rule of thumb: use a fast, cheap model for tiny utility actions. Use MiniMax M3 for anything that depends on large context, structure, or long reasoning. That is where the stack becomes meaningfully better than standard chat
## Working pattern – folders that actually scale
If you want this to work for real people, vault structure matters.
A practical layout:
```
MainVault/
Inbox/
Projects/
People/
Reading/
Daily/
Reviews/
AI/
Hermes/
MiniMax/
```
Why this works:
- Inbox/ catches raw captures and rough dumps
- Daily/ is for low‑friction daily logs
- Reading/ holds source notes, highlights, and quotes
- Projects/ stores durable outputs and ongoing work
- Reviews/ stores weekly and monthly syntheses
Hermes works best when each folder has a clear job. If your vault is chaotic, Hermes will still help, but it will spend more time interpreting the mess instead of improving it
A simple operational rule:
- Humans write freely into Inbox/, Daily/, and Reading/
- Hermes is allowed to summarize into Projects/, Reviews/, and topic folders like AI/
- Long‑term notes live in stable, predictable folders
That gives the agent permission boundaries, even if you never formalize them in YAML.
## Jobs that are actually worth automating
> The strongest Hermes use cases are not “answer one question”
> - They are recurring transformations
Concrete examples:
- Turn yesterday's daily note into a structured summary
- Merge 10 rough reading notes into one evergreen note
- Extract open questions from a project folder
- Build a weekly review from scattered notes
- Compare current notes to older ones and highlight changed opinions
This is where MiniMax M3 earns its keep.
A standard short-context model can summarize a single note well.
M3 can summarize a folder of 50 notes, cross‑reference them with the 10 MOCs in my vault, and propose a 1 000‑word overview that actually uses my own voice and tags – because it saw the whole graph.
The job I run most often: drop a fresh article into raw/, ask M3 to compile it into a 5‑section note (# Profile → # Context in my research → # Links into vault → # Tags → # Related), and watch it:
- correctly pick a tag from my 41‑tag taxonomy,
- write 8–12 wikilinks to existing notes,
- tell me which MOC needs an update.
> With a 200K model I’d get maybe 3 of those 4 right
> With M3 I get all 4 in one pass, on a ~500‑file vault
The compounding effect: every note I compile in this style becomes part of M3's context for the next question I ask.
After 6 months of weekly compiles, the model “knows” my voice, my tag system, and which MOCs I update for which kind of work – without me retraining anything.
A typical flow from the terminal:
```
hermes
```
Then, inside Hermes, you ask for tasks like:
- “Read everything in Reading/AI Agents/ and create one consolidated note called agent-architecture-overview.md”
- “Scan Daily/ for the last 7 days and write a weekly review into Reviews/2026-W24.md”
- “Find duplicate ideas across Inbox/ and Projects/ and propose merges”
The exact phrasing is flexible, but the core idea is: every task maps to real folders and produces real markdown outputs
## Scheduling and unattended work
Hermes is built not just for chat, but also for gateways, schedulers, and background execution
That matters because the best PKM workflows are usually asynchronous, not ad‑hoc.
Useful scheduled jobs:
- Every morning at 08:00 - summarize yesterday's notes into a daily summary in Reviews/
- Every Friday - generate a weekly review from Daily/ and Projects/
- Once a day - scan for orphaned notes and structural problems
- Every night - turn new reading highlights into atomic notes and link them
The architectural shift is big:
- Chat answers disappear
- Scheduled note maintenance compounds
Over time, that compound effect is what turns “just notes” into a real second brain
## Full practical path, end to end
1. Install Hermes
macOS / Linux / WSL2:
```
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
```
Windows:
```
irm https://hermes-agent.nousresearch.com/install.ps1 | iex
```
Desktop:
- Download Hermes Desktop from the official desktop page and run the native installer on macOS, Windows, or Linux.
2. Configure the agent
```
hermes setup
# or
hermes setup --portal
```
3. Verify health
```
hermes doctor
```
4. Choose your model
```
hermes model
```
Select the provider path that exposes MiniMax M3 and save it as the default model for long-context work.
5. Start Hermes and make it real
```
hermes
```
At this point, the useful first move is not “write code”. It is:
- Point Hermes at your vault
- Give it exactly one folder
- Ask it to produce one clean markdown artifact
- Open it in Obsidian and inspect the result
- Iterate until this workflow becomes boring and dependable
Once one loop feels solid, add another -> Then another.
That is how you turn Hermes + MiniMax M3 + Obsidian from a cool idea into actual infrastructure
## If you found this useful:
- Bookmark this article. The links change and new repos pop up weekly - you'll need this as a reference
- Like and Repost the thread above to help other builders escape the chatbot trap
- For weekly deep dives into AI architecture, quant trading, and the agent economy.Follow me: @polydao
- Join the TG Channel: Buzzoni Notes - here I share my raw prompts, custom skills, and alpha that's too early for X
> Don't just read it. Build it. Change your workflow starting today
## 相关链接
- [Mr. Buzzoni](https://x.com/polydao)
- [@polydao](https://x.com/polydao)
- [150K](https://x.com/polydao/status/2066904909849440434/analytics)
- [Obsidian](https://obsidian.md/)
- [Hermes Agent](https://hermes-agent.nousresearch.com/)
- [MiniMax M3](https://www.minimax.io/)
- [#coin](https://x.com/search?q=%23coin&src=hashtag_click)
- [#project](https://x.com/search?q=%23project&src=hashtag_click)
- [#concept](https://x.com/search?q=%23concept&src=hashtag_click)
- [#solana](https://x.com/search?q=%23solana&src=hashtag_click)
- [#meta](https://x.com/search?q=%23meta&src=hashtag_click)
- [@NousResearch](https://x.com/@NousResearch)
- [download Hermes Desktop](https://hermes-agent.nousresearch.com/)
- [Obsidian](https://obsidian.md/)
- [Hermes Desktop](https://hermes-agent.nousresearch.com/)
- [@polydao](https://x.com/@polydao)
- [Buzzoni Notes](https://t.me/+Wf8q84QkpyJhNjIy)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [11:25 PM · Jun 16, 2026](https://x.com/polydao/status/2066904909849440434)
- [150.7K Views](https://x.com/polydao/status/2066904909849440434/analytics)
- [View quotes](https://x.com/polydao/status/2066904909849440434/quotes)
---
*导出时间: 2026/6/17 15:32:36*
---
## 中文翻译
# Karpathy 风格知识栈：为何我将 Hermes、MiniMax M3 和 Obsidian 置于核心
**作者**: Mr. Buzzoni
**日期**: 2026-06-16T15:25:06.000Z
**来源**: [https://x.com/polydao/status/2066904909849440434](https://x.com/polydao/status/2066904909849440434)
---
> 大多数人把笔记、模型和智能体视为三个互不相关的世界
这套栈将它们融合为一个反馈闭环：
Obsidian 作为你的记忆，Hermes 作为你的智能体，MiniMax M3 作为推理核心
## 为何“知识栈”胜过“笔记应用”
传统的个人知识管理（PKM）会在三个方面崩塌：
- 笔记写一次就永不再更新
- AI 对话很聪明但健忘——每次会话都从零开始
- 严肃工作所需的上下文会不断从内存中消失——无论是你的还是模型的
我们真正想要的是：
- 一个本地的、可链接的关于我们所知一切的图谱
- 一个生活在图谱“里”而非“上”的智能体
- 一个前沿模型，能对庞大的真实上下文进行推理，而不仅仅是 2-3 个段落
Hermes + MiniMax M3 + Obsidian 能给你这些：
- Obsidian —— 本地 Markdown 图谱，具备反向链接、图谱视图，以及专为个人知识库设计的插件生态
- Hermes Agent —— 自我改进的开源智能体，内置学习循环、工具和长时间运行任务，运行在你自己的基础设施上
- MiniMax M3 —— 我每天都在 Hermes 中实际运行的模型。长上下文、多模态、适合智能体任务
我选择它，是因为我想要一个模型，能在单个上下文窗口内读完我的整个库、我的日志以及一堆新的原始文章——而不需要我拼装一个 RAG 管道来实现这点。经过几个月的实际使用，它留任成了我的默认选择。原因详见下文
最终感觉这不像是在“使用 LLM”，更像是在慢慢训练第二大脑
## 为何我选择了 M3（以及我注意到了什么）
> 我选 M3 不是因为跑分
我选它，是因为我在 2025 年试过的其他模型都在我的工作流中遭遇了同样的失败模式：
> 它可以很好地总结单个笔记，但当我要求它读十个笔记、与我的 MOC（内容地图）交叉引用并写回一个新笔记时，它就会跟不上思路
症状总是一样的：
- 总结在局部是连贯的，但在全局是错误的
- 它引用了一个实际不在文件中的项目
- 它使用了来自不同分类法的标签
- 它发明了一个指向不存在页面的 wiki 链接
模型很聪明。工作流比模型大
M3 是我试过的第一个模型，能让整个图谱适配上下文，并在整个任务期间保持在那
实际使用中有三点很突出：
1. 它真的在用我的分类法
我有一个包含约 41 个标签的固定模式（#coin/*, #project/*, #concept/*, #solana-internal, #meta）。当我要求 M3 编写新笔记时，它第一次就能选对主标签的概率大约是 90%。
用 20 万上下文长度的模型，我大概只能到 60%。区别在于 M3 一次性看到了整个标签图谱并对其进行推理，而不是从几个例子中猜测。
2. 它在长智能体循环中不会掉链子
完整的库检查包含 30+ 个工具调用：读取 MOC、跟随 wiki 链接、统计标签、扫描重复项、写报告。
大多数模型在第 8-9 次调用左右就开始跑偏。
M3 能保持连贯直到最后。这就是我不再每 20 分钟就切换到新会话的最大原因。
3. 它把“前向引用”视为功能
当我要求它编译笔记，而某个概念尚不存在时，M3 无论如何都会写入前向引用。
Obsidian 会将其渲染为灰色链接。我每周在检查时处理这些一次。
这比那些要么编造假笔记要么完全跳过链接的模型要好得多。
经过几个月的使用，三个诚实的注意事项：
- 首次调用延迟很高。Hermes 会预加载上下文。不要用前 3 秒来评判 M3——给它 10 秒。
- 它会自信地写一个指向不存在页面的 [[wikilink]]。这就是上面的“前向引用”行为。只有当你跳过每周检查时，它才会成为问题。
- 多模态是真的，但对于图表密集的 PDF，我仍然会先找专门的视觉工具。M3 处理图片中的文本和短截图没问题。对于包含图表的整页，它不是合适的工具。
这就是全部卖点。
这个模型恰好擅长库工作流需要的一件事：一次性读取整个图谱并写回，而不丢失结构。
## 第一层 —— Obsidian 作为单一事实来源
Obsidian 是这套栈中无聊但关键的基础层
- 你的知识以纯 Markdown 文件形式存在于磁盘上，而不是被锁在别人的云里
- 反向链接、图谱视图和每日笔记帮助想法聚合成簇，而不是消失在聊天记录中
- 插件把 Obsidian 变成可编程的文档、任务和数据集图谱，智能体可以系统地遍历
原则很简单：
> 如果值得保留，它就先存在于 Obsidian 中
> 如果智能体做了有用的事，它最终应该成为一条笔记
一个实用的结构：
```
/obsidian-vault
/inbox
/people
/projects
/research
ai-agents.md
minimax-m3-benchmarks.md
/ai
hermes-playbook.md
agents-ideas.md
```
Hermes 会读取、重构和创建这些笔记——但库依然是单一事实来源
## 第二层 —— Hermes 作为自我改进的操作者
这就是这套栈不再是“带 LLM 的笔记系统”而开始像基础设施的地方
Hermes Agent 是由 @NousResearch 构建的自我改进 AI 智能体
它保持你和你的工作的持久模型，从经验中创建技能，在使用中改进它们，并搜索自己过去的对话以召回相关上下文，而不是每次会话都重置
你可以通过两种主要方式运行 Hermes：
- 作为 Linux、macOS 或 WSL2 上的 CLI 工具
- 通过 Hermes Desktop —— macOS、Windows 和 Linux 的原生应用，将相同的智能体核心封装在 GUI 中
## 安装路径
macOS / Linux / WSL2 (CLI)
这条命令安装 Hermes Agent，设置环境，并暴露全局 hermes 命令
```
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
```
安装后：
```
source ~/.bashrc 2>/dev/null || true
source ~/.zshrc 2>/dev/null || true
hermes
```
Windows PowerShell (CLI)
```
irm https://hermes-agent.nousresearch.com/install.ps1 | iex
```
Windows 安装程序处理 Python 3.11、Node.js 22、ripgrep、ffmpeg 和便携式 Git Bash，然后将 hermes 添加到你的 PATH
Hermes Desktop (GUI)
如果你不想住在终端里，请从官方桌面页面下载 Hermes Desktop 并运行 macOS、Windows 或 Linux 的原生安装程序。
- 当你想要原生 GUI 而不是 CLI 优先设置、更简单的入门以及相同的 Hermes 核心而无需手动 shell 引导时，使用 Desktop
- 当你想要可重复性、脚本编写、远程服务器/VPS 部署以及严密控制工具、环境变量和长时间运行的工作流时，使用 CLI
大多数人会两者都用：Desktop 用于日常交互，CLI 用于设置、自动化和远程工作
## 架构 —— 栈实际上是如何组合在一起的
一个清晰的心智模型：
```
Obsidian Vault
↓
Hermes Agent
↓
MiniMax M3
↓
Updated notes, summaries, skills, scheduled jobs
```
每一层都有独特的工作：
- Obsidian 将你的笔记存储为 Markdown 文件，使它们易于索引、搜索、对比和版本控制
- Hermes 是编排层——它读取文件、运行工具、记住之前的工作、调度作业，并决定何时持久化有用的东西。它还可以连接到消息平台和网关
- MiniMax M3 是这套栈中的推理引擎。
它读取大量的笔记集合，重写混乱的笔记，跨库比较文档，并处理长时间运行的智能体任务，而不会忘记 20 个工具调用之前上下文顶部的内容
- 在我的工作流中，最后一点是关键：一次完整的库清理、一次跨 MOC 重构，或一个 30 次调用的“将这篇文章编译成 5 节笔记并更新 3 个 MOC”的任务，从头到尾都能保持连贯
- “MSA 架构”的说法是营销。实际体验是：我可以运行一个任务 20 分钟，模型仍然知道我在第 1 分钟时要求它做什么
> Hermes 不是要取代 Obsidian。它位于你的库和模型之间，将库转化为可行动的东西
一个现实的循环：
- 你在 Obsidian 中捕捉原始想法
- Hermes 读取库或特定文件夹
- Hermes 将相关笔记集发送给 MiniMax M3
- M3 重组材料，打标签、加链接、做总结或扩展
- Hermes 将结果作为干净的 Markdown 写回库
那个循环——而不是一次性聊天——才是真正的产品
## 真实设置 —— 将 Hermes 连接到你的库
将 Obsidian 库放在一个正常的文件系统位置，并将该路径暴露给 Hermes。
macOS / Linux
```
export OBSIDIAN_VAULT="$HOME/Documents/Obsidian/MainVault"
ls "$OBSIDIAN_VAULT"
```
Windows PowerShell
```
$env:OBSIDIAN_VAULT="$HOME\Documents\Obsidian\MainVault"
Get-ChildItem $env:OBSIDIAN_VAULT
```
现在运行 Hermes 设置向导：
```
hermes setup
```
或者，通过 Nous Portal 获取最短路径（自动提供商、Tool Gateway 等）：
```
hermes setup --portal
```
官方文档推荐 `hermes setup` 作为主要的入门命令，而 `--portal` 作为账户和提供商相关配置的快捷方式
然后验证安装：
```
hermes doctor
```
hermes doctor 会检查依赖项、PATH、提供商配置，并在你开始连接模型和工具之前标记常见问题
## 模型层 —— 将 Hermes 连接到 MiniMax M3
Hermes 将“使用哪个模型”视为一等配置，而不是硬编码的假设。
你通过使用 Hermes 本身来挑选和更新模型，而不是手动编辑配置文件。
主要命令：
```
hermes model
```
这会打开一个模型选择流程，Hermes 列出支持的提供商和模型，让你选择暴露 MiniMax M3 的后端
实用的设置路径：
1. 安装 Hermes（CLI 或 Desktop）
2. 运行 hermes setup 或 hermes setup --portal
3. 运行 hermes model
4. 选择能让你访问 MiniMax M3 的提供商路径
5. 将其保存为默认长上下文模型
如果你已经知道环境变量和提供商格式，也可以通过以下方式设置特定值：
```
hermes config set
```
文档称 hermes config set 为在不手动编辑文件的情况下写入单个配置值的受支持方法。
在我的日常设置中，M3 是任何我原本不得不拆分为多次模型调用的任务的默认选择。具体来说：
- 读取大量笔记文件夹，其中的答案取决于图谱，而非任何单个文件
- 合并重复或重叠的笔记——这是一个图谱问题，不是文本问题
- 用我的语调写结构化摘要和概览（5 节模板、41 标签分类法）
- 长研究链，上下文不断增长——开放式的“编译，然后更新 3 个 MOC，然后写 3 个推文想法”的任务
- 代码繁重的多步骤智能体任务，模型必须记住自己 20 次调用之前的工具历史
我在 Hermes 中保留一个小而快的模型用于微小的实用操作（重命名文件、查找字符串、格式化 YAML）。
对于上述所有一切——用 M3。划分大致是：机械任务用便宜模型，推理任务用 M3。几周后，这种路由就变得不可见了。
> 经验法则：用快速、便宜的模型处理微小的实用操作。用 MiniMax M3 处理任何依赖大上下文、结构或长推理的事情。这就是这套栈明显优于标准聊天的地方
## 工作模式 —— 真正可扩展的文件夹
如果你想让这对真人有用，库结构很重要。
一个实用的布局：
```
MainVault/
Inbox/
Projects/
People/
Reading/
Daily/
Reviews/
AI/
Hermes/
MiniMax/
```
为什么这有效：
- Inbox/ 捕捉原始捕捉和粗略的堆砌
- Daily/ 用于低摩擦的每日日志
- Reading/ 保存源笔记、高亮和引文
- Projects/ 存储持久输出和正在进行的工作
- Reviews/ 存储每周和每月的综合报告
当每个文件夹都有明确的工作时，Hermes 效果最好。如果你的库是混乱的，Hermes 仍然会帮忙，但会花更多时间解读混乱，而不是改进它
一个简单的操作规则：
- 人类自由写入 Inbox/、Daily/ 和 Reading/
- Hermes 被允许总结到 Projects/、Reviews/ 和像 AI/ 这样的主题文件夹
- 长期笔记存在于稳定、可预测的文件夹中
这给了智能体权限边界，即使你从未在 YAML 中将其形式化。
## 真正值得自动化的工作
> 最强大的 Hermes 用例不是“回答一个问题”
> - 它们是重复性的转换
具体例子：
- 将昨天的每日笔记转化为结构化摘要
- 将 10 条粗略的阅读笔记合并为一条常青笔记
- 从项目文件夹中提取未决问题
- 从分散的笔记中构建每周回顾
- 比较当前笔记与旧笔记，并突出已改变的观点
这就是 MiniMax M3 物有所值的地方。
标准的短上下文模型可以很好地总结单个笔记。
M3 可以总结包含 50 条笔记的文件夹，将它们与我库中的 10 个 MOC 交叉引用，并提出一篇真正使用我自己的语调和标签的 1000 字概览——因为它看到了整个图谱。
我最常运行的工作：将一篇新鲜文章放入 raw/，要求 M3 将其编译成一篇 5 节笔记（# Profile → # Context in my research → # Links into vault → # Tags → # Related），然后观察它：
- 从我的 41 标签分类法中正确选出一个标签，
- 写 8-12 个指向现有笔记的 wiki 链接，
- 告诉我哪个 MOC 需要更新。
> 用 20 万上下文的模型，这 4 点我也许能对 3 点
> 用 M3，我能在一次通过中完成全部 4 点，在大约 500 个文件的库上
复合效应：我以这种风格编译的每一条笔记都成为 M3 回答我下一个问题时的上下文的一部分。
在 6 个月的每周编译后，模型“知道”了我的语调、我的标签系统，以及我对哪种工作更新哪些 MOC——而无需我重新训练任何东西。
终端中的典型流程：
```
hermes
```
然后，在 Hermes 内部，你可以要求如下任务：
- “读取 Reading/AI Agents/ 中的所有内容并创建一条名为 agent-architecture-overview.md 的综合笔记”
- “扫描 Daily/ 最近 7 天的内容并将每周回顾写入 Reviews/2026-W24.md”
- “跨 Inbox/ 和 Projects/ 查找重复想法并提出合并建议”
确切的措辞很灵活，但核心思想是：每个任务都映射到真实的文件夹并产生真实的 Markdown 输出
## 调度和无人值守工作
Hermes 不仅为聊天而构建，还为网关、调度器和后台执行而构建
这很重要，因为最好的 PKM 工作流通常是异步的，而非临时的。
有用的定时作业：
- 每天早上 08:00 - 将昨天的笔记总结成 Reviews/ 中的每日摘要
- 每周五 - 从 Daily/ 和 Projects/ 生成每周回顾
- 每天一次 - 扫描孤立笔记和结构问题
- 每晚 - 将新的阅读高亮转化为原子笔记并链接它们
架构转变是巨大的：
- 聊天答案会消失
- 定时笔记维护会复合
随着时间的推移，这种复合效应是将“仅仅是笔记”转化为真正的第二大脑的关键
## 完整实用路径，端到端
1. 安装 Hermes
macOS / Linux / WSL2:
```
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | ba