# ontorata/ratary [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/ontorata/ratary  
**GitHub Stars:** 1  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/ontorata-ratary

## Description
Persistent coding memory for AI assistants — hybrid search, knowledge graph, token-efficient context. MCP stdio (28 tools), npm @ratary/mcp-server, optional remote Streamable HTTP. Self-host D1, Postgres, MariaDB, or Docker.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "ratary": {
    "command": "npx",
    "args": ["-y","@ratary/mcp-server@1.1.3"],
    "env": {
      "AUTH_SECRET": "",
      "DATABASE_URL": "",
      "SQL_PROVIDER": "",
      "RATARY_BASE_URL": "",
      "RATARY_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `AUTH_SECRET`, `DATABASE_URL`, `SQL_PROVIDER`, `RATARY_BASE_URL`, `RATARY_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What ontorata/ratary MCP server does

The ontorata/ratary MCP server connects AI clients to Ratary, an open-source memory platform for persistent AI context. It is intended for assistants and agents that need to retain information between sessions instead of relying only on the current conversation or manually supplied documents.

Ratary stores durable, owner-scoped, versioned memory alongside structured knowledge. Records can include metadata and relationships, allowing applications to retrieve related information and traverse a knowledge graph. The platform also provides hybrid search and bounded context assembly so retrieved information can be selected for an agent's available context.

The repository contains Ratary Server, which exposes REST, persistence, and a Ratary MCP stdio implementation. The project also publishes client packages, including `@ratary/mcp-server`, which connects an IDE MCP client to a Ratary API over stdio.

## How it works

A local deployment runs on Node.js 24 and uses a SQL metadata store. PostgreSQL is the documented template default, while Cloudflare D1 is also supported in the quick-start instructions. The current description additionally identifies MariaDB and Docker as deployment options.

For a self-hosted setup, the MCP layer operates against the Ratary Server instance. The server exposes an API at `http://localhost:9876` in the local example, with Swagger documentation at `/docs`. A bootstrap step creates an API key beginning with `aic_`; clients then authenticate with that key.

The npm MCP package provides another path: it runs as a stdio process and sends requests to a hosted or self-hosted Ratary REST API. Configure the target with `RATARY_BASE_URL` and authenticate with `RATARY_API_KEY`.

## Setup and configuration

The repository quick start requires Node.js 24, a SQL metadata store, and an environment file. PostgreSQL setup uses `DATABASE_URL` and `AUTH_SECRET`, applies the PostgreSQL schema, runs setup, and starts the development server. The D1 path sets `SQL_PROVIDER=d1` and the relevant Cloudflare or D1 configuration before running migrations.

The documented npm command is:

```bash
npx -y @ratary/mcp-server@1.1.3
```

That package requires `RATARY_BASE_URL` and `RATARY_API_KEY` to connect to the API. The repository also documents `npm run setup` for wiring Ratary MCP to clients such as Cursor and Claude Code.

## Tools and capabilities

The listing describes 28 MCP tools. Supported platform capabilities include:

- Saving and retrieving persistent memory
- Hybrid search across stored knowledge
- Metadata and relationship handling
- Knowledge-graph traversal
- Token-conscious context assembly
- REST and MCP access to the same memory layer
- Optional remote Streamable HTTP access

These capabilities suit coding assistants, project-specific agents, and applications that need one durable memory source across multiple models or client surfaces.

## Limitations and notes

The material does not provide the names or schemas of the 28 MCP tools, so tool-level parameters cannot be evaluated here. A SQL metadata store is required for the self-hosted server, and the database choice changes the setup steps. The npm MCP process is a client adapter to a Ratary API; it does not replace the server or database. Remote Streamable HTTP is described as optional, while the repository's native implementation is stdio.

Ratary is self-hostable and released under the MIT license. The provided material does not describe hosted-service pricing or service-level guarantees.

_Full upstream README: https://allmcps.com/mcp/ontorata-ratary/readme_