Memory

me.ai-knowPublished by ai-know.meOfficial publisherv0.4.0Updated Oct 27, 2026

Chinese-first brain-inspired memory MCP — hybrid recall, 7-layer user profile, workspace assembly.

VerifiedStreamable HTTPWeb executableKnowledge & MemoryAI & ML

Overview

AI-generated overview

Chinese-first long-term memory server that lets an assistant store conversations and files and recall a user's profile, facts and memories across sessions.

What you can do
  • Recall and understand the user: assemble a context-ready workspace, run hybrid memory search, fetch the 7-layer profile, atomic facts, and due reminders
  • Write memory: ingest conversation turns, or ingest audio, image, PDF, Word, Excel and video files for transcription, OCR and parsing
  • Improve and diagnose: send thumbs up/down feedback on the last recall and check service health and memory scale
  • Read resources for the profile dimension schema and live server status, and use a prompt that weaves profile, memories and facts into a system prompt
When to use it
Useful when an assistant should carry persistent, personalized context about a user between sessions, especially for Chinese-language conversations, and when you want profile and fact recall rather than plain vector search.
Requirements
A remote Streamable HTTP endpoint at ai-know.me, or the local stdio bridge run with Node.js. An agent Key with the mb- prefix, sent as an Authorization Bearer header or set in MB_API_KEY; MB_BASE_URL, MB_USER_EMAIL and MB_TIMEOUT_MS configure the local bridge. A Zhiji account is needed to create the Key.
Before you install
The agent Key is a credential: keep it out of shared configs. All memory is stored in the Zhiji backend, so conversations and uploaded audio, images and documents are sent to that service. Writes are persistent and user-scoped by userEmail, which the bridge treats as a namespace rather than a credential; do not expose a key-less, userEmail-swappable bridge to end users. Slow workspace queries can take 10-15 seconds.

Installation

In SourceWeft

  1. Open Memory in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/me.ai-know%2Fmemory/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "memory": {
      "type": "http",
      "url": "https://ai-know.me/mcp"
    }
  }
}

README

知己 (Zhiji) Memory — MCP Server

Chinese-first, brain-inspired long-term memory as an MCP server. Give any MCP client — Claude Desktop / Claude Code / Cursor / Cline / Cherry Studio / Coze — the ability to remember and understand your user across sessions.

中文用户：完整接入手册见 MCP-USAGE.md,或在线版 https://ai-know.me/mcp。

v0.4.0 · 9 tools / 2 resources / 1 prompt · stdio + Streamable HTTP · MCP protocol 2025-11-25

This repo is a thin bridge: it translates MCP tool calls into REST calls to the Zhiji backend (hosted at ai-know.me). The bridge stores nothing; all memory lives in the Zhiji service you connect to.

Why not just another vector-memory MCP?

Mem0 / Zep / LangMem expose add / search / delete over a vector store. 知己 exposes brain-inspired primitives:

  • 11-stage hybrid retrieval — trigram full-text + bge-large-zh semantic + time-decay + access-reinforcement + dedup ranking.
  • 7-layer / 37-dimension evolving user profile — values, decision logic, behavior style, self-cognition, interoceptive & dynamic state.
  • Workspace assembly — one call returns profile + relevant memories + confirmed facts + behavioral inferences, budget-trimmed for the client context window.
  • Prospective reminders, multimodal ingest (audio / OCR / doc), and a self-evolving reward loop driven by user feedback.

All Chinese-optimized (trigram tokenizer + bge-large-zh); English is supported too. Memory is stored in the Zhiji backend you connect to — self-host it, or use the hosted ai-know.me service; either way it's your Zhiji instance, not a generic memory-SaaS middleman.

Tools, resources & prompts

9 tools, grouped by role. Every user-scoped tool takes userEmail (or falls back to MB_USER_EMAIL); only the notable extra params are listed.

Read — understand the user

ToolWhat it doesNotable params
zhiji_workspace_assembleFlagship. One call returns everything needed to understand this user for a query — relevant memories + profile + confirmed facts + behavioral inferences (plus counterfactual & cross-domain hints). Drop straight into any LLM's context.query; maxResults ≤20 (def 6). Slow "what-if" queries can take 10–15s.
zhiji_memory_searchLighter, recall-only: the 11-stage hybrid pipeline (trigram FTS + semantic + time-decay), returns scored snippets with sources.query; maxResults ≤50 (def 8)
zhiji_profile_get7-layer / 37-dim user profile as an inject-ready natural-language summary.—
zhiji_facts_getStructured atomic facts (subject attribution, confidence, conflict status) — for exact names/dates/counts, not narrative.—
zhiji_prospective_dueDue/upcoming intentions (todos, promises, plans) within a time window — for proactively nudging the user.hours ≤720 (def 24)

Write — feed memory

ToolWhat it doesNotable params
zhiji_memory_ingestWrite a conversation turn to long-term memory; async embedding + profile/fact extraction + importance scoring follow. Text only.conversationId; messages[{ author: "user"|"bot", text }]
zhiji_ingest_fileMultimodal ingest — audio / image / PDF / Word / Excel / video → Whisper transcribe / Tesseract OCR / doc parse → memory. Audio & video also get acoustic-emotion analysis.one of path | url | base64; filename; isUserVoice

Ops — improve & diagnose

ToolWhat it doesNotable params
zhiji_feedbackThumbs up/down on the last recall/answer → feeds the self-evolution reward and reinforces (or penalizes) the Q-value of recently retrieved memories. The "gets better the more you use it" loop.rating: "up"|"down"; weak? → ±0.5
zhiji_statusHealth & memory scale (files / chunks / FTS availability). Call first to verify connectivity.—

2 resources — zhiji://schema/dimensions (authoritative 7-layer / 37-dim profile schema) · zhiji://server/status (live service status). 1 prompt — personal-context: weaves profile + memories + facts into a ready-to-prepend system prompt for a given query.

Experimental capabilities (sleep consolidation / dream replay / emergence) are not exposed until their groundedness passes ablation.

Typical flow

zhiji_status              → verify connectivityzhiji_memory_ingest       → feed a conversation  (or zhiji_ingest_file for audio/docs)zhiji_workspace_assemble  → in a *new* session, recall + understand the userzhiji_feedback            → thumbs up/down, closing the self-evolution loop

Quick start

You need an agent Key (mb- prefix). Get one at https://ai-know.me/memory?tab=api (register + create a Key bound to your account).

Option A — remote, no install (recommended)

Point any Streamable-HTTP MCP client at the hosted endpoint — you don't need this repo at all:

bash
claude mcp add zhiji-memory --transport http \  --url https://ai-know.me/mcp \  --header "Authorization: Bearer mb-yourKey"

Or in a URL-style client config (Cursor / Cherry Studio / LobeChat):

json
{  "mcpServers": {    "zhiji-memory": {      "url": "https://ai-know.me/mcp",      "headers": { "Authorization": "Bearer mb-yourKey" }    }  }}

Option B — run this bridge locally (stdio)

Use this repo when you want the bridge as a local stdio process (e.g. a desktop client launches it for you), talking to the hosted Zhiji backend:

bash
npm install   # only @modelcontextprotocol/sdk + zod

Then in your client config:

json
{  "mcpServers": {    "zhiji-memory": {      "command": "node",      "args": ["/absolute/path/to/zhiji-mcp/zhiji-mcp-server.mjs"],      "env": {        "MB_BASE_URL": "https://ai-know.me",        "MB_API_KEY": "mb-yourKey"      }    }  }}

Verify

bash
# visual debugger — should list 9 tools / 2 resources / 1 promptnpx @modelcontextprotocol/inspector node zhiji-mcp-server.mjs

Full client matrix (LangChain, OpenAI Agents SDK, Coze…) is in MCP-USAGE.md.

Architecture — a stateless thin bridge

MCP client  ──stdio / HTTP(JSON-RPC)──►  zhiji-mcp-*.mjs  ──REST──►  Zhiji backend (ai-know.me)

The MCP layer stores nothing; it translates MCP tool calls into REST calls to the Zhiji backend. Shared core zhiji-mcp-core.mjs backs both entry points:

FileRole
zhiji-mcp-core.mjsTool/resource/prompt definitions (single source of truth)
zhiji-mcp-server.mjsstdio entry (npm start)
zhiji-mcp-http.mjsStreamable HTTP entry (npm run http)

Isolation & auth

  • All data is hard-isolated by userEmail. The bridge treats userEmail as a namespace, not a credential.
  • The hosted public endpoint requires an agent Key — requests without Bearer mb-… get 401; the backend binds each Key to its userEmail and rejects cross-user access.
  • Never hand a key-less, userEmail-swappable bridge to end users — front it with your own backend that injects the correct userEmail. See MCP-USAGE.md §8.

Environment

VarDefaultNotes
MB_BASE_URLhttp://localhost:3001Zhiji backend address; for the hosted service use https://ai-know.me
MB_USER_EMAIL—default user namespace (single-user local use)
MB_API_KEY—mb- agent Key; forwarded as Bearer
MB_TIMEOUT_MS60000slow workspace routes can take ~15s

Status

VersionHighlights
v0.4zhiji_ingest_file (9 tools) + public-release hardening (TLS, MCP_REQUIRE_KEY, JWT-only key issuance, cross-user isolation hard-test)
v0.5 (planned)inference-list tool, resource subscriptions, fine-grained key permissions

Docs

License

MIT © 2026 知己 AI (ai-know.me)

知己 AI · MCP integration — Chinese-first brain-inspired memory. The bridge is open; the memory intelligence lives in the Zhiji backend.

Source: README.md at commit f009d25

Tools

0
SourceWeft has not read this server's tools yet.

Version history

1
  1. v0.4.0LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declaredRequired10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts