めいどMAY-doh

Your Personal Maid

Anytime Anywhere at your service

Keep one continuous conversation going across days and tasks. Meido runs on your machine with three-tier memory, an Obsidian vault for notes and SOPs, local MCP servers, and a built-in browser that keeps logins private.

Local Rust runtime
3-tier memory
Obsidian SOPs & MCP
Strict permission guardrails
curl -fsSL https://raw.githubusercontent.com/kenpyfin/meido/main/install.sh | bash

Then run meido start, open http://127.0.0.1:10961, and follow the quick setup wizard.

Give each persona one clear job.

In Meido, you split complex work into distinct roles and assign a separate persona to each. Every persona gets its own memory, folder on disk, model engine, and tool permissions.

Focused role

Each persona handles one specific part of the job, such as portfolio review, quantitative analysis, or writing code. Pick the engine that fits (Classic, Gemini ADK, or Cursor) and assign only the skills and safety hooks it needs.

1 persona → 1 engine · 1 skill allowlist · 1 hook policy

Separate memory & folder

Context never bleeds between roles. Each persona gets its own working folder, 3-tier memory file, and saved secrets, keeping scratchpads, drafts, and API keys separated.

shared/personas/<chat>/<id>/ · groups/<chat>/<id>/memory_state.json

Easy handoffs in one room

Working in separate folders does not prevent collaboration. Tag any specialist into the current chat with @Persona, share procedures and notes through the ORIGIN/ Obsidian vault, or track handoffs across TODO → PLAN → BUILD → VERIFY on the shared board.

@Quant in thread · shared ORIGIN/ vault · shared Kanban board

How 3 personas work together to handle Robinhood portfolio risk management

Risk Management

Classic · Claude Sonnet 4.6

Daily portfolio review & risk advisory

Runs the main conversation, checks daily drawdown and exposure limits, and writes the final risk report. Strictly read-only: it can inspect your Robinhood portfolio, but it can never place an order.

Workspace
shared/personas/1/1/reports/
Memory
groups/1/1/memory_state.json
Vault SOP
ORIGIN/Operations/SOPs/RH-Main-Book-Risk-Pipeline.md

@Quant

Gemini ADK · Gemini 2.5 Pro

Factor exposure & tail-risk stress testing

Tagged into the chat via @Quant to stress-test factor crowding and option tail risk, replying directly in the thread.

Workspace
shared/personas/1/2/factors/
Memory
groups/1/2/memory_state.json
Handoff
Reads the portfolio snapshot and posts its critique inline

@Repo

Cursor SDK · Code Agent

Broker connection, scripts & safety hooks

Sets up the local robinhood-trading MCP server, maintains the Python risk script, and locks in the PreToolUse hook that blocks live trade execution.

Workspace
shared/personas/1/3/ & skills/rh-main-book-risk/
Memory
groups/1/3/memory_state.json
Handoff
Builds the shared skills and safety hooks used by the other two

Every Mon/Wed/Fri at 1:15 PM PT (15 minutes after market close), a scheduled job wakes Risk Management, runs the checklist built by @Repo, brings in @Quant to stress-test the numbers, and posts the finished report into your chat.

Walk through the Robinhood risk workflow.

Connect your broker once. The chat remembers.

Ask @Repo (Cursor engine) to connect a local robinhood-trading MCP server and save the OAuth token. Tomorrow’s chat picks up right where you left off, with read-only access already set up.

vault_secret saves ROBINHOOD_MCP_TOKEN on disk for Risk Management without ever showing the raw token in the prompt or chat log.

mcp_robinhood-trading_get_portfolio · [SECRET:ROBINHOOD_MCP_TOKEN]

Checklists live in your Obsidian vault, not brittle prompts.

When you ask for a post-close risk review, Risk Management opens the checklist in your vault (ORIGIN/Operations/SOPs/RH-Main-Book-Risk-Pipeline.md) and runs the 9-step risk pipeline in order.

It pulls live positions and option Greeks via MCP, runs the Python risk script to calculate daily Expected Shortfall (2.84% of NAV) and Sharpe (1.68), and tags @Quant in the same thread to stress-test the numbers.

read_file(SOP) → run_skill_script(risk_report.py) → @Quant Critic

Turn any long discussion into a clean summary view.

Switch from Transcript to Focus to view the current topic as a clean brief: key takeaways, pinned rules, side-chat threads, and generated files.

Spin off a side chat (“Stage 8 $100M Critic calibration”) to dig into TSLA option risk without cluttering the main conversation, then fold the answer back in.

Surface: Focus · Side chat: Stage 8 $100M Critic calibration

All three personas coordinate on one shared board.

Switch the sidebar to Board to see Risk Management, @Quant, and @Repo move tasks across TODO, PLAN, BUILD, and VERIFY, from wiring the broker to verifying the risk report.

Each card tracks which persona owns the step, what prompt runs next, and the full verification history.

Sidebar: Board · Owners: Risk Management, Quant, Repo

See your current status and pinned rules at a glance.

Open the Cockpit bar to see the live status summary, task queue, bookmarked rules, and your standing instructions.

Bookmarks let you jump straight back to key decisions, like your drawdown warning threshold (> 3.0% of NAV), even hundreds of messages later.

BulletinStrip + CockpitBar · 1d 99% ES: 2.84% NAV [OK]

Give each persona its own saved secrets and model engine.

Open the Persona settings. Profile shows masked API keys (ROBINHOOD_MCP_TOKEN, FRED_API_KEY) saved only for this persona. Switch to Engine to pick which model powers it.

The Engine tab is where that choice is saved. Profile secrets stay with this persona and are not copied to the others.

PersonaDialog · Profile (Saved secrets) → Engine (Classic / Cursor / ADK)

Lock down which skills and tools each persona can touch.

Switch to Skills to choose which tools Risk Management is allowed to run. Switch to Hooks to see the safety rules enforced by the server.

The block-live-order-tools hook runs before every tool call and blocks any mcp_robinhood-trading_place_* command, so the assistant can inspect your portfolio without ever placing a trade.

PersonaDialog · Skills Allowlist → PreToolUse Read-Only Hook

Memory that carries forward, plus scheduled runs.

The Memory dialog splits context into three simple layers: Tier 1 (permanent role & rules), Tier 2 (links to vault SOPs), and Tier 3 (short-term notes for today’s task).

Open Schedules to see that post-close job. When it finishes, the risk report is posted into the chat.

groups/1/1/memory_state.json → Cron 0 15 13 * * 2,4,6

Inspect every step taken and open the finished reports.

Agent History lets you step through each tool call (reading the SOP → pulling portfolio data → running the risk script → @Quant review) and check the quality scores.

The Artifacts library keeps all generated Markdown reports, PDF summaries, and vault notes in one place so you can preview or download them anytime.

AgentHistoryDialog (Steps 1–4) → ArtifactsDialog (Report Preview)
http://127.0.0.1:10961 · Robinhood Portfolio (Read-Only)

Starting over vs. picking up where you left off.

Typical cloud chatbotMeido on your machine
Where a turn beginsA blank chat window.The conversation you’re already having.
How you organize topicsStart another chat thread.Tag topics inside the same timeline, or spin up a separate room only when you want one.
When the context fills upThe thread slows down or resets.Old messages trim automatically while your memory tiers, briefing, and vault stay intact.
Where workflows livePasted into system prompts.Plain Markdown SOPs in your Obsidian vault (ORIGIN/Operations/SOPs/…), loaded when needed.
How tools connectPlatform-specific plugins.Any local or remote MCP server, plus per-persona skills and encrypted secrets.
Scheduled & background workOnly runs while you’re watching.Cron jobs and background tasks post their results and files right back into the chat.
How you verify what happenedScroll through old chat logs.Inspect every tool call, memory update, quality check, and generated file.

Related guides:

How it runs on your machine.

Channels

Use the local web app out of the box, or reach the same chat from Telegram, Discord, WhatsApp, or WeCom. Long reports automatically turn into clean PDF links on mobile.

Engines

Run local models through Ollama and llama.cpp. A lightweight background model handles routine memory housekeeping, separate from each persona's engine.

MCP & Skills

Servers run as local processes or remote endpoints. A persona receives only the MCP servers and skills on its allowlist.

Vault & Recall

Recall reads the vault note for the active turn. Notes that are not needed stay on disk instead of crowding the prompt.

Common questions

When do I need to restart the server?

Only when changing the workspace folder, bind address, or vault path. API keys, personas, skills, and model settings apply immediately when saved.