Ratary Memory Mcp

MCP文档知识

提供方 ontorata

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

Ratary is an open-source AI Brain Platform. The Memory MCP server (ratary) gives coding assistants durable, owner-scoped memory across sessions — hybrid search, knowledge graph traversal, and token-efficient context assembly.

一句话选型结论

按资料字段整理

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

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

工具与能力

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

能力标签

memory development ai coding assistant

支持客户端

适用场景

memorydevelopmentai coding assistant

安装与配置

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

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

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

先想清楚的地方

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

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Ratary Memory Mcp当前 未标注 未标注 未标注 无 未标注
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

服务器档案

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

详细介绍

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

Ratary

Build AI that remembers.

Ratary is the open-source AI Brain Platform — persistent memory,

structured knowledge, and intelligent retrieval for every model and agent you run.

Get started →
Star on GitHub
Website
Docs

Ratary is where AI remembers. · Built by Ontorata

Quick start ·
Ecosystem ·
Architecture ·
How it works ·
Capabilities ·
Docs


The problem

Why does AI forget between sessions?

Every AI session starts from zero.

Your model forgets yesterday's architecture decisions. Your agent drops customer context between runs. Your coding assistant can't recall why you chose Postgres over DynamoDB. Teams paste the same background into Cursor, Claude, ChatGPT, and custom bots — and knowledge still drifts.

Vector databases store chunks. RAG pipelines retrieve documents. Agent frameworks orchestrate tools.

None of them give AI a durable brain.


Why Ratary exists

Why build a brain layer now?

AI models are getting cheaper. Context windows are getting larger. Agents are getting capable.

But AI still forgets.

The bottleneck is no longer reasoning. It's memory — durable, structured, retrievable, and owned by you.

Every serious application eventually needed a database. Every serious AI system will need a brain layer: persistent intelligence that sits between your models and your storage — independent of any single vendor, IDE, or agent framework.

> AI should remember.
> Developers should own that memory.

Ratary exists to be that layer. Applications bring models. Ratary brings the brain.


What Ratary is

What is Ratary?

Ratary is an AI Brain Platform — infrastructure that gives AI:

  • Persistent memory — durable, owner-scoped, versioned
  • Structured knowledge — metadata, relations, graph traversal
  • Intelligent retrieval — hybrid search + bounded context assembly
  • Protocol access — Ratary MCP, REST, optional gRPC

It sits between AI clients and storage. One brain, many surfaces — Cursor, Claude Code, custom agents, enterprise APIs, and remote MCP hosts.

The runnable deployment is Ratary Server — this repository. Ratary is the product; Ratary Server is what you clone and run.

Bring your model. Ratary brings the memory.


Quick start

How do I run Ratary Server locally?

Prerequisites: Node.js 24 · SQL metadata store (pick one — Postgres is the template default)

Path A — PostgreSQL (npm + local or Docker)```bash

git clone https://github.com/ontorata/ratary.git
cd ratary && npm install
cp .env.example .env # Set AUTH_SECRET + DATABASE_URL — see .env.example QUICK START
npm run db:apply-postgres-schema
npm run setup # wire Ratary MCP for Cursor, Claude Code, …
npm run dev


Or use Docker: `docker compose --profile postgres up --build` — see docs/DOCKER.md.

### Path B — Cloudflare D1```bash
git clone https://github.com/ontorata/ratary.git
cd ratary && npm install
cp .env.example .env   # Set AUTH_SECRET + SQL_PROVIDER=d1 + CLOUDFLARE_* / D1_*
npm run db:migrate
npm run setup
npm run dev

Details: docs/GUIDE.md · docs/CONFIGURATION.md

→ API http://localhost:9876 · Swagger /docs

First REST call: bootstrap once to get an API key (aic_...) — see GUIDE — First REST API key.```bash

Save your first memory

curl -X POST http://localhost:9876/api/v1/memory \
-H "Authorization: Bearer aic_YOUR_KEY" \
-H "Content-Type: application/json" \
-d '{"title":"Hello brain","project":"demo","content":"Ratary remembers this."}'


Full guide: **docs/GUIDE.md** · SDK & MCP examples in docs/examples/

### npm packages (`@ratary`)

Client libraries ship on npm under the **`@ratary`** scope — product name, published by Ontorata. No server clone required for SDK, CLI, or hosted MCP.```bash
npm install @ratary/sdk@1.1.0
npx @ratary/mcp-server@1.1.3          # remote REST → stdio MCP
npm install -g @ratary/cli@1.1.0      # operator CLI
Package Version Install Role
@ratary/sdk 1.1.0 npm install @ratary/sdk Typed REST client + client.admin.*
@ratary/cli 1.1.0 npm install -g @ratary/cli Operator commands (admin, connectors)
@ratary/mcp-server 1.1.3 npx @ratary/mcp-server IDE MCP → hosted API

Set RATARY_BASE_URL and RATARY_API_KEY (aic_...). Details: packages/README.md · remote MCP install.


Ecosystem

Which repository owns what?

The Visual architecture diagram shows logical layers inside Ratary Server. This diagram shows repository and product relationships — what ships in this repo, what connects to it, and what lives in sibling Ontorata repositories. Both views describe the same platform from different angles.

Throughout this README, Ratary MCP means the official memory MCP implementation (stdio in this repo · npm @ratary/mcp-server for hosted REST). It is not the same as Ontorata MCP (ecosystem gateway — separate repo).```text
┌─────────────────────────────────────────────────────────────┐
│ Ratary Cloud (opt-in) │
│ optional hosted deployment · not this repo │
└──────────────────────────────┬──────────────────────────────┘
│
┌──────────────────────────────▼──────────────────────────────┐
│ Ratary Server ← ontorata/ratary (this repo) │
└──────────────────────────────┬──────────────────────────────┘
│ │ │
▼ ▼ ▼
@ratary/sdk @ratary/cli @ratary/mcp-server
(SDK) (CLI) (Ratary MCP · npm)
│ │ │
└──────────────┴──────────────┘
│
┌─────────────────────┴─────────────────────┐
▼ ▼ ▼
Ontorata MCP Ontorata Studio Ontory Runtime
ontorata/ontorata-mcp ontorata/Ontorata-Studio ontorata/ontory-runtime
ecosystem product ecosystem product (ADR-2119; was ontorata/ontory)


**Infrastructure** (ships from `ontorata/ratary` — server plus client packages):

| Component | Repository | Role |
|-----------|------------|------|
| **Ratary Server** | ontorata/ratary | Memory engine — REST, persistence, Ratary MCP stdio. **You run this.** |
| **Ratary SDK** | npm `@ratary/sdk` · `packages/sdk` | Typed REST client for Ratary Server. |
| **Ratary CLI** | npm `@ratary/cli` · `packages/cli` | Operator commands; delegates to Ratary SDK. |
| **Ratary MCP** | npm `@ratary/mcp-server` · stdio in repo | Memory MCP — full stdio in clone · npm proxy for hosted REST. |

**Ecosystem products** (separate repositories — connect to Ratary Server; not bundled here):

| Product | Repository | Role |
|---------|------------|------|
| **Ontorata MCP** | ontorata/ontorata-mcp | Ecosystem MCP gateway — Ratary MCP plus additional Ontorata tools. |
| **Ontorata Studio** | ontorata/Ontorata-Studio | Operator UI — uses `@ratary/sdk` only. |
| **Ontory** | ontorata/ontory-runtime | Ontory Runtime — AI orchestration (ADR-2119). Legacy URL `ontorata/ontory` redirects. |

Ratary Server **does not depend** on ecosystem product repositories.

### Ratary MCP vs Ontorata MCP

*Which MCP should I install?*

| | **Ratary MCP** | **Ontorata MCP** |
|---|----------------|------------------|
| **Layer** | Ratary infrastructure | Ontorata ecosystem product |
| **What it is** | Official memory protocol for Ratary Server | Ecosystem gateway for Ontorata products |
| **Scope** | Memory — CRUD, search, context, graph | Ratary memory plus additional Ontorata tools |
| **Repository** | ontorata/ratary · npm `@ratary/mcp-server` | ontorata/ontorata-mcp |
| **Typical `mcp.json` key** | `ratary` | `ontorata` |

Use **Ratary MCP** for direct memory access. Use **Ontorata MCP** for one MCP entry point across the Ontorata stack. Both use **Ratary Server** as source of truth.

---

## What Ratary is not

*How is Ratary different from alternatives?*

| | Vector DB | Memory API | RAG | Agent framework | **Ratary** |
|---|:---:|:---:|:---:|:---:|:---:|
| **Primary job** | Similarity search | Key-value recall | Document Q&A | Tool orchestration | **Durable AI memory** |
| **Structured knowledge & graph** | ❌ | ⚠️ | ❌ | ⚠️ | ✅ |
| **MCP-native IDE integration** | ❌ | ⚠️ | ❌ | ⚠️ | ✅ |
| **Token-efficient context assembly** | ❌ | ⚠️ | ❌ | ⚠️ | ✅ |
| **Self-host & data sovereignty** | ✅ | ⚠️ | ⚠️ | ⚠️ | ✅ |
| **Clear agent boundary** | N/A | ⚠️ | N/A | ❌ bundled | ✅ substrate only |

Ratary **complements** your stack — it does not replace pgvector, LangGraph, or your agent of choice. See the **Capability matrix** for a feature-level comparison.

Why not just pgvector, Mem0, Letta, LangGraph, or RAG?

| If you only use… | You get… | What you miss |
|------------------|----------|---------------|
| **pgvector** | Embedding similarity | Structured memory, graph, MCP, context packing |
| **Mem0** | Fast hosted memory API | Full self-host, hybrid retrieval, enterprise adapters |
| **Letta** | Agent + memory bundled | Your agent stays yours — Ratary is substrate, not runtime |
| **LangGraph** | Workflow & tool routing | Shared durable memory across sessions and clients |
| **RAG** | Document chunks | Evolving memory — decisions, handoffs, relations |

---

## Visual architecture

*How is Ratary Server structured internally?*

This diagram shows the **logical internal architecture** of Ratary — how memory, knowledge, retrieval, and storage layers compose inside the platform. It is **not** a repository or product map.```
        ┌─────────────────────────────────────────┐
        │           Your AI applications           │
        │  Cursor · Claude · Agents · REST · MCP   │
        └────────────────────┬────────────────────┘
                             │
                    MCP · REST · gRPC
                             │
        ┌────────────────────▼────────────────────┐
        │     Ratary Server (logical layers)       │
        │  ┌─────────┐ ┌──────────┐ ┌───────────┐ │
        │  │ Memory  │ │Knowledge │ │ Retrieval │ │
        │  └────┬────┘ └────┬─────┘ └─────┬─────┘ │
        │       └───────────┴─────────────┘       │
        │         Context · Learning · Protocols   │
        └────────────────────┬────────────────────┘
                             │
        ┌────────────────────▼────────────────────┐
        │     Pluggable storage (your choice)      │
        │  Postgres · Supabase · MariaDB · D1 · pgvector · Neo4j · │
        │  R2/S3/MinIO · OpenSearch · ClickHouse · …        │
        └─────────────────────────────────────────┘

Search browses. Retrieval injects context. Embedding enriches asynchronously — never on the CRUD hot path.

Details: docs-ai → products/ratary/roadmap/ARCHITECTURE.md

For repository and product relationships (SDK, CLI, Ratary MCP, Ontorata ecosystem repos), see Ecosystem — a separate diagram, same platform, different perspective.


How Ratary works

What happens to a memory after you save it?```
Write Enrich Retrieve Learn Reuse
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
Save via Summarize, Rank & pack Signals, Same memory
Ratary MCP/REST embed, link context for consolidate, powers every
relations your prompt evolve client


1. **Write** — Persist memory through Ratary MCP or REST.
2. **Enrich** — Summarize, embed, and relate — asynchronously.
3. **Retrieve** — Assemble the smallest useful context slice.
4. **Learn** — Optional signals and consolidation improve recall over time.
5. **Reuse** — One brain across IDEs, agents, and APIs.

---

## Core capabilities

*What can Ratary Server do today?*

### Memory intelligence
Durable memories with summaries, codenames, favorites, archives, and handoffs. Version history with restore and merge — built for long-running work, not chat logs.

### Knowledge
Semantic enrichment, relation linking, and graph traversal. Memory becomes navigable knowledge — not a flat pile of notes.

### Retrieval
Hybrid search across SQL, vectors, lexical index, and graph. Separate **browse** from **inject**. Optional precision modes (hybrid, semantic, fulltext, title) when you need more control.

### Reasoning support
Progressive retrieval, token budgets, and summary-first context assembly — typically **~85% fewer tokens** than dumping full memory bodies into prompts.

### Learning
Quality signals, consolidation, and compression — optional pipelines that improve the brain over time without retraining your model.

### External agent support
Capability manifests, workspace scoping, and **28 Ratary MCP tools**. External agents discover what the brain can do; Ratary never embeds agent reasoning — see What Ratary is not.

### Platform
Pluggable adapters: choose **SQL metadata** (Postgres, Supabase, MariaDB/MySQL, D1, TiDB/Cockroach) plus optional pgvector, R2/S3/MinIO, Azure Blob, GCS, Meilisearch, OpenSearch, Neo4j, Redis, DuckDB, ClickHouse. Same application code for every backend.

**Self-host stacks:** docs/DOCKER.md — `postgres` or `enterprise` (MariaDB + MinIO + Redis) profiles.

### Cloud & enterprise
Self-host, deploy to Vercel, or run a control plane with metering and federation. RBAC workspaces, audit trails, SSO, and policy hooks — opt-in when you need them.

### Observability
OpenTelemetry, Prometheus metrics, SLO dashboards, and cost visibility for production brains.

### Developer experience
OpenAPI, npm **`@ratary/sdk@1.1.0`** · **`@ratary/cli@1.1.0`** · **`@ratary/mcp-server@1.1.3`** — and one-command IDE setup (`npm run setup`).

### Knowledge fabric (opt-in)
Ingest from external systems of record — **Notion** (live on hosted prod), **Confluence**, **Google Drive**, **SharePoint**, and **Teams** connectors (code complete · enable per connector via env). Webhook HMAC, incremental sync, provenance on memories. Flags: `KNOWLEDGE_FABRIC_ENABLED` + `CONNECTOR_SYNC_ENABLED`. Guides: Knowledge fabric · Production enable · Phases 32–34 in docs-ai.

---

## Use cases

*Who is Ratary for?*

| | What you build | What Ratary provides |
|---|----------------|---------------------|
| **Developer AI** | Coding assistants across IDEs and sessions | Persistent project memory, MCP tools, handoffs |
| **Enterprise search** | Internal knowledge discovery | Hybrid retrieval over structured memory, not just files |
| **Customer support** | AI that handles tickets | Durable customer context without re-prompting every thread |
| **Knowledge management** | Team second brain | Graph-linked memories, codenames, relations, summaries |
| **Autonomous agents** | Multi-agent systems | Shared memory layer with workspace and agent scoping |
| **Personal AI** | Private assistant you own | Self-hosted, exportable, sovereign data |

---

## Capability matrix

*How does Ratary compare feature-by-feature?*

For category positioning, see **What Ratary is not**.

| Capability | Ratary | Vector DB | Memory API | RAG | Agent framework |
|------------|:------:|:---------:|:----------:|:---:|:---------------:|
| Persistent structured memory | ✅ | ❌ | ⚠️ | ❌ | ⚠️ |
| MCP-native | ✅ | ❌ | ⚠️ | ❌ | ⚠️ |
| Hybrid SQL + vector + graph | ✅ | ⚠️ | ⚠️ | ⚠️ | ⚠️ |
| Token-efficient context assembly | ✅ | ❌ | ⚠️ | ❌ | ⚠️ |
| Knowledge graph & relations | ✅ | ❌ | ⚠️ | ❌ | ⚠️ |
| Self-host sovereignty | ✅ | ✅ | ⚠️ | ⚠️ | ⚠️ |
| Agent boundary (bring your agent) | ✅ | N/A | ⚠️ | N/A | ❌ |
| Enterprise storage adapters | ✅ | ✅ | ⚠️ | ⚠️ | ⚠️ |

---

## Documentation

*Where do I read next?*

### Engineering knowledge (internal)

Architecture, ADRs, roadmap, phases, design history, and reviews live in the Ontorata **Knowledge OS**:

**https://github.com/ontorata/docs-ai** → `products/ratary/`

### Operator / developer guides (this repository)

**Ratary Server** (`ontorata/ratary` — this repository):

docs/GUIDE.md · Setup, daily usage, Ratary MCP configuration
docs/install/README.md · Per-harness MCP / plugin installation
docs/DOCKER.md · Container & Compose self-host
docs/CONFIGURATION.md · Environment variables — what each flag does
docs/examples/ · MCP and IDE config templates
MCP/README.md · Ratary MCP — stdio and `@ratary/mcp-server`
packages/README.md · npm packages — install, env, publish
.env.example · Env template — meanings in docs/CONFIGURATION.md
docs/PRODUCTION-ENABLE.md · Hosted deploy — knowledge fabric on Vercel
docs/OPS-PRODUCTION-VERIFY.md · Production ops checklist — `npm run ops:verify-production`
docs/MCP-CHATGPT-OAUTH.md · ChatGPT MCP OAuth + Keycloak IdP runbook
MCP/submission/directory-status.md · MCP directory listing status
docs/ENTERPRISE-MODULES.md · Enterprise flags (opt-in)
CHANGELOG.md · Release notes and version map
SECURITY.md · Vulnerability reporting
ontorata/docs-ai · Architecture · ADR · phases · evidence (Knowledge OS)

**Canonical hosted API:** `https://ratary.ontorata.com` (self-host uses your own base URL).

**Ontorata ecosystem** (separate repositories — not in this tree):

ontorata/ontorata-mcp · Ontorata MCP — ecosystem gateway
ontorata/Ontorata-Studio · Ontorata Studio — operator UI (setup)

---

## Roadmap

*What is shipping when?*

**Canonical roadmap / phase history:** ontorata/docs-ai → `products/ratary/roadmap/` · `products/ratary/phases/`

Organized by direction — not sprints. Phases **1–31** are implemented in code (gates PASS); platform modules stay **opt-in via env** unless noted.

| | Themes | Code | Ops (prod) | Primary repository |
|---|--------|:----:|:----------:|-------------------|
| **Today (v1.0)** | Ratary MCP + REST, hybrid/graph retrieval, peer SQL, Docker, npm `@ratary/sdk@1.1.0` · `@ratary/mcp-server@1.1.3`, remote MCP, Ontorata Studio. **Platform (opt-in):** knowledge fabric (Notion/Confluence/Drive/SharePoint/Teams live), universal memory fabric (Phase 32), Neptune traversal (Phase 33), federation, global intelligence | ✅ | Partial | `ontorata/ratary` |
| **Ops (now)** | Prod connector creds · MCP directory follow-ups · ChatGPT OAuth IdP (Keycloak) | ✅ | ⏳ | `ontorata/ratary` |

**Ops status (2026-07-19):** Notion + fabric/federation flags on Vercel ✅ · D1 `db:migrate` ✅ · SDK codegen CI ✅ (workflow) · Confluence/Drive/SharePoint/Teams creds ⏳ (owner secrets) · Keycloak IdP ⏳ (`auth.ontorata.com` → deploy Render; prod uses Smithery API-key mode until OAuth enabled) · MCP listings mostly **Listed** (directory-status.md). Verify: `npm run ops:verify-production` · OPS-PRODUCTION-VERIFY.md

Enterprise modules ship **opt-in via environment flags** on Ratary Server — defaults stay lean. See ENTERPRISE-MODULES.md and CONFIGURATION.md.

---

## Vision

*What is Ratary building toward?*

Today every application has a database.

Tomorrow every AI will have a brain.

**Ratary is building that layer** — open, portable, self-hostable, and protocol-native. Not another chat wrapper. Not another vector dump. Infrastructure for persistent intelligence.

Knowledge should **accumulate**. Boundaries should be **respected**. Agents should stay **coherent across time**.

If you're building AI that lasts longer than a single prompt — **build on Ratary**.

Bring your model. Bring your agent. Ratary brings the brain.

Ratary · where AI remembers · Ontorata · MIT License

---

## Contributing

*How do I contribute?*

**Ratary Server** (this repo): fork ontorata/ratary → branch → `npm run lint && npm run build && npm test` → PR to `ontorata/ratary`.

**Standard PR gate:**```bash
npm run lint && npm run build && npm test

Org-memory / recall changes (maintainers with .ai/ workspace): run the full gate before merge — see docs/RATARY-VALIDATION-RUNBOOK.md:```bash
npm run ci:ratary-validation


**Production ops changes** (Vercel env, connectors, OAuth): see docs/OPS-PRODUCTION-VERIFY.md:```bash
npm run ops:verify-production

Extended governance (.ai/ phases, ADRs) lives in the development mirror — optional for contributors; docs-only and standard PRs to ontorata/ratary are welcome without the mirror.

Ontorata MCP and Ontorata Studio accept contributions in their own repositories — not via this repo.

Questions: hello@ontorata.com

常见问题

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

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

Ratary Memory Mcp 怎么在 Claude、Cursor、Codex 里配置?

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

Ratary Memory Mcp 收费吗?

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

Ratary Memory Mcp 需要 API Key 吗?

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

Ratary Memory Mcp 支持哪些客户端?

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

Ratary Memory Mcp 能提供哪些能力?

资料显示能力标签包括 memory、development、ai coding assistant。具体工具清单以官方文档为准。

Ratary Memory Mcp 需要什么运行环境?

运行时为 Cross-platform。

热门专题

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

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