wayneblacktea

English  ·  繁體中文

A personal-OS MCP server for AI agents — your goals, decisions, knowledge, and learning live in one shared brain so the AI you work with already knows your context instead of asking you to re-explain it every conversation.

Install

go install github.com/Wayne997035/wayneblacktea/cmd/wbt@latest
wbt setup

That's it. wbt setup does end-to-end: creates the SQLite store, reclaims the TCP port if something's squatting on it, spawns wayneblacktea-server in the background (PID file under $XDG_STATE_HOME/wayneblacktea/), waits for /health, and registers the HTTP MCP transport with Claude Code:

$ wbt setup
==> Reading or creating config…          [ok] Config ready
==> Ensuring SQLite directory…           [ok] SQLite directory ready
==> Resolving port…                      [ok] Port resolved: 8080
==> Checking for an existing healthy server…
==> Reclaiming TCP port if occupied…     [ok] Port is free
==> Spawning wayneblacktea-server in the background…
                                         [ok] Server spawned (pid 12345, logs ~/.local/state/wayneblacktea/server.log)
==> Waiting for /health…                 [ok] Server is healthy
==> Registering MCP with Claude Code…    [ok] claude mcp add wayneblacktea --transport http http://127.0.0.1:8080/mcp
All set. wayneblacktea is running at http://127.0.0.1:8080

Open Claude Code anywhere and verify:

> get_today_context

Sister commands:

Install channels

See docs/install.md for Postgres, Docker, Railway, pre-built release binary options, and Troubleshooting.

Full tool reference: docs/mcp-tools.md.

Architecture

flowchart TD
    CC["Claude Code\n(wbt mcp — stdio)"]
    CURL["HTTP clients\n(dashboard / curl)"]
    HTTPMCP["HTTP MCP transport\n(/mcp)"]

    CC   -->|MCP stdio|       SRV
    CURL -->|REST /api/star|  SRV
    HTTPMCP -->|MCP over HTTP| SRV

    SRV["wayneblacktea-server\n(Echo HTTP + mcp-go)"]

    SRV --> STORES["Store interfaces\ngtd · decision · knowledge · session\nproposal · vision · learning · workspace"]

    STORES --> SQLITE["SQLite\n(local dev, zero infra)"]
    STORES --> PG["Postgres + pgvector\n(Aiven / Railway)"]

    SRV --> AI["AI providers\nAnthropic · Gemini embeddings\nGroq (Discord bot)"]
    SRV --> SCHED["Scheduler\nSaturday reflection\nauto-consolidation · decay prune"]
    SRV --> DISCORD["Discord bot"]

One process serves MCP stdio, HTTP REST, and HTTP MCP — no separate components to run.

What you get

Once Claude Code is connected to wbt mcp, every MCP-capable agent reads and writes the same store:

Auto-memory (no nagging required)

The agent doesn't need to remember to save things. The server captures them automatically:

• MCP middleware classifier — every significant tool call (complete_task, confirm_proposal, upsert_project_arch, update_project_status, resolve_handoff, sync_repo) is async-classified by Haiku; implicit decisions get auto-logged, follow-up tasks get auto-created. Rate-capped at 60/min, deduped, prompt-injection-bounded.
• Stop hook (wbt-doctor) — when a Claude Code session ends, the transcript is compressed to a ≤500-char summary and stored as both session_handoffs.summary_text and a searchable knowledge_items row.
• SessionStart hook (wbt-context) — the next session opens with the previous handoff, recent decisions, and due reviews already injected as context.
• Saturday reflection cron — weekly batch reads 7 days of activity + decisions and proposes 3-5 retrospective knowledge entries (gated through pending_proposals for your confirmation).
• Auto-consolidation — clusters of ≥5 same-actor activities in the last 30 days get merged into a single proposed knowledge entry.

Design

Structure beats prompts. Encode what you want the AI to remember as an explicit schema. No drift between agents, no "I think you mentioned…" — it's just data.

You stay in control. Agents propose, you confirm. The friction is the point — a system that decides for you eventually decides everything.

Make forgetting visible. The server tracks every tool call and surfaces forgotten work — stuck in_progress tasks, piled-up proposals, decisions logged without a session-start recall.

Workflow tools, not raw CRUD. The agent surface exposes verbs like "get today's context", "confirm this plan", "log this decision" — rules live in the tool layer, not scattered across each client's prompt.

vs similar tools

Verifying release binaries

Release binaries are signed with cosign keyless signing via GitHub OIDC. To verify a downloaded binary:

# Install cosign: https://docs.sigstore.dev/cosign/system_config/installation/

cosign verify-blob \
  --certificate-identity-regexp "https://github.com/Wayne997035/wayneblacktea/.github/workflows/release.yml@refs/tags/.*" \
  --certificate-oidc-issuer "https://token.actions.githubusercontent.com" \
  --signature wayneblacktea_checksums.txt.sig \
  --certificate wayneblacktea_checksums.txt.pem \
  wayneblacktea_checksums.txt

The .sig and .pem files are attached to each GitHub Release alongside the binaries.

What this isn't

• Not a team product. One person, many agents. No RBAC, no shared workspace, no Notion-clone collaboration.
• Not a hosted service. Self-host on your own machine. Workspace scoping is for personal data isolation, not multi-tenancy.
• Not a stable API. Solo project, irregular releases, breaking changes happen, dashboard rough edges remain.
• Not a chatbot with memory. The schema is the memory. Conversation history is irrelevant.

Licensed under MIT. Architecture deep-dive in docs/architecture.md.