AgenticMind

MCP文档知识

提供方 Moai-Team-LLC

文档知识 未标注 API Key 社区 / 第三方 ClaudeCursorGemini CLICodex

Auditable, self-improving knowledge & memory for AI agents, served over MCP. Citation-enforced answers (no source, no claim), a replayable why-trace per answer, and a judge-gated loop that promotes validated knowledge. Zero-key local embeddings (bge-m3), hybrid vector + BM25 retr

一句话选型结论

按资料字段整理

AgenticMind 属于文档知识类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude、Cursor、Gemini CLI 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式未标注 鉴权API Key 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

mcpagentsmemory

安装与配置

未标注 API Key
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude、Cursor、Gemini CLI,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
AgenticMind当前 未标注 未标注 未标注 无 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方Moai-Team-LLC上游标注的维护方 Moai-Team-LLC
分类文档知识本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

13.9 KB
来自项目仓库与上游目录的原文,未做删改

AgenticMind

The auditable, self-improving knowledge & memory layer for AI agents.

Grounded answers with provable citations, a full why-trace for every answer,
and a corpus that improves itself — served to any agent over MCP.
Zero-key, multilingual, and self-hostable on Postgres alone.

If this is useful, a ⭐ helps others find it — and tells us to keep going.


> Not "memory storage for an agent." AgenticMind is the substrate an agent points
> at when it needs answers it can trust, a trail it can audit, and a knowledge
> base that compounds.

Most agent memory is a vector store with save() and search(). That buys you fuzzy
recall and zero accountability: you can't tell why an answer came back, whether it's
current, or whether a source even supports it. AgenticMind treats knowledge as a
first-class, auditable, self-improving substrate — and exposes it to any agent over the
Model Context Protocol.

✨ Why AgenticMind

  • 📌 Citation-enforced — every claim in an answer is keyed to a numbered source. No source, no claim.
  • 🔍 Fully auditable — a replayable why-trace for every answer: what was retrieved, ranked, and used.
  • ♻️ Self-improving — validated answers are promoted back into the corpus by a judge-gated compounding loop, driven by programmatic signals (not human thumbs).
  • 🧩 Tiered retrieval — chunks → typed fact cards → knowledge graph; hybrid vector + full-text, recency-aware.
  • 🔐 Safe by construction — scoped, least-privilege MCP tokens, fail-closed auth, guardrails on input and output.
  • 🐘 One datastore — Postgres + pgvector carries vectors, full-text, the graph (recursive CTE), and the durable queue. No Redis, no Neo4j, no vector-DB sprawl.

🔧 How it works```mermaid

flowchart TD
A["🤖 Agent"] -->|"MCP request"| R["Tiered retrieval<br/>pgvector + full-text + graph"]
R --> Y["Citation-enforced synthesis"]
Y -->|"grounded answer + [citations]"| A
Y --> T[("Replayable why-trace")]
Y -->|"programmatic signals"| L["Judge-gated compounding loop"]
L -->|"promotes validated knowledge"| R


A request comes in over MCP → the engine retrieves across three tiers → synthesises an
answer where **every claim cites a source** → logs a replayable trace → and feeds
programmatic signals into a loop that promotes validated knowledge back into the corpus.

## 🎬 See it work

A real `kl_ask_global` call against a corpus seeded with the Agentic Product Standard. The
question deliberately has **two halves** — one the corpus can answer, one it can&#x27;t:```jsonc
// → kl_ask_global
{ &quot;question&quot;: &quot;When should I use a multi-agent architecture instead of a single agent,
                and what must every agent ship with according to the standard?&quot; }

// ← response (trimmed)
{
  &quot;answer&quot;: &quot;The provided sources do not specify when to use a multi-agent architecture
             versus a single agent. … According to the Agentic Product Standard, every
             agent must ship with a written Agent Contract [1]. This contract must cover
             ownership, forbidden actions, acceptance criteria, failure modes, escalation
             rules, and logging requirements [1].&quot;,
  &quot;citations&quot;: [
    { &quot;number&quot;: 1, &quot;title&quot;: &quot;Agent Contract requirement&quot;,
      &quot;materialId&quot;: &quot;ba44971b-…&quot;, &quot;score&quot;: 0.46, &quot;origin&quot;: &quot;chunk&quot; }
  ],
  &quot;model&quot;: &quot;google/gemini-3.1-flash-lite-preview&quot;,
  &quot;retrievalMs&quot;: 606, &quot;generationMs&quot;: 890,
  &quot;phases&quot;: [ {&quot;phase&quot;:&quot;embed&quot;,&quot;ms&quot;:552}, {&quot;phase&quot;:&quot;retrieve&quot;,&quot;ms&quot;:37},
              {&quot;phase&quot;:&quot;synth&quot;,&quot;ms&quot;:890}, {&quot;phase&quot;:&quot;output_filter&quot;,&quot;ms&quot;:2} ],
  &quot;telemetryId&quot;: &quot;cc942e54-…&quot;
}

Look at what didn't happen. The half the corpus couldn't support, the model refused to
answer
— "the provided sources do not specify…" — instead of fabricating it. The half it
could support is keyed to a numbered citation you can open. And every answer comes with a
why-trace (phases, model, telemetryId) you can replay. That's the whole pitch in one
call: no source, no claim — and a receipt for every answer.

🆚 How it's different

Plain RAG / memory SDKs AgenticMind
Grounded answers sometimes citation-enforced + post-checked
Why-trace per answer ✗ full decision trace
Self-improving corpus ✗ compounding loop (judge-gated)
Relational verification ✗ graph module
Runs on varies Postgres + pgvector (flagship)

✅ Use it when / 🚫 reach for something else when

Use AgenticMind when:

  • Your agent must answer from trusted sources, and every claim needs a citation.
  • You need a replayable why-trace and a single status (supported / partial /
    unsupported / conflicted / needs_review) you can gate an agent on.
  • Disagreeing or stale sources must be surfaced, not silently resolved.
  • You want governed self-improvement — not silent autonomous memory mutation.
  • You need self-hosting (Postgres-only) and MCP-native access (Claude Code,
    Cursor, LangGraph, OpenAI/Claude Agent SDK, custom agents).

Reach for something else when:

  • You only need simple personalised chat memory (use a memory SDK).
  • You want a hosted API / no-code UI today — AgenticMind is self-hosted infra.
  • You need SSO / SOC2 out of the box (see the security model for what exists).
  • You're optimising for the fastest prototype, not accountable production.

🛠 Agent surface (MCP)

A headless service (apps/server) exposes the engine as MCP tools over
streamable HTTP, with fail-closed per-token bearer auth (scoped, least-privilege):

Tool Scope Purpose
kl_search knowledge:read semantic / keyword passage search
kl_ask_global knowledge:read synthesised answer + citations + a gate-able status (optional intent/facts)
kl_get_material knowledge:read fetch a material by id
kl_graph_neighbors knowledge:read related materials via the knowledge graph
kl_ingest knowledge:write add text (chunked, embedded, distilled into cards, graph-extracted)
kl_forget knowledge:admin delete a material + all derived chunks/cards/graph (inverse of ingest)
kl_signal knowledge:signal emit a programmatic compounding signal on a prior answer
mem_recall memory:read recall beliefs (private ∪ shared); semantic or asOf time-travel
mem_write memory:write record a belief into private memory (bitemporal, revision-aware)
mem_forget memory:write retract one of your own beliefs (soft, bitemporal)

See What counts as knowledge for the Knowledge Unit
contract (what may become stored knowledge), Evals & limits
for what we measure and what we don't claim, docs/knobs.md
for the optional answer-quality knobs (Tier-B faithfulness, contested-sources,
answer policy, source trust), and the security model
(fail-closed auth, tenant RLS, lethal-trifecta analysis, supply chain).

There is no frontend — the only consumers are agents over MCP. The tool logic is
framework-agnostic in packages/shared/src/lib/knowledge/mcp-tools.ts; the host is a
~60-line Web-standard fetch handler served by Node or Bun.

🚀 Quickstart

Run it — no clone (~1 min)

Needs Docker (Compose v2.23+) and an OpenAI-compatible key. One command pulls the
published images, generates secrets, brings up Postgres + server + worker, and
prints a ready-to-paste MCP config — no repo clone, no token minting:```bash
OPENAI_API_KEY=sk-... sh -c "$(curl -fsSL https://raw.githubusercontent.com/Moai-Team-LLC/AgenticMind/main/quickstart.sh)"


The MCP endpoint comes up at `http://localhost:3000/mcp`, authenticated with a
single static bearer (`MCP_API_KEY`, auto-generated). Point Claude Code / Cursor at
it with the `Authorization: Bearer ` header.

**Embeddings run locally by default** — a zero-key, offline, multilingual model
(bge-m3) downloads on first use, so retrieval needs no cloud key. Only the
*synthesis* step needs a chat model: `OPENAI_API_KEY` for OpenAI (the default), or
point `CHAT_BASE_URL` at any OpenAI-compatible endpoint — a local Ollama or vLLM.

&gt; The published Docker image reads `OPENAI_API_KEY` and maps it to the server&#x27;s
&gt; `CHAT_API_KEY` internally; the from-source path below sets `CHAT_API_KEY` directly in
&gt; `.env.local` — same secret, just named for each entry point.

Prefer to read before you run? Same thing, explicit (just the `deploy/` drop-in, no full clone):```bash
mkdir agenticmind &amp;&amp; cd agenticmind
curl -fsSL https://raw.githubusercontent.com/Moai-Team-LLC/AgenticMind/main/deploy/docker-compose.yml -o docker-compose.yml
curl -fsSL https://raw.githubusercontent.com/Moai-Team-LLC/AgenticMind/main/deploy/.env.example       -o .env.example
curl -fsSL https://raw.githubusercontent.com/Moai-Team-LLC/AgenticMind/main/deploy/gen-secrets.sh     -o gen-secrets.sh &amp;&amp; chmod +x gen-secrets.sh
./gen-secrets.sh                   # writes DB password + MCP_API_KEY into .env
# set OPENAI_API_KEY in .env, then:
docker compose up -d

From source (development & contributing)

Requires Docker and Node ≥22.18 (or Bun ≥1.3) — the server and worker run on plain Node or Bun.```bash
git clone https://github.com/Moai-Team-LLC/AgenticMind.git
cd AgenticMind
cp .env.example .env.local # set AUTH_SECRET (+ a chat key OR local Ollama)
./setup.sh # picks npm or bun, starts Postgres, runs migrations
npm run dev # headless MCP server on :3000 (or: bun run dev)


Verify the build with `npm run check` (typecheck + tests) — `bun run check` works too.

In a from-source dev setup the `/mcp` route is fail-closed and accepts a bearer
`typ=&quot;mcp&quot;` HS256 JWT (rather than the static deploy key). The headless server
ships no admin UI — mint one with the issuance script (it reads `DATABASE_URL` +
`AUTH_SECRET` from your `.env.local`):```bash
npm run issue-token -- --label &quot;claude-code&quot; --ttl-days 365   # or: bun run issue-token --label …
# prints the bearer on the last line — capture it, it is not stored in plaintext

Then point an MCP client at http://localhost:3000/mcp with that token as the
Authorization: Bearer … header. (Lint additionally requires Node ≥22.18 — see .nvmrc.)

> Note. The local Docker Postgres has no TLS, so .env.example ships
> DATABASE_SSL=false and DATABASE_URL on host port 5435. For managed Postgres
> (Supabase, RDS, …) that requires SSL, set DATABASE_SSL=true.

🧱 Layout```text

packages/shared/src/lib/knowledge/ ← the tiered engine (the product)
packages/shared/src/lib/ai/ ← chat + embeddings (provider-agnostic; local embeddings by default)
packages/shared/src/database/ ← Drizzle schema + queries (Postgres + pgvector)
apps/server/src/{index,mcp}.ts ← headless MCP host, Node or Bun (agent surface)
apps/worker/src/jobs/knowledge-feedback/ ← Postgres-scheduled compounding sweep
```

Architecture notes. Agent-first and Postgres-only: the graph lives behind a
GraphStore interface (recursive-CTE traversal on Postgres, no extra service),
compounding is driven by programmatic signals, MCP tokens are scoped least-privilege, the
agent principal is slim, and the host is a headless Node/Bun HTTP server. Retrieval is multilingual by
default
— local bge-m3 embeddings cover many languages with zero keys; full-text search
uses the language-agnostic simple config (configurable per deployment).

🌐 The AgenticProduct ecosystem

One standard and five reference implementations you can run — together they close the loop every production agent needs: run → remember → measure, with security as a cross-cutting assurance plane.

Project Role
📐 agentic-product-standard The contract — principles, the autonomy ladder, the harness layers, and eval discipline (plus a Claude Code skill set).
⚙️ AgenticOps Runtime & operations — deployable manifests, scheduling, a durable backlog, a bounded runner, and fleet health.
🧠 AgenticMind (this repo) Knowledge & memory — auditable, self-improving, citation-enforced, over MCP; Postgres-only.
📈 AgenticPerformance Evals & observability — OTel traces, golden-set evals with a CI gate, failure clusters, and the improvement loop.
🌉 AgenticGateway Model & cost plane — one key, measured routing, ceilings, cache, evidence.
🛡️ AgenticAssurance Security & assurance — red-teams any agent (OWASP Agentic + MITRE ATLAS), a toxic-flow graph, and SARIF output.

How they compose. AgenticOps runs the fleet, AgenticMind gives agents auditable knowledge & memory, and AgenticPerformance measures every run with traces and evals — closing the run → remember → measure loop. AgenticGateway is the model plane every LLM call in that loop passes through — one key, eval-measured routing, cost ceilings — and AgenticAssurance red-teams any agent in the loop, with the whole stack conforming to the agentic-product-standard.

See the standard's AgenticMind case study for a layer-by-layer map of how this repo implements the canon.

🤝 Contributing & license

Contributions welcome — see CONTRIBUTING.md. Licensed under Apache-2.0.

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
AgenticMind 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

AgenticMind 怎么在 Claude、Cursor、Gemini CLI 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

AgenticMind 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

AgenticMind 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

AgenticMind 支持哪些客户端?

资料标注支持 Claude、Cursor、Gemini CLI、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

AgenticMind 能提供哪些能力?

资料显示能力标签包括 mcp、agents、memory、knowledge、rag、postgres。具体工具清单以官方文档为准。

AgenticMind 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。