Power your agent
पब्लिशर का अपना URL। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
https://memory.kagura-ai.com/mcpऊपर दिया Claude बटन नाम और URL भरकर Claude खोलता है। पुष्टि आपको वहीं करनी होती है।
claude mcp add --transport http io.github.kagura-ai-memory-cloud https://memory.kagura-ai.com/mcpRun in a terminal.
{ "mcpServers": { "io.github.kagura-ai-memory-cloud": { "command": "npx", "args": [ "-y", "mcp-remote", "https://memory.kagura-ai.com/mcp" ] } }}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.
लॉन्चपब्लिशर से
Your AI forgets everything after each conversation. Kagura fixes that — and gets smarter every time you search.
Most AI memory tools are just vector databases with a chat wrapper. Kagura is different — it implements the full LLM Knowledge Base pattern (Karpathy's LLM Wiki) at team scale:
Persistent memory for AI assistants: store, search, and connect knowledge across conversations.
Workspace (team/org)
├── Context A ("my-project") ← like a folder
│ ├── Memory 1 ← 3-layer: summary / context / content
│ ├── Memory 2
│ └── Neural edges (Hebbian) ← automatic connections
├── Context B ("learning-notes")
│ └── ...
└── Members (Owner/Admin/Member/Viewer)
Karpathy's LLM Wiki pattern describes a 5-layer "living knowledge base" — beyond traditional RAG. Kagura implements all 5 layers at team scale:
Compounding loop: Currently explicit (user/agent calls remember() after synthesizing answers). Auto-write-back of synthesized answers is intentionally opt-in to keep noise low.
Kagura separates precision search and discovery into two independent paths, each optimized for its purpose:
recall() ──→ Hybrid Search (semantic + BM25) ──→ [Reranker] ──→ Precise results
│
└──→ Hebbian Learning (background) ──→ Graph edges grow
│
explore() ──→ Graph Traversal (Neural Memory) ←─────────────────┘ Related discoveries
recall() — Precision search. Hybrid (semantic 60% + BM25 40%) with optional AI reranking. Returns the most relevant memories.explore() — Discovery. Traverses the Neural Memory graph to find related memories that keyword search would miss.recall() silently strengthens edges between co-retrieved memories. No explicit training needed — the graph grows organically as you use the system.This separation is intentional: mixing graph signals into recall degrades precision (validated via benchmarks). Instead, each path does what it's best at.
Data isolation: All data is filtered by workspace_id → context_id → user_id. Memories never leak across boundaries. Single Qdrant collection with payload filtering.
Tech stack: FastAPI (async) · PostgreSQL · Qdrant · Redis · Next.js 16 · OAuth2 · MCP over Streamable HTTP
Vector backend: Qdrant by default. A single-process self-hosted / CLI / edge deployment can instead run the embedded LanceDB backend — "Kagura Lite" (preview) with no separate Qdrant server (KAGURA_VECTOR_BACKEND=lance, cd backend && uv sync --locked --extra lite). Not for multi-worker / SaaS (LanceDB is single-writer). See Deployment → Embedded Vector Backend.
One-line setup:
git clone https://github.com/kagura-ai/memory-cloud.git
cd memory-cloud
./setup.sh
With Claude Code:
git clone https://github.com/kagura-ai/memory-cloud.git
cd memory-cloud
claude # then run /setup
Step-by-step setup:
# 1. Clone
git clone https://github.com/kagura-ai/memory-cloud.git
cd memory-cloud
# 2. Configure environment (generates secrets, prompts for API keys)
(cd backend && python3 -m src.cli.setup_env)
# 3. Start all services
docker compose up -d
# 4. Run migrations
(cd backend && alembic upgrade head)
# 5. Create admin account (interactive — sets password, MFA, API key, embedding provider)
(cd backend && python3 -m src.cli.create_admin)
# Backend API: http://localhost:8080
# Frontend UI: http://localhost:3000
# API docs: http://localhost:8080/redoc
.env.local settings (auto-configured by setup_env):
* Either OPENAI_API_KEY or a running self-hosted inference server (e.g. Ollama) is required for memory features.
Run from
backend/directory. Docker API container must be running.
brew install [email protected] nodesudo apt install docker.io docker-compose-v2 python3.11 nodejs npm.env.local (DATABASE_URL, QDRANT_URL, ENVIRONMENT=production, CORS_ORIGINS) and private values for API_KEY_SECRET, AUDIT_HMAC_KEY, AUDIT_PSEUDO_SALT (openssl rand -hex 32) — the API refuses to start on the defaults or .env.example placeholdersfrontend/.env.example to frontend/.env.local and set:
NEXT_PUBLIC_API_URL — backend URL (default: http://localhost:8080)NEXT_PUBLIC_APP_URL — frontend URL for metadataNEXT_PUBLIC_PLAN_FREE_DISPLAY_NAME / BASIC / PRO / PROMAX — plan display name customization (default: S/M/L/XL)Works with Claude Code, Claude Desktop, Claude Chat, ChatGPT, Gemini, Gemini CLI, and any Streamable-HTTP MCP client.
Claude Code (3 steps):
http://localhost:3000/workspace/integrations/credentials?tab=api-keys to create an API key.mcp.json.example to .mcp.json and fill in your API key (a key created there is scoped to its workspace):cp .mcp.json.example .mcp.json
# Edit .mcp.json — set the API key
.mcp.json.example ships with the all-tools URL. Set "url" to one of:
http://localhost:8080/mcphttp://localhost:8080/mcp?profile=fullAn OAuth client (Claude.ai, Claude Desktop, ChatGPT, Gemini, Cursor, claude mcp add) uses the same /mcp URL and connects to the workspace selected in the web UI; /mcp/w/{workspace_id} pins such a connector to one workspace when you belong to several.
The default URL lists the core memory and context tools (the exact set is under Tool Profiles) and leaves out Sleep, analyses, files, edges, secrets, resources and the agent control plane — they are just not listed — describe_tools names them from inside a session, and most clients let the model call listed tools only, so a task that needs them reconnects with the URL below. Add ?profile=full when your client should see every tool schema up front (the list is about 2.6 times larger). See Tool Profiles.
You: "Remember: our API uses JWT with 1h expiry and refresh token rotation"
→ AI calls remember() — stored permanently
You: "What do we know about auth?"
→ AI calls recall() — finds it instantly, even months later
.mcp.jsonis in.gitignore— never commit it (contains API keys).
Full setup guide — every client, the memory-sync hook, the ready-to-use .claude/ templates, the kagura-memory Claude Code plugin (skills + tool-guardrail hooks), and the WSL2 networking note: MCP Client Setup
72 tools across 14 categories: Guide (guide, the tool manual on demand; describe_tools, the tools the URL left out), Memory (remember / remember_batch / recall / explore …), Agent Substrate (pinned + time-triggered delivery, deterministic list / changes_since, one-call bootstrap, state, measurements, feedback), Agent Control Plane (preview), Neural Edges, Contexts, Tags, Files (R2), Analyses (Memory Analysis), Resources, Secrets (zero-knowledge), Sleep Maintenance, Usage, and API-Key Bindings — each with per-role access control.
Tool-by-tool reference with required roles: MCP Tools Reference
An agent's writes can be listed and undone: changes_since + rollback_session per session (a stateless MCP client can name its own session with _meta["ai.kagura/sessionId"] or a Kagura-Session-Id header), or — for clients without a session id — over a time window of your own writes (by_me=true, since / until); see Which clients get a session id.
A client does not have to list all 72: the default URL above lists the 22 core tools (?profile=full lists everything), ?tools=remember,recall lists exactly the tools you name, and ?add_tools=list_edges lists the core tools plus the ones you name — see Tool Profiles.
In addition to MCP tools, a full REST API is available:
/api/v1/memory/*)/api/v1/contexts/*)/api/v1/agents/*)/api/v1/files/*, up to 100 MiB); legacy /api/v1/attachments/* routes return 410 Gone/api/v1/analyses/*)/api/v1/resources/*)/api/v1/workspaces/*)/api/v1/admin/*)/api/v1/config/secrets/*)Full API documentation: http://localhost:8080/redoc
Two OAuth2 providers are supported:
GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRETGITHUB_CLIENT_ID and GITHUB_CLIENT_SECRETUsers with the same email address across providers share a single account. Password + MFA login is available without any OAuth provider (see Quick Start). An existing account can also add a password from its profile and then sign in with its verified email address and that password; see Deployment → Email + password sign-in.
Plans control per-workspace resource limits (contexts / memories / MCP calls per day). Four tiers ship by default: S (free), M (basic), L (pro) and XL (promax). For self-hosted single-user setups, assign the XL (promax) plan to your workspace — it is the only tier that may create resources, connectors and public contexts (numeric limits are env-overridable; a tier's feature set is not). Defaults, environment-variable overrides, and optional Stripe self-service billing: Deployment → Plan Tiers
This project is designed to be developed with Claude Code and Kagura Memory Cloud itself — pre-configured slash commands, safety hooks, sub-agents, and rules load automatically from .claude/. Setup and the full tooling reference: Contributing → Development with Claude Code
API reference — two complementary entry points:
http://localhost:8080/redoc — auto-generated from FastAPI, always in sync with the running backendConcepts & guides:
KaguraClient (MCP) plus REST clients for resources, files, secrets, workspaces, and agent bootstrap, and a document FileIngestorSee CONTRIBUTING.md for development setup, code style, and PR workflow.
Persistent memory for AI assistants: store, search, and connect knowledge across conversations.
{ "mcpServers": { "io.github.kagura-ai-memory-cloud": { "url": "https://memory.kagura-ai.com/mcp", "headers": {} } }}टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए http कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Kagura Memory Cloud तक HTTP से पहुँचा जाता है।
पिछली जाँच 2026-11-15 को हुई। Persistent memory for AI assistants: store, search, and connect knowledge across conversations.