ishenwei/nexus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

测试n8n工作流

Browse Source
This commit is contained in:
admin
2026-03-30 14:13:23 +08:00
parent 06acfb9a43
commit eb7a78c2aa
2 changed files with 4 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

205
openclaw/content-queue/3 Essential Tools for OpenClaw.md Normal file
View File

@@ -0,0 +1,205 @@
# 3 Essential Tools for OpenClaw
#qmd #agentmail #agentbrowser
**Source**: https://x.com/_sean_matthew/status/2028902126005653889
**Author**: Sean Matthew (Verified)
**Published**: March 4, 2026 at 2:35 AM
**Views**: 6,484 | **Reposts**: 13 | **Likes**: 76 | **Bookmarks**: 113
---
For the last few weeks, I've been running OpenClaw on a dedicated Mac Mini as my personal AI agent. It's got access to Telegram, my calendar, task manager, my YouTube channel, my Obsidian vault, and many other useful things. But even after wiring up all those integrations, I still found there were three big gaps.
Because here's the thing: out of the box, OpenClaw can't send emails, can't remember what you worked on last week (at least not very well), and can't reliably browse the web.
What I will show you below are three tools that fix all of that, plus the exact prompts you can paste into Claude Code to set each one up in minutes.
I have a full video walkthrough of this setup on YouTube, which you can access here: https://www.youtube.com/watch?v=QvfqAMUJTT4
---
## Before You Start
Make sure you have OpenClaw installed. On whatever machine you're running it, open a Terminal and run this:
```bash
cd ~/.openclaw
```
This puts you in the OpenClaw workspace folder. Launch Claude Code, Codex, or whatever coding agent you like from this directory. All of the following steps assume you're in this directory.
---
## Side Note: Why Not Use OpenClaw Itself Here?
You might be wondering: why not just have OpenClaw install its own skills and tools? It can absolutely do that, and I use it that way frequently. But just as often, I use Claude Code as the background architect of my OpenClaw. There's a reason why I have the Claude Max plan, and I like to use it to its fullest. But as you probably know, Anthropic has [cracked](https://www.theregister.com/2026/02/20/anthropic_clarifies_ban_third_party_claude_access/) [down](https://www.reddit.com/r/ClaudeAI/comments/1r8ecyq/anthropic_bans_oauth_tokens_from_consumer_plans/) on people using their Claude subscriptions with OpenClaw, basically making API keys the only truly "safe" path for now. So in almost all cases, you're paying per-token to run OpenClaw, whether that's through Anthropic, OpenAI, OpenRouter, or whatever provider you're using.
So, to answer the question above, I use Claude Code to build all of OpenClaw's systems, skills, and workflows. When OpenClaw is actually running day-to-day, it's not burning through tokens to fix faulty setups. It's executing systems that were built precisely with Claude Code.
---
## How Skills Work in OpenClaw
Before we get into the tools, a quick note on how OpenClaw learns new capabilities. There are two ways to add skills:
1. **Manually** — You teach OpenClaw how to use a tool by creating a SKILL.md file with all the instructions it needs to use the tool. You can use any agent to build this out.
2. **ClawHub** — This is OpenClaw's skill registry, basically a repository of pre-built skills you can install. Some come from the OpenClaw creator himself, some are official skills from tool authors, and some are community-contributed.
A word of warning on ClawHub: There have been reports of malware being deployed on the site. Exercise caution when downloading skills (stick to official or well-known authors). All three skills in this guide come from verified sources.
To install ClawHub (one-time setup):
```bash
npm i -g clawhub
```
---
## Tool 1: AgentMail: Give Your Agent Its Own Email
[AgentMail](https://agentmail.to) is a Y Combinator-backed startup that built an email platform specifically for AI agents. The idea is simple: your agent gets its own real email inbox. This is not Gmail and does not come with the inherent risks of signing up for Google accounts (i.e., account banning). This is an inbox designed from the ground up for agents to send and receive emails programmatically.
### Create an account
Go to [agentmail.to](https://agentmail.to) and click "Get Started." You can sign up with Google, and it's free. There are paid plans, but the free tier is very generous and gives you up to 3 inboxes. You'll go through a simple onboarding to create your first inbox. The address will be yourname@agentmail.to. Copy this inbox name, as you'll need it in a minute.
### Grab your API key
In the AgentMail dashboard, go to the API keys section and generate your first key. Keep a copy of that handy.
### Paste this prompt into Claude Code
Use this prompt to install the AgentMail skill for Open Claw and connect your OpenClaw to all the necessary tools it needs to send and receive email through your new AgentMail inbox.
```markdown
Set up AgentMail for my OpenClaw agent. The AgentMail skill docs and reference are at: https://clawhub.ai/adboio/agentmail Make sure to:
1. The AgentMail skill is already installed via clawhub (if not installed, please do so)
2. Configure the AGENTMAIL_API_KEY in my openclaw.json. My key is: [YOUR_KEY] under skills.entries.agentmail
3. My agent's inbox is: [YOUR_INBOX]
4. Install the Python SDK (pip install agentmail python-dotenv)
5. Test sending and receiving an email
```
Replace [YOUR_KEY] and [YOUR_INBOX] with the values you saved earlier. Claude Code will handle the rest.
### What this looks like in practice
In the full walkthrough video I linked above, I forwarded a newsletter I received in my personal email to my AgentMail inbox. OpenClaw picked it up and immediately pinged me on Telegram to let me know something landed in the inbox. I asked it to give me the main takeaways, and it came back with a clean summary of the entire email.
That's a simple personal use case: I'm forwarding invoices, newsletters, and other stuff from my day-to-day life to Jarvis (my OpenClaw agent), and it gives me summaries and action items.
But you could take this much further:
- Set up a **support inbox** where your agent handles first-line responses to customer inquiries
- Have it **process incoming invoices** and extract key details
- Build a **daily email digest** that your agent compiles and sends to you on Telegram
- Route different types of emails to different agent workflows via webhooks
The possibilities are really endless.
---
## Tool 2: QMD: Upgrade the Agent's Memory
This might be the single biggest upgrade you can make to your OpenClaw. Let me explain the problem first.
### The problem with default memory
Out of the box, OpenClaw has a memory system. When you interact with it, it creates markdown files stored in a local SQLite database. Anytime you want to ask about previous work or past sessions, it uses keyword-based search to find relevant memories.
The problem is obvious: if you ask "hey, what did we do with XYZ last week?" but the actual conversation used different words, the keyword search fails. So your agent easily forgets things you've worked on.
And it gets worse over time. The more you interact with OpenClaw and the more memories you accumulate, the more bloated your queries get. You're pulling in a ton of irrelevant tokens every time you ask about history, which burns through API costs and makes your agent slower and dumber.
### What QMD is
[QMD](https://github.com/tobi/qmd) is an open-source tool built by Tobi Lutke (the CEO of Shopify). It's a local hybrid search engine for markdown files that combines three search strategies:
1. **Keyword search** (traditional matching, same as OpenClaw's default memory system)
2. **Vector semantic search** (understands meaning, not just exact words)
3. **LLM-powered re-ranker** (scores results by actual relevance)
The key thing: it all runs entirely on your machine. No API keys, no cloud services, no data leaving your computer. It downloads some small local models (they don't take up much space) and everything happens locally and efficiently.
### Setup
Paste this prompt into ClaudeCode to install QMD and hook it up to your OpenClaw as its memory backbone:
```markdown
Set up QMD as the memory backend for my OpenClaw agent. Follow the official docs here: https://docs.openclaw.ai/concepts/memory#qmd-backend-experimental Make sure to:
1. Install the QMD CLI
2. Install SQLite with extension support if needed (macOS: brew install sqlite)
3. Configure memory.backend = "qmd" in my openclaw.json
4. Add my workspace memory files as a QMD collection
5. Run the initial embed so models are downloaded and the index is built
6. Verify it works by running a test query
```
If I had to pick just one tool from this entire list, it's QMD. The memory upgrade is the single biggest quality-of-life improvement for OpenClaw.
---
## Tool 3: Agent-Browser: Give the Agent a Better Browser
[Agent-browser](https://github.com/vercel-labs/agent-browser) is a CLI tool from Vercel that gives your AI agent a real web browser. This is not just fetching and scraping HTML. This is an actual Chromium browser that can navigate pages, click on things, take screenshots, fill out forms, etc. Basically any interaction a user could have in a browser.
### Why agent-browser instead of Playwright?
If you've used Playwright with an AI agent before, you've probably noticed how token-inefficient it is. Every time Playwright interacts with a website, it generates a ton of information. Your AI agent has to process all of that, which fills up its context window and ultimately gives you a worse outcome.
Agent-browser takes a completely different approach. Everything Playwright can do, agent-browser can do with **93% less tokens**. That's a massive difference for an always-on agent: it means your agent can do a lot more browsing for a lot less money.
### Install the CLI
```bash
npm install -g agent-browser
```
### Paste this prompt into Claude Code
```markdown
Install the agent-browser skill for my OpenClaw agent. The agent-browser SKILL.md and reference docs are at: https://github.com/vercel-labs/agent-browser/tree/main/skills/agent-browser Follow the OpenClaw skills docs here: https://docs.openclaw.ai/tools/skills Make sure to:
1. Install the agent-browser skill into ~/.openclaw/skills/agent-browser/ so it's available to all my agents
2. Include the SKILL.md and any reference docs from the repo
3. Verify the skill shows up as eligible
4. Whenever my agent needs to access the internet or browse a web page, it should use agent-browser
```
This prompt pulls the agent-browser skills from GitHub, installs them on your machine, and tells OpenClaw that anytime it needs to browse the web, it should use agent-browser. Once installed, the skill is available to OpenClaw, as well as Claude Code, Codex, or any other AI agent running on that machine.
In the walkthrough video I linked above, I showed a simple use case for agent-browser: navigating to Hacker News and summarizing what is trending for the day. I ran it through the command line to show its speed (42s to complete the whole task) and then ran the same workflow through Telegram (which pings my OpenClaw to run the same agent-browser commands). These are relatively simple use cases, but there are ton of different directions you can take agent-browser:
### Advanced use cases
- **No-API workflows** — Any site or service that doesn't have an API, where you have to go to a web console or dashboard to interact with it, your agent can now handle that. Fill out forms, export reports, change settings, etc.
- **Self-verifying code** — When your agent makes code changes, it can open a preview URL in an actual browser and verify the fix worked. This is a typical workflow for Playwright, but as I mentioned, agent-browser can do it much faster.
- **Website monitoring** — Track price drops, product listings, back-in-stock alerts, job listings, or any changes on any page.
- **Security guardrails** — This is not a use case per se, but I'll just point out that agent-browser has built-in prompt injection defenses. It's not perfect, but it provides an extra line of defense so your agent isn't getting poisoned by malicious content on the web.
- **Electron apps** — This is brand new. Agent-browser has an Electron skill that lets it control desktop apps (e.g., Slack, Notion, VS Code, Discord). I haven't tested this one out yet, but it opens up a whole new category of automation beyond just web browsing.
---
## Recap
There you have it. Three tools, three simple upgrades:
1. **AgentMail** gives your agent its own dedicated email inbox
2. **QMD** gives your agent real semantic memory that actually works
3. **Agent-Browser** gives your agent a better, faster, cheaper way to browse the web
Each one takes only a few minutes to set up, but together they turn a basic OpenClaw install into something that actually feels like a useful assistant.
Start with QMD. Then hook up all three. I promise that it's worth it.
---
## Resources
- [AgentMail](https://agentmail.to)
- [AgentMail skill (ClawHub)](https://clawhub.ai/adboio/agentmail)
- [QMD](https://github.com/tobi/qmd)
- [OpenClaw Memory Docs (QMD)](https://docs.openclaw.ai/concepts/memory#qmd-backend-experimental)
- [Agent-Browser](https://github.com/vercel-labs/agent-browser)
- [OpenClaw Skills Docs](https://docs.openclaw.ai/tools/skills)
- [ClawHub](https://clawhub.ai)