Power your agent
คำสั่งของผู้เผยแพร่เอง ไม่ใช่เอนด์พอยต์ของ PlugMCP
Host a copy with our keys and logs.
npx -y @ratary/[email protected]Claude Code ไม่มีลิงก์ติดตั้งสำหรับคำสั่งแบบโลคัล ให้คัดลอกคำสั่งด้านล่างแล้วรันในเทอร์มินัล
RATARY_API_KEY=<secret> RATARY_BASE_URL=<value> claude mcp add io.github.ontorata-ratary -- npx -y @ratary/mcp-server@1.1.1รันในเทอร์มินัล
{ "mcpServers": { "io.github.ontorata-ratary": { "command": "npx", "args": [ "-y", "@ratary/[email protected]" ], "env": { "RATARY_API_KEY": "<secret>", "RATARY_BASE_URL": "<value>" } } }}claude_desktop_config.json
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
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.
Persistent coding memory for AI assistants. MCP stdio, hybrid search, graph, context.
Vector databases store chunks. RAG pipelines retrieve documents. Agent frameworks orchestrate tools.
None of them give AI a durable brain.
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 is Ratary?
Ratary is an AI Brain Platform — infrastructure that gives AI:
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.
How do I run Ratary Server locally?
Ratary is the product. Ratary Server is the open-source deployment you run — ontorata/ratary (this repository). @ratary/sdk, @ratary/cli, and Ratary MCP connect to it; sibling Ontorata products use the same source of truth.
Prerequisites: Node.js 24 · SQL metadata store (pick one — Postgres is the template default)
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.
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.
# 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/
@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.
npm install @ratary/[email protected]
npx @ratary/[email protected] # remote REST → stdio MCP
npm install -g @ratary/[email protected] # operator CLI
Set RATARY_BASE_URL and RATARY_API_KEY (aic_...). Details: packages/README.md · remote MCP install.
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).
┌─────────────────────────────────────────────────────────────┐
│ 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):
Ecosystem products (separate repositories — connect to Ratary Server; not bundled here):
Ratary Server does not depend on ecosystem product repositories.
Which MCP should I install?
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.
How is Ratary different from alternatives?
Ratary complements your stack — it does not replace pgvector, LangGraph, or your agent of choice. See the Capability matrix for a feature-level comparison.
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.
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
What can Ratary Server do today?
Durable memories with summaries, codenames, favorites, archives, and handoffs. Version history with restore and merge — built for long-running work, not chat logs.
Semantic enrichment, relation linking, and graph traversal. Memory becomes navigable knowledge — not a flat pile of notes.
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.
Progressive retrieval, token budgets, and summary-first context assembly — typically ~85% fewer tokens than dumping full memory bodies into prompts.
Quality signals, consolidation, and compression — optional pipelines that improve the brain over time without retraining your model.
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.
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.
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.
OpenTelemetry, Prometheus metrics, SLO dashboards, and cost visibility for production brains.
OpenAPI, npm @ratary/[email protected] · @ratary/[email protected] · @ratary/[email protected] — and one-command IDE setup (npm run setup).
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.
Who is Ratary for?
How does Ratary compare feature-by-feature?
For category positioning, see What Ratary is not.
Where do I read next?
Architecture, ADRs, roadmap, phases, design history, and reviews live in the Ontorata Knowledge OS:
https://github.com/ontorata/docs-ai → products/ratary/
Ratary Server (ontorata/ratary — this repository):
Canonical hosted API: https://ratary.ontorata.com (self-host uses your own base URL).
Ontorata ecosystem (separate repositories — not in this tree):
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.
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.
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.
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:
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:
npm run ci:ratary-validation
Production ops changes (Vercel env, connectors, OAuth): see docs/OPS-PRODUCTION-VERIFY.md:
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: [email protected]
Persistent coding memory for AI assistants. MCP stdio, hybrid search, graph, context.
{ "mcpServers": { "io.github.ontorata-ratary": { "command": "npx", "args": [ "-y", "@ratary/[email protected]" ], "env": { "RATARY_API_KEY": "<secret>", "RATARY_BASE_URL": "<value>" } } }}เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ผู้เผยแพร่ระบุตัวแปรสภาพแวดล้อมเหล่านี้: RATARY_API_KEY, RATARY_BASE_URL
Ratary Memory MCP ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-10 Persistent coding memory for AI assistants. MCP stdio, hybrid search, graph, context.